{"version":3,"file":"chunks/8405.fe71c20507ce26324edc.min.js","mappings":";8HAAA,IAAIA,EAAM,CACT,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,KAED,aAAc,CACb,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,KACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,KAED,iBAAkB,CACjB,MACA,EACA,KAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,KAED,UAAW,CACV,MACA,EACA,KAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,KAED,aAAc,CACb,KACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,KACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,KACA,EACA,MAED,iBAAkB,CACjB,KACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,oBAAqB,CACpB,KACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,KACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,KACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,KACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,KACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,KACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,KAED,oBAAqB,CACpB,KACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,KAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,KAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,KAED,oBAAqB,CACpB,MACA,EACA,MAED,aAAc,CACb,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,KAED,iBAAkB,CACjB,MACA,EACA,KAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MAED,UAAW,CACV,MACA,EACA,MAED,sBAAuB,CACtB,MACA,EACA,MAED,eAAgB,CACf,MACA,EACA,MAED,iBAAkB,CACjB,MACA,EACA,MA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CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,KAED,aAAc,CACb,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,WAAY,CACX,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,gBAAiB,CAChB,MACA,IACA,MAED,gBAAiB,CAChB,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,IAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,aAAc,CACb,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,cAAe,CACd,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,KAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,eAAgB,CACf,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,WAAY,CACX,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,WAAY,CACX,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,WAAY,CACX,MACA,IACA,MAED,gBAAiB,CAChB,MACA,IACA,KAED,WAAY,CACX,MACA,IACA,MAED,aAAc,CACb,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,eAAgB,CACf,MACA,IACA,KAED,UAAW,CACV,KACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,gBAAiB,CAChB,MACA,IACA,MAED,UAAW,CACV,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,MAED,aAAc,CACb,MACA,IACA,OAGF,SAASC,EAAoBC,GAC5B,IAAIC,EAAoBC,EAAEJ,EAAKE,GAC9B,OAAOG,QAAQC,UAAUC,MAAK,WAC7B,IAAIC,EAAI,IAAIC,MAAM,uBAAyBP,EAAM,KAEjD,MADAM,EAAEE,KAAO,mBACHF,CACP,IAGD,IAAIG,EAAMX,EAAIE,GAAMU,EAAKD,EAAI,GAC7B,OAAON,QAAQ4e,IAAIte,EAAIoN,MAAM,GAAG/N,IAAIG,EAAoBK,IAAID,MAAK,WAChE,OAAOJ,EAAoBU,EAAED,EAAI,GAClC,GACD,CACAX,EAAoBa,KAAO,WAAa,OAAOC,OAAOD,KAAKd,EAAM,EACjEC,EAAoBW,GAAK,MACzBI,EAAOC,QAAUhB,C","sources":["webpack://@patternslib/patternslib/./node_modules/@fullcalendar/core/locales/ lazy ^\\.\\/.*\\.js$ namespace object","webpack://@patternslib/patternslib/./.modernizrrc.js","webpack://@patternslib/patternslib/./src/core/mockup-parser.js","webpack://@patternslib/patternslib/./src/core/base.js","webpack://@patternslib/patternslib/./src/core/dom.js","webpack://@patternslib/patternslib/./src/core/events.js","webpack://@patternslib/patternslib/./src/core/i18n.js","webpack://@patternslib/patternslib/./src/core/jquery-ext.js","webpack://@patternslib/patternslib/./src/core/logging.js","webpack://@patternslib/patternslib/./src/core/parser.js","webpack://@patternslib/patternslib/./src/core/polyfills.js","webpack://@patternslib/patternslib/./src/core/registry.js","webpack://@patternslib/patternslib/./src/core/store.js","webpack://@patternslib/patternslib/./src/core/utils.js","webpack://@patternslib/patternslib/./src/pat/ajax/ajax.js","webpack://@patternslib/patternslib/./src/pat/close-panel/close-panel.js","webpack://@patternslib/patternslib/./src/pat/date-picker/date-picker.js","webpack://@patternslib/patternslib/./src/pat/display-time/display-time.js","webpack://@patternslib/patternslib/./src/pat/inject/inject.js","webpack://@patternslib/patternslib/./src/pat/markdown/markdown.js","webpack://@patternslib/patternslib/./src/pat/scroll/scroll.js","webpack://@patternslib/patternslib/./src/pat/tooltip/tooltip.js","webpack://@patternslib/patternslib/./src/globals.js","webpack://@patternslib/patternslib/./src/core/push_kit.js","webpack://@patternslib/patternslib/./src/pat/auto-scale/auto-scale.js","webpack://@patternslib/patternslib/./src/lib/input-change-events.js","webpack://@patternslib/patternslib/./src/pat/auto-submit/auto-submit.js","webpack://@patternslib/patternslib/./src/pat/auto-suggest/auto-suggest.js","webpack://@patternslib/patternslib/./src/pat/autofocus/autofocus.js","webpack://@patternslib/patternslib/./src/pat/breadcrumbs/breadcrumbs.js","webpack://@patternslib/patternslib/./src/pat/bumper/bumper.js","webpack://@patternslib/patternslib/./src/pat/modal/modal.js","webpack://@patternslib/patternslib/./src/pat/calendar/calendar.js","webpack://@patternslib/patternslib/./src/pat/carousel/carousel.js","webpack://@patternslib/patternslib/./src/pat/checklist/checklist.js","webpack://@patternslib/patternslib/./src/pat/clone/clone.js","webpack://@patternslib/patternslib/./src/pat/collapsible/collapsible.js","webpack://@patternslib/patternslib/./src/pat/colour-picker/colour-picker.js","webpack://@patternslib/patternslib/./src/pat/datetime-picker/datetime-picker.js","webpack://@patternslib/patternslib/./src/pat/depends/depends.js","webpack://@patternslib/patternslib/./src/pat/equaliser/equaliser.js","webpack://@patternslib/patternslib/./src/pat/expandable-tree/expandable-tree.js","webpack://@patternslib/patternslib/./src/pat/focus/focus.js","webpack://@patternslib/patternslib/./src/pat/form-state/form-state.js","webpack://@patternslib/patternslib/./src/pat/forward/forward.js","webpack://@patternslib/patternslib/./src/pat/fullscreen/fullscreen-close.js","webpack://@patternslib/patternslib/./src/pat/fullscreen/fullscreen.js","webpack://@patternslib/patternslib/./src/pat/gallery/gallery.js","webpack://@patternslib/patternslib/./src/pat/image-crop/image-crop.js","webpack://@patternslib/patternslib/./src/pat/legend/legend.js","webpack://@patternslib/patternslib/./src/pat/masonry/masonry.js","webpack://@patternslib/patternslib/./src/pat/menu/menu.js","webpack://@patternslib/patternslib/./src/pat/navigation/navigation.js","webpack://@patternslib/patternslib/./src/pat/notification/notification.js","webpack://@patternslib/patternslib/./src/pat/push/push.js","webpack://@patternslib/patternslib/./src/pat/scroll-box/scroll-box.js","webpack://@patternslib/patternslib/./src/pat/selectbox/selectbox.js","webpack://@patternslib/patternslib/./src/core/url.js","webpack://@patternslib/patternslib/./src/core/remove.js","webpack://@patternslib/patternslib/./src/pat/slides/slides.js","webpack://@patternslib/patternslib/./src/pat/sortable/sortable.js","webpack://@patternslib/patternslib/./src/pat/stacks/stacks.js","webpack://@patternslib/patternslib/./src/pat/subform/subform.js","webpack://@patternslib/patternslib/./src/pat/switch/switch.js","webpack://@patternslib/patternslib/./src/pat/syntax-highlight/syntax-highlight.js","webpack://@patternslib/patternslib/./src/pat/tabs/tabs.js","webpack://@patternslib/patternslib/./src/pat/toggle/toggle.js","webpack://@patternslib/patternslib/./src/pat/validation/validation.js","webpack://@patternslib/patternslib/./src/pat/zoom/zoom.js","webpack://@patternslib/patternslib/./src/pat/minimalpattern/minimalpattern.js","webpack://@patternslib/patternslib/./src/patterns.js","webpack://@patternslib/patternslib/./node_modules/moment/locale/ lazy ^\\.\\/.*\\.js$ namespace object"],"sourcesContent":["var map = {\n\t\"./af.global.js\": [\n\t\t35794,\n\t\t7,\n\t\t5794\n\t],\n\t\"./af.js\": [\n\t\t31294,\n\t\t9,\n\t\t1294\n\t],\n\t\"./ar-dz.global.js\": [\n\t\t93244,\n\t\t7,\n\t\t3244\n\t],\n\t\"./ar-dz.js\": [\n\t\t43904,\n\t\t9,\n\t\t3904\n\t],\n\t\"./ar-kw.global.js\": [\n\t\t50548,\n\t\t7,\n\t\t548\n\t],\n\t\"./ar-kw.js\": [\n\t\t76517,\n\t\t9,\n\t\t6517\n\t],\n\t\"./ar-ly.global.js\": [\n\t\t46974,\n\t\t7,\n\t\t6974\n\t],\n\t\"./ar-ly.js\": [\n\t\t3698,\n\t\t9,\n\t\t3698\n\t],\n\t\"./ar-ma.global.js\": [\n\t\t36589,\n\t\t7,\n\t\t6589\n\t],\n\t\"./ar-ma.js\": [\n\t\t67950,\n\t\t9,\n\t\t7950\n\t],\n\t\"./ar-sa.global.js\": [\n\t\t39200,\n\t\t7,\n\t\t9200\n\t],\n\t\"./ar-sa.js\": [\n\t\t79405,\n\t\t9,\n\t\t9405\n\t],\n\t\"./ar-tn.global.js\": [\n\t\t75531,\n\t\t7,\n\t\t5531\n\t],\n\t\"./ar-tn.js\": [\n\t\t40239,\n\t\t9,\n\t\t239\n\t],\n\t\"./ar.global.js\": [\n\t\t50676,\n\t\t7,\n\t\t676\n\t],\n\t\"./ar.js\": [\n\t\t36030,\n\t\t9,\n\t\t6030\n\t],\n\t\"./az.global.js\": [\n\t\t33675,\n\t\t7,\n\t\t3675\n\t],\n\t\"./az.js\": [\n\t\t33469,\n\t\t9,\n\t\t3469\n\t],\n\t\"./bg.global.js\": [\n\t\t30591,\n\t\t7,\n\t\t591\n\t],\n\t\"./bg.js\": [\n\t\t60196,\n\t\t9,\n\t\t196\n\t],\n\t\"./bn.global.js\": [\n\t\t16263,\n\t\t7,\n\t\t6263\n\t],\n\t\"./bn.js\": [\n\t\t6998,\n\t\t9,\n\t\t6998\n\t],\n\t\"./bs.global.js\": [\n\t\t59491,\n\t\t7,\n\t\t9491\n\t],\n\t\"./bs.js\": [\n\t\t11463,\n\t\t9,\n\t\t1463\n\t],\n\t\"./ca.global.js\": [\n\t\t82303,\n\t\t7,\n\t\t2303\n\t],\n\t\"./ca.js\": [\n\t\t54301,\n\t\t9,\n\t\t4301\n\t],\n\t\"./cs.global.js\": [\n\t\t83989,\n\t\t7,\n\t\t3989\n\t],\n\t\"./cs.js\": [\n\t\t52222,\n\t\t9,\n\t\t2222\n\t],\n\t\"./cy.global.js\": [\n\t\t83126,\n\t\t7,\n\t\t3126\n\t],\n\t\"./cy.js\": [\n\t\t18395,\n\t\t9,\n\t\t8395\n\t],\n\t\"./da.global.js\": [\n\t\t76641,\n\t\t7,\n\t\t6641\n\t],\n\t\"./da.js\": [\n\t\t36271,\n\t\t9,\n\t\t6271\n\t],\n\t\"./de-at.global.js\": [\n\t\t14362,\n\t\t7,\n\t\t4362\n\t],\n\t\"./de-at.js\": [\n\t\t38799,\n\t\t9,\n\t\t8799\n\t],\n\t\"./de.global.js\": [\n\t\t83364,\n\t\t7,\n\t\t3364\n\t],\n\t\"./de.js\": [\n\t\t56091,\n\t\t9,\n\t\t6091\n\t],\n\t\"./el.global.js\": [\n\t\t96346,\n\t\t7,\n\t\t6346\n\t],\n\t\"./el.js\": [\n\t\t68633,\n\t\t9,\n\t\t8633\n\t],\n\t\"./en-au.global.js\": [\n\t\t40912,\n\t\t7,\n\t\t912\n\t],\n\t\"./en-au.js\": [\n\t\t4726,\n\t\t9,\n\t\t4726\n\t],\n\t\"./en-gb.global.js\": [\n\t\t56740,\n\t\t7,\n\t\t6740\n\t],\n\t\"./en-gb.js\": [\n\t\t7278,\n\t\t9,\n\t\t7278\n\t],\n\t\"./en-nz.global.js\": [\n\t\t91331,\n\t\t7,\n\t\t1331\n\t],\n\t\"./en-nz.js\": [\n\t\t2570,\n\t\t9,\n\t\t2570\n\t],\n\t\"./eo.global.js\": [\n\t\t3475,\n\t\t7,\n\t\t3475\n\t],\n\t\"./eo.js\": [\n\t\t34962,\n\t\t9,\n\t\t4962\n\t],\n\t\"./es-us.global.js\": [\n\t\t96067,\n\t\t7,\n\t\t6067\n\t],\n\t\"./es-us.js\": [\n\t\t55352,\n\t\t9,\n\t\t5352\n\t],\n\t\"./es.global.js\": [\n\t\t95415,\n\t\t7,\n\t\t5415\n\t],\n\t\"./es.js\": [\n\t\t79337,\n\t\t9,\n\t\t9337\n\t],\n\t\"./et.global.js\": [\n\t\t98291,\n\t\t7,\n\t\t8291\n\t],\n\t\"./et.js\": [\n\t\t3450,\n\t\t9,\n\t\t3450\n\t],\n\t\"./eu.global.js\": [\n\t\t93539,\n\t\t7,\n\t\t3539\n\t],\n\t\"./eu.js\": [\n\t\t85680,\n\t\t9,\n\t\t5680\n\t],\n\t\"./fa.global.js\": [\n\t\t75762,\n\t\t7,\n\t\t5762\n\t],\n\t\"./fa.js\": [\n\t\t94267,\n\t\t9,\n\t\t4267\n\t],\n\t\"./fi.global.js\": [\n\t\t54062,\n\t\t7,\n\t\t4062\n\t],\n\t\"./fi.js\": [\n\t\t84361,\n\t\t9,\n\t\t4361\n\t],\n\t\"./fr-ca.global.js\": [\n\t\t3936,\n\t\t7,\n\t\t3936\n\t],\n\t\"./fr-ca.js\": [\n\t\t26253,\n\t\t9,\n\t\t6253\n\t],\n\t\"./fr-ch.global.js\": [\n\t\t43923,\n\t\t7,\n\t\t3923\n\t],\n\t\"./fr-ch.js\": [\n\t\t44480,\n\t\t9,\n\t\t4480\n\t],\n\t\"./fr.global.js\": [\n\t\t75681,\n\t\t7,\n\t\t5681\n\t],\n\t\"./fr.js\": [\n\t\t68956,\n\t\t9,\n\t\t8956\n\t],\n\t\"./gl.global.js\": [\n\t\t79103,\n\t\t7,\n\t\t9103\n\t],\n\t\"./gl.js\": [\n\t\t8474,\n\t\t9,\n\t\t8474\n\t],\n\t\"./he.global.js\": [\n\t\t49430,\n\t\t7,\n\t\t9430\n\t],\n\t\"./he.js\": [\n\t\t34997,\n\t\t9,\n\t\t4997\n\t],\n\t\"./hi.global.js\": [\n\t\t94536,\n\t\t7,\n\t\t4536\n\t],\n\t\"./hi.js\": [\n\t\t53878,\n\t\t9,\n\t\t3878\n\t],\n\t\"./hr.global.js\": [\n\t\t88007,\n\t\t7,\n\t\t8007\n\t],\n\t\"./hr.js\": [\n\t\t16486,\n\t\t9,\n\t\t6486\n\t],\n\t\"./hu.global.js\": [\n\t\t54978,\n\t\t7,\n\t\t4978\n\t],\n\t\"./hu.js\": [\n\t\t4295,\n\t\t9,\n\t\t4295\n\t],\n\t\"./hy-am.global.js\": [\n\t\t76160,\n\t\t7,\n\t\t6160\n\t],\n\t\"./hy-am.js\": [\n\t\t83837,\n\t\t9,\n\t\t3837\n\t],\n\t\"./id.global.js\": [\n\t\t2507,\n\t\t7,\n\t\t2507\n\t],\n\t\"./id.js\": [\n\t\t68599,\n\t\t9,\n\t\t8599\n\t],\n\t\"./is.global.js\": [\n\t\t12523,\n\t\t7,\n\t\t2523\n\t],\n\t\"./is.js\": [\n\t\t96238,\n\t\t9,\n\t\t6238\n\t],\n\t\"./it.global.js\": [\n\t\t24391,\n\t\t7,\n\t\t4391\n\t],\n\t\"./it.js\": [\n\t\t54707,\n\t\t9,\n\t\t4707\n\t],\n\t\"./ja.global.js\": [\n\t\t8388,\n\t\t7,\n\t\t8388\n\t],\n\t\"./ja.js\": [\n\t\t79694,\n\t\t9,\n\t\t9694\n\t],\n\t\"./ka.global.js\": [\n\t\t5293,\n\t\t7,\n\t\t5293\n\t],\n\t\"./ka.js\": [\n\t\t7967,\n\t\t9,\n\t\t7967\n\t],\n\t\"./kk.global.js\": [\n\t\t31802,\n\t\t7,\n\t\t1802\n\t],\n\t\"./kk.js\": [\n\t\t69750,\n\t\t9,\n\t\t9750\n\t],\n\t\"./km.global.js\": [\n\t\t58255,\n\t\t7,\n\t\t8255\n\t],\n\t\"./km.js\": [\n\t\t28964,\n\t\t9,\n\t\t8964\n\t],\n\t\"./ko.global.js\": [\n\t\t16727,\n\t\t7,\n\t\t6727\n\t],\n\t\"./ko.js\": [\n\t\t48008,\n\t\t9,\n\t\t8008\n\t],\n\t\"./ku.global.js\": [\n\t\t37240,\n\t\t7,\n\t\t7240\n\t],\n\t\"./ku.js\": [\n\t\t35649,\n\t\t9,\n\t\t5649\n\t],\n\t\"./lb.global.js\": [\n\t\t62060,\n\t\t7,\n\t\t2060\n\t],\n\t\"./lb.js\": [\n\t\t28123,\n\t\t9,\n\t\t8123\n\t],\n\t\"./lt.global.js\": [\n\t\t8892,\n\t\t7,\n\t\t8892\n\t],\n\t\"./lt.js\": [\n\t\t21149,\n\t\t9,\n\t\t1149\n\t],\n\t\"./lv.global.js\": [\n\t\t33004,\n\t\t7,\n\t\t3004\n\t],\n\t\"./lv.js\": [\n\t\t29697,\n\t\t9,\n\t\t9697\n\t],\n\t\"./mk.global.js\": [\n\t\t87153,\n\t\t7,\n\t\t7153\n\t],\n\t\"./mk.js\": [\n\t\t3489,\n\t\t9,\n\t\t3489\n\t],\n\t\"./ms.global.js\": [\n\t\t65980,\n\t\t7,\n\t\t5980\n\t],\n\t\"./ms.js\": [\n\t\t55720,\n\t\t9,\n\t\t5720\n\t],\n\t\"./nb.global.js\": [\n\t\t57707,\n\t\t7,\n\t\t7707\n\t],\n\t\"./nb.js\": [\n\t\t76713,\n\t\t9,\n\t\t6713\n\t],\n\t\"./ne.global.js\": [\n\t\t26100,\n\t\t7,\n\t\t6100\n\t],\n\t\"./ne.js\": [\n\t\t6130,\n\t\t9,\n\t\t6130\n\t],\n\t\"./nl.global.js\": [\n\t\t31396,\n\t\t7,\n\t\t1396\n\t],\n\t\"./nl.js\": [\n\t\t8152,\n\t\t9,\n\t\t8152\n\t],\n\t\"./nn.global.js\": [\n\t\t11552,\n\t\t7,\n\t\t1552\n\t],\n\t\"./nn.js\": [\n\t\t61494,\n\t\t9,\n\t\t1494\n\t],\n\t\"./pl.global.js\": [\n\t\t32375,\n\t\t7,\n\t\t2375\n\t],\n\t\"./pl.js\": [\n\t\t30411,\n\t\t9,\n\t\t411\n\t],\n\t\"./pt-br.global.js\": [\n\t\t9825,\n\t\t7,\n\t\t9825\n\t],\n\t\"./pt-br.js\": [\n\t\t57318,\n\t\t9,\n\t\t7318\n\t],\n\t\"./pt.global.js\": [\n\t\t22668,\n\t\t7,\n\t\t2668\n\t],\n\t\"./pt.js\": [\n\t\t30138,\n\t\t9,\n\t\t138\n\t],\n\t\"./ro.global.js\": [\n\t\t37850,\n\t\t7,\n\t\t7850\n\t],\n\t\"./ro.js\": [\n\t\t50801,\n\t\t9,\n\t\t801\n\t],\n\t\"./ru.global.js\": [\n\t\t92098,\n\t\t7,\n\t\t2098\n\t],\n\t\"./ru.js\": [\n\t\t40110,\n\t\t9,\n\t\t110\n\t],\n\t\"./si-lk.global.js\": [\n\t\t78858,\n\t\t7,\n\t\t8858\n\t],\n\t\"./si-lk.js\": [\n\t\t77092,\n\t\t9,\n\t\t7092\n\t],\n\t\"./sk.global.js\": [\n\t\t39849,\n\t\t7,\n\t\t9849\n\t],\n\t\"./sk.js\": [\n\t\t80197,\n\t\t9,\n\t\t197\n\t],\n\t\"./sl.global.js\": [\n\t\t30482,\n\t\t7,\n\t\t482\n\t],\n\t\"./sl.js\": [\n\t\t21180,\n\t\t9,\n\t\t1180\n\t],\n\t\"./sm.global.js\": [\n\t\t62425,\n\t\t7,\n\t\t2425\n\t],\n\t\"./sm.js\": [\n\t\t55912,\n\t\t9,\n\t\t5912\n\t],\n\t\"./sq.global.js\": [\n\t\t45167,\n\t\t7,\n\t\t5167\n\t],\n\t\"./sq.js\": [\n\t\t51992,\n\t\t9,\n\t\t1992\n\t],\n\t\"./sr-cyrl.global.js\": [\n\t\t22996,\n\t\t7,\n\t\t2996\n\t],\n\t\"./sr-cyrl.js\": [\n\t\t69203,\n\t\t9,\n\t\t9203\n\t],\n\t\"./sr.global.js\": [\n\t\t19038,\n\t\t7,\n\t\t9038\n\t],\n\t\"./sr.js\": [\n\t\t27146,\n\t\t9,\n\t\t7146\n\t],\n\t\"./sv.global.js\": [\n\t\t88569,\n\t\t7,\n\t\t8569\n\t],\n\t\"./sv.js\": [\n\t\t37018,\n\t\t9,\n\t\t7018\n\t],\n\t\"./ta-in.global.js\": [\n\t\t77442,\n\t\t7,\n\t\t7442\n\t],\n\t\"./ta-in.js\": [\n\t\t65719,\n\t\t9,\n\t\t5719\n\t],\n\t\"./th.global.js\": [\n\t\t2066,\n\t\t7,\n\t\t2066\n\t],\n\t\"./th.js\": [\n\t\t77108,\n\t\t9,\n\t\t7108\n\t],\n\t\"./tr.global.js\": [\n\t\t26838,\n\t\t7,\n\t\t6838\n\t],\n\t\"./tr.js\": [\n\t\t97974,\n\t\t9,\n\t\t7974\n\t],\n\t\"./ug.global.js\": [\n\t\t16819,\n\t\t7,\n\t\t6819\n\t],\n\t\"./ug.js\": [\n\t\t3163,\n\t\t9,\n\t\t3163\n\t],\n\t\"./uk.global.js\": [\n\t\t83831,\n\t\t7,\n\t\t3831\n\t],\n\t\"./uk.js\": [\n\t\t86485,\n\t\t9,\n\t\t6485\n\t],\n\t\"./uz.global.js\": [\n\t\t22138,\n\t\t7,\n\t\t2138\n\t],\n\t\"./uz.js\": [\n\t\t20649,\n\t\t9,\n\t\t649\n\t],\n\t\"./vi.global.js\": [\n\t\t73034,\n\t\t7,\n\t\t3034\n\t],\n\t\"./vi.js\": [\n\t\t20026,\n\t\t9,\n\t\t26\n\t],\n\t\"./zh-cn.global.js\": [\n\t\t76522,\n\t\t7,\n\t\t6522\n\t],\n\t\"./zh-cn.js\": [\n\t\t96278,\n\t\t9,\n\t\t6278\n\t],\n\t\"./zh-tw.global.js\": [\n\t\t40100,\n\t\t7,\n\t\t100\n\t],\n\t\"./zh-tw.js\": [\n\t\t74452,\n\t\t9,\n\t\t4452\n\t]\n};\nfunction webpackAsyncContext(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\treturn Promise.resolve().then(function() {\n\t\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\t\te.code = 'MODULE_NOT_FOUND';\n\t\t\tthrow e;\n\t\t});\n\t}\n\n\tvar ids = map[req], id = ids[0];\n\treturn __webpack_require__.e(ids[2]).then(function() {\n\t\treturn __webpack_require__.t(id, ids[1] | 16)\n\t});\n}\nwebpackAsyncContext.keys = function() { return Object.keys(map); };\nwebpackAsyncContext.id = 23954;\nmodule.exports = webpackAsyncContext;",";(function(window){var hadGlobal='Modernizr' in window;var oldGlobal=window.Modernizr;/*!\n * modernizr v3.12.0\n * Build https://modernizr.com/download?-adownload-appearance-applicationcache-backdropfilter-backgroundblendmode-backgroundcliptext-backgroundsize-bgpositionshorthand-bgpositionxy-bgrepeatspace_bgrepeatround-bgsizecover-blobconstructor-bloburls-borderimage-borderradius-boxshadow-boxsizing-canvas-canvasblending-canvastext-canvaswinding-capture-checked-classlist-contenteditable-contextmenu-cookies-cors-createelementattrs_createelement_attrs-cssall-cssanimations-csscalc-csschunit-csscolumns-cssescape-cssexunit-cssfilters-cssgradients-cssgrid_cssgridlegacy-cssinvalid-cssmask-csspointerevents-csspositionsticky-csspseudoanimations-csspseudotransitions-cssreflections-cssremunit-cssresize-cssscrollbar-csstransforms-csstransforms3d-csstransformslevel2-csstransitions-cssvalid-cssvhunit-cssvmaxunit-cssvminunit-cssvwunit-cubicbezierrange-customelements-dataset-datauri-devicemotion_deviceorientation-directory-display_runin-displaytable-documentfragment-ellipsis-eventlistener-exiforientation-fileinput-flexbox-flexboxlegacy-flexboxtweener-flexwrap-fontface-formattribute-formvalidation-fullscreen-generatedcontent-hairline-hashchange-hidden-hiddenscroll-history-hovermq-hsla-htmlimports-inputtypes-json-lastchild-localstorage-mediaqueries-microdata-multiplebgs-mutationobserver-notification-nthchild-objectfit-oninput-opacity-overflowscrolling-pagevisibility-passiveeventlisteners-performance-placeholder-pointermq-postmessage-preserve3d-proximity-queryselector-regions-requestanimationframe-requestautocomplete-rgba-sandbox-scrollsnappoints-seamless-sessionstorage-shapes-siblinggeneral-srcdoc-subpixelfont-supports-target-textalignlast-textshadow-todataurljpeg_todataurlpng_todataurlwebp-touchevents-unicode-unicoderange-urlparser-urlsearchparams-userdata-userselect-vibrate-video-videoautoplay-videocrossorigin-videoloop-videopreload-websqldatabase-willchange-wrapflow-xdomainrequest-addtest-atrule-domprefixes-hasevent-load-mq-prefixed-prefixedcss-prefixes-printshiv-setclasses-testallprops-testprop-teststyles-dontmin\n *\n * Copyright (c)\n *  Faruk Ates\n *  Paul Irish\n *  Alex Sexton\n *  Ryan Seddon\n *  Patrick Kettner\n *  Stu Cox\n *  Richard Herrera\n *  Veeck\n\n * MIT License\n */\n\n/*\n * Modernizr tests which native CSS3 and HTML5 features are available in the\n * current UA and makes the results available to you in two ways: as properties on\n * a global `Modernizr` object, and as classes on the `<html>` element. This\n * information allows you to progressively enhance your pages with a granular level\n * of control over the experience.\n*/\n\n;(function(scriptGlobalObject, window, document, undefined){\n\n  var tests = [];\n  \n\n  /**\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n  var ModernizrProto = {\n    _version: '3.12.0',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': '',\n      'enableClasses': true,\n      'enableJSClass': true,\n      'usePrefixes': true\n    },\n\n    // Queue of tests\n    _q: [],\n\n    // Stub these for people who are listening\n    on: function(test, cb) {\n      // I don't really think people should do this, but we can\n      // safe guard it a bit.\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\n      // This is in case people listen to synchronous tests. I would leave it out,\n      // but the code to *disallow* sync tests in the real version of this\n      // function is actually larger than this.\n      var self = this;\n      setTimeout(function() {\n        cb(self[test]);\n      }, 0);\n    },\n\n    addTest: function(name, fn, options) {\n      tests.push({name: name, fn: fn, options: options});\n    },\n\n    addAsyncTest: function(fn) {\n      tests.push({name: null, fn: fn});\n    }\n  };\n\n  \n\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\n  var Modernizr = function() {};\n  Modernizr.prototype = ModernizrProto;\n\n  // Leak modernizr globally when you `require` it rather than force it here.\n  // Overwrite name so constructor name is nicer :D\n  Modernizr = new Modernizr();\n\n  \n\n  var classes = [];\n  \n\n  /**\n   * is returns a boolean if the typeof an obj is exactly type.\n   *\n   * @access private\n   * @function is\n   * @param {*} obj - A thing we want to check the type of\n   * @param {string} type - A string to compare the typeof against\n   * @returns {boolean} true if the typeof the first parameter is exactly the specified type, false otherwise\n   */\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   * @returns {void}\n   */\n  function testRunner() {\n    var featureNames;\n    var feature;\n    var aliasIdx;\n    var result;\n    var nameIdx;\n    var featureName;\n    var featureNameSplit;\n\n    for (var featureIdx in tests) {\n      if (tests.hasOwnProperty(featureIdx)) {\n        featureNames = [];\n        feature = tests[featureIdx];\n        // run the test, throw the return value into the Modernizr,\n        // then based on that boolean, define an appropriate className\n        // and push it into an array of classes we'll join later.\n        //\n        // If there is no name, it's an 'async' test that is run,\n        // but not directly added to the object. That should\n        // be done with a post-run addTest call.\n        if (feature.name) {\n          featureNames.push(feature.name.toLowerCase());\n\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\n            // Add all the aliases into the names list\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\n            }\n          }\n        }\n\n        // Run the test, or use the raw value if it's not a function\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\n\n        // Set each of the names on the Modernizr object\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\n          featureName = featureNames[nameIdx];\n          // Support dot properties as sub tests. We don't do checking to make sure\n          // that the implied parent tests have been added. You must call them in\n          // order (either in the test, or make the parent test a dependency).\n          //\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\n          // hashtag famous last words\n          featureNameSplit = featureName.split('.');\n\n          if (featureNameSplit.length === 1) {\n            Modernizr[featureNameSplit[0]] = result;\n          } else {\n            // cast to a Boolean, if not one already or if it doesnt exist yet (like inputtypes)\n            if (!Modernizr[featureNameSplit[0]] || Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n            }\n\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\n          }\n\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\n        }\n      }\n    }\n  }\n  ;\n\n  /**\n   * docElement is a convenience wrapper to grab the root element of the document\n   *\n   * @access private\n   * @returns {HTMLElement|SVGElement} The root element of the document\n   */\n  var docElement = document.documentElement;\n  \n\n  /**\n   * A convenience helper to check if the document we are running in is an SVG document\n   *\n   * @access private\n   * @returns {boolean}\n   */\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n\n  \n\n  /**\n   * setClasses takes an array of class names and adds them to the root element\n   *\n   * @access private\n   * @function setClasses\n   * @param {string[]} classes - Array of class names\n   */\n  // Pass in an and array of class names, e.g.:\n  //  ['no-webp', 'borderradius', ...]\n  function setClasses(classes) {\n    var className = docElement.className;\n    var classPrefix = Modernizr._config.classPrefix || '';\n\n    if (isSVG) {\n      className = className.baseVal;\n    }\n\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\n    // Handle classPrefix on this too\n    if (Modernizr._config.enableJSClass) {\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\n    }\n\n    if (Modernizr._config.enableClasses) {\n      // Add the new classes\n      if (classes.length > 0) {\n        className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      }\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n  }\n\n  ;\n\n  /**\n   * hasOwnProp is a shim for hasOwnProperty that is needed for Safari 2.0 support\n   *\n   * @author kangax\n   * @access private\n   * @function hasOwnProp\n   * @param {object} object - The object to check for a property\n   * @param {string} property - The property to check for\n   * @returns {boolean}\n   */\n\n  // hasOwnProperty shim by kangax needed for Safari 2.0 support\n  var hasOwnProp;\n\n  (function() {\n    var _hasOwnProperty = ({}).hasOwnProperty;\n    /* istanbul ignore else */\n    /* we have no way of testing IE 5.5 or safari 2,\n     * so just assume the else gets hit */\n    if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) {\n      hasOwnProp = function(object, property) {\n        return _hasOwnProperty.call(object, property);\n      };\n    }\n    else {\n      hasOwnProp = function(object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */\n        return ((property in object) && is(object.constructor.prototype[property], 'undefined'));\n      };\n    }\n  })();\n\n  \n\n\n  // _l tracks listeners for async tests, as well as tests that execute after the initial run\n  ModernizrProto._l = {};\n\n  /**\n   * Modernizr.on is a way to listen for the completion of async tests. Being\n   * asynchronous, they may not finish before your scripts run. As a result you\n   * will get a possibly false negative `undefined` value.\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.on\n   * @access public\n   * @function on\n   * @param {string} feature - String name of the feature detect\n   * @param {Function} cb - Callback function returning a Boolean - true if feature is supported, false if not\n   * @returns {void}\n   * @example\n   *\n   * ```js\n   * Modernizr.on('flash', function( result ) {\n   *   if (result) {\n   *    // the browser has flash\n   *   } else {\n   *     // the browser does not have flash\n   *   }\n   * });\n   * ```\n   */\n  ModernizrProto.on = function(feature, cb) {\n    // Create the list of listeners if it doesn't exist\n    if (!this._l[feature]) {\n      this._l[feature] = [];\n    }\n\n    // Push this test on to the listener list\n    this._l[feature].push(cb);\n\n    // If it's already been resolved, trigger it on next tick\n    if (Modernizr.hasOwnProperty(feature)) {\n      // Next Tick\n      setTimeout(function() {\n        Modernizr._trigger(feature, Modernizr[feature]);\n      }, 0);\n    }\n  };\n\n  /**\n   * _trigger is the private function used to signal test completion and run any\n   * callbacks registered through [Modernizr.on](#modernizr-on)\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._trigger\n   * @access private\n   * @function _trigger\n   * @param {string} feature - string name of the feature detect\n   * @param {Function|boolean} [res] - A feature detection function, or the boolean =\n   * result of a feature detection function\n   * @returns {void}\n   */\n  ModernizrProto._trigger = function(feature, res) {\n    if (!this._l[feature]) {\n      return;\n    }\n\n    var cbs = this._l[feature];\n\n    // Force async\n    setTimeout(function() {\n      var i, cb;\n      for (i = 0; i < cbs.length; i++) {\n        cb = cbs[i];\n        cb(res);\n      }\n    }, 0);\n\n    // Don't trigger these again\n    delete this._l[feature];\n  };\n\n  /**\n   * addTest allows you to define your own feature detects that are not currently\n   * included in Modernizr (under the covers it's the exact same code Modernizr\n   * uses for its own [feature detections](https://github.com/Modernizr/Modernizr/tree/master/feature-detects)).\n   * Just like the official detects, the result\n   * will be added onto the Modernizr object, as well as an appropriate className set on\n   * the html element when configured to do so\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.addTest\n   * @optionName Modernizr.addTest()\n   * @optionProp addTest\n   * @access public\n   * @function addTest\n   * @param {string|object} feature - The string name of the feature detect, or an\n   * object of feature detect names and test\n   * @param {Function|boolean} test - Function returning true if feature is supported,\n   * false if not. Otherwise a boolean representing the results of a feature detection\n   * @returns {object} the Modernizr object to allow chaining\n   * @example\n   *\n   * The most common way of creating your own feature detects is by calling\n   * `Modernizr.addTest` with a string (preferably just lowercase, without any\n   * punctuation), and a function you want executed that will return a boolean result\n   *\n   * ```js\n   * Modernizr.addTest('itsTuesday', function() {\n   *  var d = new Date();\n   *  return d.getDay() === 2;\n   * });\n   * ```\n   *\n   * When the above is run, it will set Modernizr.itstuesday to `true` when it is tuesday,\n   * and to `false` every other day of the week. One thing to notice is that the names of\n   * feature detect functions are always lowercased when added to the Modernizr object. That\n   * means that `Modernizr.itsTuesday` will not exist, but `Modernizr.itstuesday` will.\n   *\n   *\n   *  Since we only look at the returned value from any feature detection function,\n   *  you do not need to actually use a function. For simple detections, just passing\n   *  in a statement that will return a boolean value works just fine.\n   *\n   * ```js\n   * Modernizr.addTest('hasjquery', 'jQuery' in window);\n   * ```\n   *\n   * Just like before, when the above runs `Modernizr.hasjquery` will be true if\n   * jQuery has been included on the page. Not using a function saves a small amount\n   * of overhead for the browser, as well as making your code much more readable.\n   *\n   * Finally, you also have the ability to pass in an object of feature names and\n   * their tests. This is handy if you want to add multiple detections in one go.\n   * The keys should always be a string, and the value can be either a boolean or\n   * function that returns a boolean.\n   *\n   * ```js\n   * var detects = {\n   *  'hasjquery': 'jQuery' in window,\n   *  'itstuesday': function() {\n   *    var d = new Date();\n   *    return d.getDay() === 2;\n   *  }\n   * }\n   *\n   * Modernizr.addTest(detects);\n   * ```\n   *\n   * There is really no difference between the first methods and this one, it is\n   * just a convenience to let you write more readable code.\n   */\n  function addTest(feature, test) {\n\n    if (typeof feature === 'object') {\n      for (var key in feature) {\n        if (hasOwnProp(feature, key)) {\n          addTest(key, feature[ key ]);\n        }\n      }\n    } else {\n\n      feature = feature.toLowerCase();\n      var featureNameSplit = feature.split('.');\n      var last = Modernizr[featureNameSplit[0]];\n\n      // Again, we don't check for parent test existence. Get that right, though.\n      if (featureNameSplit.length === 2) {\n        last = last[featureNameSplit[1]];\n      }\n\n      if (typeof last !== 'undefined') {\n        // we're going to quit if you're trying to overwrite an existing test\n        // if we were to allow it, we'd do this:\n        //   var re = new RegExp(\"\\\\b(no-)?\" + feature + \"\\\\b\");\n        //   docElement.className = docElement.className.replace( re, '' );\n        // but, no rly, stuff 'em.\n        return Modernizr;\n      }\n\n      test = typeof test === 'function' ? test() : test;\n\n      // Set the value (this is the magic, right here).\n      if (featureNameSplit.length === 1) {\n        Modernizr[featureNameSplit[0]] = test;\n      } else {\n        // cast to a Boolean, if not one already\n        if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n          Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n        }\n\n        Modernizr[featureNameSplit[0]][featureNameSplit[1]] = test;\n      }\n\n      // Set a single class (either `feature` or `no-feature`)\n      setClasses([(!!test && test !== false ? '' : 'no-') + featureNameSplit.join('-')]);\n\n      // Trigger the event\n      Modernizr._trigger(feature, test);\n    }\n\n    return Modernizr; // allow chaining.\n  }\n\n  // After all the tests are run, add self to the Modernizr prototype\n  Modernizr._q.push(function() {\n    ModernizrProto.addTest = addTest;\n  });\n\n  \n\n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific styles as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following (which is technically incorrect):\n   *   elem.style.webkitBorderRadius\n   *\n   * WebKit ghosts their properties in lowercase but Opera & Moz do not.\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\n   *\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\n   *\n   * @access private\n   * @returns {string} The string representing the vendor-specific style properties\n   */\n  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\n  \n\n  /**\n   * atRule returns a given CSS property at-rule (eg @keyframes), possibly in\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.atRule\n   * @optionName Modernizr.atRule()\n   * @optionProp atRule\n   * @access public\n   * @function atRule\n   * @param {string} prop - String name of the @-rule to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the @-rule, or `false` when it is unsupported.\n   * @example\n   * ```js\n   *  var keyframes = Modernizr.atRule('@keyframes');\n   *\n   *  if (keyframes) {\n   *    // keyframes are supported\n   *    // could be `@-webkit-keyframes` or `@keyframes`\n   *  } else {\n   *    // keyframes === `false`\n   *  }\n   * ```\n   */\n  var atRule = function(prop) {\n    var length = prefixes.length;\n    var cssrule = window.CSSRule;\n    var rule;\n\n    if (typeof cssrule === 'undefined') {\n      return undefined;\n    }\n\n    if (!prop) {\n      return false;\n    }\n\n    // remove literal @ from beginning of provided property\n    prop = prop.replace(/^@/, '');\n\n    // CSSRules use underscores instead of dashes\n    rule = prop.replace(/-/g, '_').toUpperCase() + '_RULE';\n\n    if (rule in cssrule) {\n      return '@' + prop;\n    }\n\n    for (var i = 0; i < length; i++) {\n      // prefixes gives us something like -o-, and we want O_\n      var prefix = prefixes[i];\n      var thisRule = prefix.toUpperCase() + '_' + rule;\n\n      if (thisRule in cssrule) {\n        return '@-' + prefix.toLowerCase() + '-' + prop;\n      }\n    }\n\n    return false;\n  };\n\n  ModernizrProto.atRule = atRule;\n\n  \n\n  /**\n   * List of JavaScript DOM values used for tests\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._domPrefixes\n   * @optionName Modernizr._domPrefixes\n   * @optionProp domPrefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\n   * than hyphen-case properties, all properties are their Capitalized variant\n   *\n   * ```js\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\n  \n\n  /**\n   * createElement is a convenience wrapper around document.createElement. Since we\n   * use createElement all over the place, this allows for (slightly) smaller code\n   * as well as abstracting away issues with creating elements in contexts other than\n   * HTML documents (e.g. SVG documents).\n   *\n   * @access private\n   * @function createElement\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\n   */\n  function createElement() {\n    if (typeof document.createElement !== 'function') {\n      // This is the case in IE7, where the type of createElement is \"object\".\n      // For this reason, we cannot call apply() as Object is not a Function.\n      return document.createElement(arguments[0]);\n    } else if (isSVG) {\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\n    } else {\n      return document.createElement.apply(document, arguments);\n    }\n  }\n\n  ;\n\n  /**\n   * Modernizr.hasEvent() detects support for a given event\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.hasEvent\n   * @optionName Modernizr.hasEvent()\n   * @optionProp hasEvent\n   * @access public\n   * @function hasEvent\n   * @param {string|*} eventName - the name of an event to test for (e.g. \"resize\")\n   * @param {Element|string} [element=HTMLDivElement] - is the element|document|window|tagName to test on\n   * @returns {boolean}\n   * @example\n   *  `Modernizr.hasEvent` lets you determine if the browser supports a supplied event.\n   *  By default, it does this detection on a div element\n   *\n   * ```js\n   *  hasEvent('blur') // true;\n   * ```\n   *\n   * However, you are able to give an object as a second argument to hasEvent to\n   * detect an event on something other than a div.\n   *\n   * ```js\n   *  hasEvent('devicelight', window) // true;\n   * ```\n   */\n  var hasEvent = (function() {\n\n    // Detect whether event support can be detected via `in`. Test on a DOM element\n    // using the \"blur\" event b/c it should always exist. bit.ly/event-detection\n    var needsFallback = !('onblur' in docElement);\n\n    function inner(eventName, element) {\n\n      var isSupported;\n      if (!eventName) { return false; }\n      if (!element || typeof element === 'string') {\n        element = createElement(element || 'div');\n      }\n\n      // Testing via the `in` operator is sufficient for modern browsers and IE.\n      // When using `setAttribute`, IE skips \"unload\", WebKit skips \"unload\" and\n      // \"resize\", whereas `in` \"catches\" those.\n      eventName = 'on' + eventName;\n      isSupported = eventName in element;\n\n      // Fallback technique for old Firefox - bit.ly/event-detection\n      if (!isSupported && needsFallback) {\n        if (!element.setAttribute) {\n          // Switch to generic element if it lacks `setAttribute`.\n          // It could be the `document`, `window`, or something else.\n          element = createElement('div');\n        }\n\n        element.setAttribute(eventName, '');\n        isSupported = typeof element[eventName] === 'function';\n\n        if (element[eventName] !== undefined) {\n          // If property was created, \"remove it\" by setting value to `undefined`.\n          element[eventName] = undefined;\n        }\n        element.removeAttribute(eventName);\n      }\n\n      return isSupported;\n    }\n    return inner;\n  })();\n\n  ModernizrProto.hasEvent = hasEvent;\n  \n\n  /**\n   * @optionName html5printshiv\n   * @optionProp html5printshiv\n   */\n\n  // Take the html5 variable out of the html5shiv scope so we can return it.\n  var html5;\n  if (!isSVG) {\n    /**\n     * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed\n     */\n    ;(function(window, document) {\n      /*jshint evil:true */\n      /** version */\n      var version = '3.7.3';\n\n      /** Preset options */\n      var options = window.html5 || {};\n\n      /** Used to skip problem elements */\n      var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;\n\n      /** Not all elements can be cloned in IE **/\n      var saveClones = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;\n\n      /** Detect whether the browser supports default html5 styles */\n      var supportsHtml5Styles;\n\n      /** Name of the expando, to work with multiple documents or to re-shiv one document */\n      var expando = '_html5shiv';\n\n      /** The id for the the documents expando */\n      var expanID = 0;\n\n      /** Cached data for each document */\n      var expandoData = {};\n\n      /** Detect whether the browser supports unknown elements */\n      var supportsUnknownElements;\n\n      (function() {\n        try {\n          var a = document.createElement('a');\n          a.innerHTML = '<xyz></xyz>';\n          //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles\n          supportsHtml5Styles = ('hidden' in a);\n\n          supportsUnknownElements = a.childNodes.length == 1 || (function() {\n            // assign a false positive if unable to shiv\n            (document.createElement)('a');\n            var frag = document.createDocumentFragment();\n            return (\n              typeof frag.cloneNode == 'undefined' ||\n              typeof frag.createDocumentFragment == 'undefined' ||\n              typeof frag.createElement == 'undefined'\n            );\n          }());\n        } catch(e) {\n          // assign a false positive if detection fails => unable to shiv\n          supportsHtml5Styles = true;\n          supportsUnknownElements = true;\n        }\n\n      }());\n\n      /*--------------------------------------------------------------------------*/\n\n      /**\n       * Creates a style sheet with the given CSS text and adds it to the document.\n       * @private\n       * @param {Document} ownerDocument The document.\n       * @param {String} cssText The CSS text.\n       * @returns {StyleSheet} The style element.\n       */\n      function addStyleSheet(ownerDocument, cssText) {\n        var p = ownerDocument.createElement('p'),\n          parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;\n\n        p.innerHTML = 'x<style>' + cssText + '</style>';\n        return parent.insertBefore(p.lastChild, parent.firstChild);\n      }\n\n      /**\n       * Returns the value of `html5.elements` as an array.\n       * @private\n       * @returns {Array} An array of shived element node names.\n       */\n      function getElements() {\n        var elements = html5.elements;\n        return typeof elements == 'string' ? elements.split(' ') : elements;\n      }\n\n      /**\n       * Extends the built-in list of html5 elements\n       * @memberOf html5\n       * @param {String|Array} newElements whitespace separated list or array of new element names to shiv\n       * @param {Document} ownerDocument The context document.\n       */\n      function addElements(newElements, ownerDocument) {\n        var elements = html5.elements;\n        if(typeof elements != 'string'){\n          elements = elements.join(' ');\n        }\n        if(typeof newElements != 'string'){\n          newElements = newElements.join(' ');\n        }\n        html5.elements = elements +' '+ newElements;\n        shivDocument(ownerDocument);\n      }\n\n      /**\n       * Returns the data associated to the given document\n       * @private\n       * @param {Document} ownerDocument The document.\n       * @returns {Object} An object of data.\n       */\n      function getExpandoData(ownerDocument) {\n        var data = expandoData[ownerDocument[expando]];\n        if (!data) {\n          data = {};\n          expanID++;\n          ownerDocument[expando] = expanID;\n          expandoData[expanID] = data;\n        }\n        return data;\n      }\n\n      /**\n       * returns a shived element for the given nodeName and document\n       * @memberOf html5\n       * @param {String} nodeName name of the element\n       * @param {Document} ownerDocument The context document.\n       * @returns {Object} The shived element.\n       */\n      function createElement(nodeName, ownerDocument, data){\n        if (!ownerDocument) {\n          ownerDocument = document;\n        }\n        if(supportsUnknownElements){\n          return ownerDocument.createElement(nodeName);\n        }\n        if (!data) {\n          data = getExpandoData(ownerDocument);\n        }\n        var node;\n\n        if (data.cache[nodeName]) {\n          node = data.cache[nodeName].cloneNode();\n        } else if (saveClones.test(nodeName)) {\n          node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();\n        } else {\n          node = data.createElem(nodeName);\n        }\n\n        // Avoid adding some elements to fragments in IE < 9 because\n        // * Attributes like `name` or `type` cannot be set/changed once an element\n        //   is inserted into a document/fragment\n        // * Link elements with `src` attributes that are inaccessible, as with\n        //   a 403 response, will cause the tab/window to crash\n        // * Script elements appended to fragments will execute when their `src`\n        //   or `text` property is set\n        return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn ? data.frag.appendChild(node) : node;\n      }\n\n      /**\n       * returns a shived DocumentFragment for the given document\n       * @memberOf html5\n       * @param {Document} ownerDocument The context document.\n       * @returns {Object} The shived DocumentFragment.\n       */\n      function createDocumentFragment(ownerDocument, data){\n        if (!ownerDocument) {\n          ownerDocument = document;\n        }\n        if(supportsUnknownElements){\n          return ownerDocument.createDocumentFragment();\n        }\n        data = data || getExpandoData(ownerDocument);\n        var clone = data.frag.cloneNode(),\n          i = 0,\n          elems = getElements(),\n          l = elems.length;\n        for(;i<l;i++){\n          clone.createElement(elems[i]);\n        }\n        return clone;\n      }\n\n      /**\n       * Shivs the `createElement` and `createDocumentFragment` methods of the document.\n       * @private\n       * @param {Document|DocumentFragment} ownerDocument The document.\n       * @param {Object} data of the document.\n       */\n      function shivMethods(ownerDocument, data) {\n        if (!data.cache) {\n          data.cache = {};\n          data.createElem = ownerDocument.createElement;\n          data.createFrag = ownerDocument.createDocumentFragment;\n          data.frag = data.createFrag();\n        }\n\n\n        ownerDocument.createElement = function(nodeName) {\n          //abort shiv\n          if (!html5.shivMethods) {\n            return data.createElem(nodeName);\n          }\n          return createElement(nodeName, ownerDocument, data);\n        };\n\n        ownerDocument.createDocumentFragment = Function('h,f', 'return function(){' +\n          'var n=f.cloneNode(),c=n.createElement;' +\n          'h.shivMethods&&(' +\n          // unroll the `createElement` calls\n          getElements().join().replace(/[\\w\\-:]+/g, function(nodeName) {\n            data.createElem(nodeName);\n            data.frag.createElement(nodeName);\n            return 'c(\"' + nodeName + '\")';\n          }) +\n          ');return n}'\n        )(html5, data.frag);\n      }\n\n      /*--------------------------------------------------------------------------*/\n\n      /**\n       * Shivs the given document.\n       * @memberOf html5\n       * @param {Document} ownerDocument The document to shiv.\n       * @returns {Document} The shived document.\n       */\n      function shivDocument(ownerDocument) {\n        if (!ownerDocument) {\n          ownerDocument = document;\n        }\n        var data = getExpandoData(ownerDocument);\n\n        if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {\n          data.hasCSS = !!addStyleSheet(ownerDocument,\n            // corrects block display not defined in IE6/7/8/9\n            'article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}' +\n            // adds styling not present in IE6/7/8/9\n            'mark{background:#FF0;color:#000}' +\n            // hides non-rendered elements\n            'template{display:none}'\n          );\n        }\n        if (!supportsUnknownElements) {\n          shivMethods(ownerDocument, data);\n        }\n        return ownerDocument;\n      }\n\n      /*--------------------------------------------------------------------------*/\n\n      /**\n       * The `html5` object is exposed so that more elements can be shived and\n       * existing shiving can be detected on iframes.\n       * @type Object\n       * @example\n       *\n       * // options can be changed before the script is included\n       * html5 = { 'elements': 'mark section', 'shivCSS': false, 'shivMethods': false };\n       */\n      var html5 = {\n\n        /**\n         * An array or space separated string of node names of the elements to shiv.\n         * @memberOf html5\n         * @type Array|String\n         */\n        'elements': options.elements || 'abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video',\n\n        /**\n         * current version of html5shiv\n         */\n        'version': version,\n\n        /**\n         * A flag to indicate that the HTML5 style sheet should be inserted.\n         * @memberOf html5\n         * @type Boolean\n         */\n        'shivCSS': (options.shivCSS !== false),\n\n        /**\n         * Is equal to true if a browser supports creating unknown/HTML5 elements\n         * @memberOf html5\n         * @type boolean\n         */\n        'supportsUnknownElements': supportsUnknownElements,\n\n        /**\n         * A flag to indicate that the document's `createElement` and `createDocumentFragment`\n         * methods should be overwritten.\n         * @memberOf html5\n         * @type Boolean\n         */\n        'shivMethods': (options.shivMethods !== false),\n\n        /**\n         * A string to describe the type of `html5` object (\"default\" or \"default print\").\n         * @memberOf html5\n         * @type String\n         */\n        'type': 'default',\n\n        // shivs the document according to the specified `html5` object options\n        'shivDocument': shivDocument,\n\n        //creates a shived element\n        createElement: createElement,\n\n        //creates a shived documentFragment\n        createDocumentFragment: createDocumentFragment,\n\n        //extends list of elements\n        addElements: addElements\n      };\n\n      /*--------------------------------------------------------------------------*/\n\n      // expose html5\n      window.html5 = html5;\n\n      // shiv the document\n      shivDocument(document);\n\n      /*------------------------------- Print Shiv -------------------------------*/\n\n      /** Used to filter media types */\n      var reMedia = /^$|\\b(?:all|print)\\b/;\n\n      /** Used to namespace printable elements */\n      var shivNamespace = 'html5shiv';\n\n      /** Detect whether the browser supports shivable style sheets */\n      var supportsShivableSheets = !supportsUnknownElements && (function() {\n        // assign a false negative if unable to shiv\n        var docEl = document.documentElement;\n        return !(\n          typeof document.namespaces == 'undefined' ||\n          typeof document.parentWindow == 'undefined' ||\n          typeof docEl.applyElement == 'undefined' ||\n          typeof docEl.removeNode == 'undefined' ||\n          typeof window.attachEvent == 'undefined'\n        );\n      }());\n\n      /*--------------------------------------------------------------------------*/\n\n      /**\n       * Wraps all HTML5 elements in the given document with printable elements.\n       * (eg. the \"header\" element is wrapped with the \"html5shiv:header\" element)\n       * @private\n       * @param {Document} ownerDocument The document.\n       * @returns {Array} An array wrappers added.\n       */\n      function addWrappers(ownerDocument) {\n        var node,\n          nodes = ownerDocument.getElementsByTagName('*'),\n          index = nodes.length,\n          reElements = RegExp('^(?:' + getElements().join('|') + ')$', 'i'),\n          result = [];\n\n        while (index--) {\n          node = nodes[index];\n          if (reElements.test(node.nodeName)) {\n            result.push(node.applyElement(createWrapper(node)));\n          }\n        }\n        return result;\n      }\n\n      /**\n       * Creates a printable wrapper for the given element.\n       * @private\n       * @param {Element} element The element.\n       * @returns {Element} The wrapper.\n       */\n      function createWrapper(element) {\n        var node,\n          nodes = element.attributes,\n          index = nodes.length,\n          wrapper = element.ownerDocument.createElement(shivNamespace + ':' + element.nodeName);\n\n        // copy element attributes to the wrapper\n        while (index--) {\n          node = nodes[index];\n          node.specified && wrapper.setAttribute(node.nodeName, node.nodeValue);\n        }\n        // copy element styles to the wrapper\n        wrapper.style.cssText = element.style.cssText;\n        return wrapper;\n      }\n\n      /**\n       * Shivs the given CSS text.\n       * (eg. header{} becomes html5shiv\\:header{})\n       * @private\n       * @param {String} cssText The CSS text to shiv.\n       * @returns {String} The shived CSS text.\n       */\n      function shivCssText(cssText) {\n        var pair,\n          parts = cssText.split('{'),\n          index = parts.length,\n          reElements = RegExp('(^|[\\\\s,>+~])(' + getElements().join('|') + ')(?=[[\\\\s,>+~#.:]|$)', 'gi'),\n          replacement = '$1' + shivNamespace + '\\\\:$2';\n\n        while (index--) {\n          pair = parts[index] = parts[index].split('}');\n          pair[pair.length - 1] = pair[pair.length - 1].replace(reElements, replacement);\n          parts[index] = pair.join('}');\n        }\n        return parts.join('{');\n      }\n\n      /**\n       * Removes the given wrappers, leaving the original elements.\n       * @private\n       * @params {Array} wrappers An array of printable wrappers.\n       */\n      function removeWrappers(wrappers) {\n        var index = wrappers.length;\n        while (index--) {\n          wrappers[index].removeNode();\n        }\n      }\n\n      /*--------------------------------------------------------------------------*/\n\n      /**\n       * Shivs the given document for print.\n       * @memberOf html5\n       * @param {Document} ownerDocument The document to shiv.\n       * @returns {Document} The shived document.\n       */\n      function shivPrint(ownerDocument) {\n        var shivedSheet,\n          wrappers,\n          data = getExpandoData(ownerDocument),\n          namespaces = ownerDocument.namespaces,\n          ownerWindow = ownerDocument.parentWindow;\n\n        if (!supportsShivableSheets || ownerDocument.printShived) {\n          return ownerDocument;\n        }\n        if (typeof namespaces[shivNamespace] == 'undefined') {\n          namespaces.add(shivNamespace);\n        }\n\n        function removeSheet() {\n          clearTimeout(data._removeSheetTimer);\n          if (shivedSheet) {\n            shivedSheet.removeNode(true);\n          }\n          shivedSheet= null;\n        }\n\n        ownerWindow.attachEvent('onbeforeprint', function() {\n\n          removeSheet();\n\n          var imports,\n            length,\n            sheet,\n            collection = ownerDocument.styleSheets,\n            cssText = [],\n            index = collection.length,\n            sheets = Array(index);\n\n          // convert styleSheets collection to an array\n          while (index--) {\n            sheets[index] = collection[index];\n          }\n          // concat all style sheet CSS text\n          while ((sheet = sheets.pop())) {\n            // IE does not enforce a same origin policy for external style sheets...\n            // but has trouble with some dynamically created stylesheets\n            if (!sheet.disabled && reMedia.test(sheet.media)) {\n\n              try {\n                imports = sheet.imports;\n                length = imports.length;\n              } catch(er){\n                length = 0;\n              }\n\n              for (index = 0; index < length; index++) {\n                sheets.push(imports[index]);\n              }\n\n              try {\n                cssText.push(sheet.cssText);\n              } catch(er){}\n            }\n          }\n\n          // wrap all HTML5 elements with printable elements and add the shived style sheet\n          cssText = shivCssText(cssText.reverse().join(''));\n          wrappers = addWrappers(ownerDocument);\n          shivedSheet = addStyleSheet(ownerDocument, cssText);\n\n        });\n\n        ownerWindow.attachEvent('onafterprint', function() {\n          // remove wrappers, leaving the original elements, and remove the shived style sheet\n          removeWrappers(wrappers);\n          clearTimeout(data._removeSheetTimer);\n          data._removeSheetTimer = setTimeout(removeSheet, 500);\n        });\n\n        ownerDocument.printShived = true;\n        return ownerDocument;\n      }\n\n      /*--------------------------------------------------------------------------*/\n\n      // expose API\n      html5.type += ' print';\n      html5.shivPrint = shivPrint;\n\n      // shiv for print\n      shivPrint(document);\n\n      if(typeof module == 'object' && module.exports){\n        module.exports = html5;\n      }\n\n    }(typeof window !== \"undefined\" ? window : this, document));\n  }\n\n  ;\n\n  var err = function() {};\n  var warn = function() {};\n\n  if (window.console) {\n    err = function() {\n      var method = console.error ? 'error' : 'log';\n      window.console[method].apply(window.console, Array.prototype.slice.call(arguments));\n    };\n\n    warn = function() {\n      var method = console.warn ? 'warn' : 'log';\n      window.console[method].apply(window.console, Array.prototype.slice.call(arguments));\n    };\n  }\n\n  /**\n   * Previously, Modernizr.load was an alias for yepnope. Since yepnope was\n   * deprecated, we removed it as well. It is not available on the website builder,\n   * this is only included as an improved warning to those who build a custom\n   * version locally.\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.load\n   * @function load\n   * @returns {void}\n   */\n  ModernizrProto.load = function() {\n    if ('yepnope' in window) {\n      warn('yepnope.js (aka Modernizr.load) is no longer included as part of Modernizr. yepnope appears to be available on the page, so we’ll use it to handle this call to Modernizr.load, but please update your code to use yepnope directly.\\n See http://github.com/Modernizr/Modernizr/issues/1182 for more information.');\n      window.yepnope.apply(window, [].slice.call(arguments, 0));\n    } else {\n      err('yepnope.js (aka Modernizr.load) is no longer included as part of Modernizr. Get it from http://yepnopejs.com. See http://github.com/Modernizr/Modernizr/issues/1182 for more information.');\n    }\n  };\n\n\n  /**\n   * getBody returns the body of a document, or an element that can stand in for\n   * the body if a real body does not exist\n   *\n   * @access private\n   * @function getBody\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\n   * artificially created element that stands in for the body\n   */\n  function getBody() {\n    // After page load injecting a fake body doesn't work so check if body exists\n    var body = document.body;\n\n    if (!body) {\n      // Can't use the real body create a fake one.\n      body = createElement(isSVG ? 'svg' : 'body');\n      body.fake = true;\n    }\n\n    return body;\n  }\n\n  ;\n\n  /**\n   * injectElementWithStyles injects an element with style element and some CSS rules\n   *\n   * @access private\n   * @function injectElementWithStyles\n   * @param {string} rule - String representing a css rule\n   * @param {Function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean} the result of the specified callback test\n   */\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\n    var mod = 'modernizr';\n    var style;\n    var ret;\n    var node;\n    var docOverflow;\n    var div = createElement('div');\n    var body = getBody();\n\n    if (parseInt(nodes, 10)) {\n      // In order not to give false positives we create a node for each test\n      // This also allows the method to scale for unspecified uses\n      while (nodes--) {\n        node = createElement('div');\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\n        div.appendChild(node);\n      }\n    }\n\n    style = createElement('style');\n    style.type = 'text/css';\n    style.id = 's' + mod;\n\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\n    (!body.fake ? div : body).appendChild(style);\n    body.appendChild(div);\n\n    if (style.styleSheet) {\n      style.styleSheet.cssText = rule;\n    } else {\n      style.appendChild(document.createTextNode(rule));\n    }\n    div.id = mod;\n\n    if (body.fake) {\n      //avoid crashing IE8, if background image is used\n      body.style.background = '';\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\n      body.style.overflow = 'hidden';\n      docOverflow = docElement.style.overflow;\n      docElement.style.overflow = 'hidden';\n      docElement.appendChild(body);\n    }\n\n    ret = callback(div, rule);\n    // If this is done after page load we don't want to remove the body so check if body exists\n    if (body.fake && body.parentNode) {\n      body.parentNode.removeChild(body);\n      docElement.style.overflow = docOverflow;\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\n      // eslint-disable-next-line\n      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n  }\n\n  ;\n\n\n  /**\n   * wrapper around getComputedStyle, to fix issues with Firefox returning null when\n   * called inside of a hidden iframe\n   *\n   * @access private\n   * @function computedStyle\n   * @param {HTMLElement|SVGElement} elem - The element we want to find the computed styles of\n   * @param {string|null} [pseudo] - An optional pseudo element selector (e.g. :before), of null if none\n   * @param {string} prop - A CSS property\n   * @returns {CSSStyleDeclaration} the value of the specified CSS property\n   */\n  function computedStyle(elem, pseudo, prop) {\n    var result;\n\n    if ('getComputedStyle' in window) {\n      result = getComputedStyle.call(window, elem, pseudo);\n      var console = window.console;\n\n      if (result !== null) {\n        if (prop) {\n          result = result.getPropertyValue(prop);\n        }\n      } else {\n        if (console) {\n          var method = console.error ? 'error' : 'log';\n          console[method].call(console, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');\n        }\n      }\n    } else {\n      result = !pseudo && elem.currentStyle && elem.currentStyle[prop];\n    }\n\n    return result;\n  }\n\n  ;\n\n  /**\n   * Modernizr.mq tests a given media query, live against the current state of the window\n   * adapted from matchMedia polyfill by Scott Jehl and Paul Irish\n   * gist.github.com/786768\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.mq\n   * @optionName Modernizr.mq()\n   * @optionProp mq\n   * @access public\n   * @function mq\n   * @param {string} mq - String of the media query we want to test\n   * @returns {boolean}\n   * @example\n   * Modernizr.mq allows for you to programmatically check if the current browser\n   * window state matches a media query.\n   *\n   * ```js\n   *  var query = Modernizr.mq('(min-width: 900px)');\n   *\n   *  if (query) {\n   *    // the browser window is larger than 900px\n   *  }\n   * ```\n   *\n   * Only valid media queries are supported, therefore you must always include values\n   * with your media query\n   *\n   * ```js\n   * // good\n   *  Modernizr.mq('(min-width: 900px)');\n   *\n   * // bad\n   *  Modernizr.mq('min-width');\n   * ```\n   *\n   * If you would just like to test that media queries are supported in general, use\n   *\n   * ```js\n   *  Modernizr.mq('only all'); // true if MQ are supported, false if not\n   * ```\n   *\n   * Note that if the browser does not support media queries (e.g. old IE) mq will\n   * always return false.\n   */\n  var mq = (function() {\n    var matchMedia = window.matchMedia || window.msMatchMedia;\n    if (matchMedia) {\n      return function(mq) {\n        var mql = matchMedia(mq);\n        return mql && mql.matches || false;\n      };\n    }\n\n    return function(mq) {\n      var bool = false;\n\n      injectElementWithStyles('@media ' + mq + ' { #modernizr { position: absolute; } }', function(node) {\n        bool = computedStyle(node, null, 'position') === 'absolute';\n      });\n\n      return bool;\n    };\n  })();\n\n  ModernizrProto.mq = mq;\n\n  \n\n  /**\n   * contains checks to see if a string contains another string\n   *\n   * @access private\n   * @function contains\n   * @param {string} str - The string we want to check for substrings\n   * @param {string} substr - The substring we want to search the first string for\n   * @returns {boolean} true if and only if the first string 'str' contains the second string 'substr'\n   */\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\n   */\n  var modElem = {\n    elem: createElement('modernizr')\n  };\n\n  // Clean up this element\n  Modernizr._q.push(function() {\n    delete modElem.elem;\n  });\n\n  \n\n  var mStyle = {\n    style: modElem.elem.style\n  };\n\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\n  // the front of the queue.\n  Modernizr._q.unshift(function() {\n    delete mStyle.style;\n  });\n\n  \n\n  /**\n   * domToCSS takes a camelCase string and converts it to hyphen-case\n   * e.g. boxSizing -> box-sizing\n   *\n   * @access private\n   * @function domToCSS\n   * @param {string} name - String name of camelCase prop we want to convert\n   * @returns {string} The hyphen-case version of the supplied name\n   */\n  function domToCSS(name) {\n    return name.replace(/([A-Z])/g, function(str, m1) {\n      return '-' + m1.toLowerCase();\n    }).replace(/^ms-/, '-ms-');\n  }\n\n  ;\n\n  /**\n   * nativeTestProps allows for us to use native feature detection functionality if available.\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @access private\n   * @function nativeTestProps\n   * @param {Array} props - An array of property names\n   * @param {string} value - A string representing the value we want to check via @supports\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\n   */\n  // Accepts a list of property names and a single value\n  // Returns `undefined` if native detection not available\n  function nativeTestProps(props, value) {\n    var i = props.length;\n    // Start with the JS API: https://www.w3.org/TR/css3-conditional/#the-css-interface\n    if ('CSS' in window && 'supports' in window.CSS) {\n      // Try every prefixed variant of the property\n      while (i--) {\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    // Otherwise fall back to at-rule (for Opera 12.x)\n    else if ('CSSSupportsRule' in window) {\n      // Build a condition string for every prefixed variant\n      var conditionText = [];\n      while (i--) {\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\n      }\n      conditionText = conditionText.join(' or ');\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\n        return computedStyle(node, null, 'position') === 'absolute';\n      });\n    }\n    return undefined;\n  }\n  ;\n\n  /**\n   * cssToDOM takes a hyphen-case string and converts it to camelCase\n   * e.g. box-sizing -> boxSizing\n   *\n   * @access private\n   * @function cssToDOM\n   * @param {string} name - String name of hyphen-case prop we want to convert\n   * @returns {string} The camelCase version of the supplied name\n   */\n  function cssToDOM(name) {\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\n      return m1 + m2.toUpperCase();\n    }).replace(/^-/, '');\n  }\n\n  ;\n\n  // testProps is a generic CSS / DOM property test.\n\n  // In testing support for a given CSS property, it's legit to test:\n  //    `elem.style[styleName] !== undefined`\n  // If the property is supported it will return an empty string,\n  // if unsupported it will return undefined.\n\n  // We'll take advantage of this quick test and skip setting a style\n  // on our modernizr element, but instead just testing undefined vs\n  // empty string.\n\n  // Property names can be provided in either camelCase or hyphen-case.\n\n  function testProps(props, prefixed, value, skipValueTest) {\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\n\n    // Try native detect first\n    if (!is(value, 'undefined')) {\n      var result = nativeTestProps(props, value);\n      if (!is(result, 'undefined')) {\n        return result;\n      }\n    }\n\n    // Otherwise do it properly\n    var afterInit, i, propsLength, prop, before;\n\n    // If we don't have a style element, that means we're running async or after\n    // the core tests, so we'll need to create our own elements to use.\n\n    // Inside of an SVG element, in certain browsers, the `style` element is only\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\n    // fall back to a less used element and hope for the best.\n    // For strict XHTML browsers the hardly used samp element is used.\n    var elems = ['modernizr', 'tspan', 'samp'];\n    while (!mStyle.style && elems.length) {\n      afterInit = true;\n      mStyle.modElem = createElement(elems.shift());\n      mStyle.style = mStyle.modElem.style;\n    }\n\n    // Delete the objects if we created them.\n    function cleanElems() {\n      if (afterInit) {\n        delete mStyle.style;\n        delete mStyle.modElem;\n      }\n    }\n\n    propsLength = props.length;\n    for (i = 0; i < propsLength; i++) {\n      prop = props[i];\n      before = mStyle.style[prop];\n\n      if (contains(prop, '-')) {\n        prop = cssToDOM(prop);\n      }\n\n      if (mStyle.style[prop] !== undefined) {\n\n        // If value to test has been passed in, do a set-and-check test.\n        // 0 (integer) is a valid property value, so check that `value` isn't\n        // undefined, rather than just checking it's truthy.\n        if (!skipValueTest && !is(value, 'undefined')) {\n\n          // Needs a try catch block because of old IE. This is slow, but will\n          // be avoided in most cases because `skipValueTest` will be used.\n          try {\n            mStyle.style[prop] = value;\n          } catch (e) {}\n\n          // If the property value has changed, we assume the value used is\n          // supported. If `value` is empty string, it'll fail here (because\n          // it hasn't changed), which matches how browsers have implemented\n          // CSS.supports()\n          if (mStyle.style[prop] !== before) {\n            cleanElems();\n            return prefixed === 'pfx' ? prop : true;\n          }\n        }\n        // Otherwise just return true, or the property name if this is a\n        // `prefixed()` call\n        else {\n          cleanElems();\n          return prefixed === 'pfx' ? prop : true;\n        }\n      }\n    }\n    cleanElems();\n    return false;\n  }\n\n  ;\n\n  /**\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\n   *\n   * @access private\n   * @function fnBind\n   * @param {Function} fn - a function you want to change `this` reference to\n   * @param {object} that - the `this` you want to call the function with\n   * @returns {Function} The wrapped version of the supplied function\n   */\n  function fnBind(fn, that) {\n    return function() {\n      return fn.apply(that, arguments);\n    };\n  }\n\n  ;\n\n  /**\n   * testDOMProps is a generic DOM property test; if a browser supports\n   *   a certain property, it won't return undefined for it.\n   *\n   * @access private\n   * @function testDOMProps\n   * @param {Array<string>} props - An array of properties to test for\n   * @param {object} obj - An object or Element you want to use to test the parameters again\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\n   * @returns {boolean|*} returns `false` if the prop is unsupported, otherwise the value that is supported\n   */\n  function testDOMProps(props, obj, elem) {\n    var item;\n\n    for (var i in props) {\n      if (props[i] in obj) {\n\n        // return the property name as a string\n        if (elem === false) {\n          return props[i];\n        }\n\n        item = obj[props[i]];\n\n        // let's bind a function\n        if (is(item, 'function')) {\n          // bind to obj unless overridden\n          return fnBind(item, elem || obj);\n        }\n\n        // return the unbound function or obj or value\n        return item;\n      }\n    }\n    return false;\n  }\n\n  ;\n\n  /**\n   * testPropsAll tests a list of DOM properties we want to check against.\n   * We specify literally ALL possible (known and/or likely) properties on\n   * the element including the non-vendor prefixed one, for forward-\n   * compatibility.\n   *\n   * @access private\n   * @function testPropsAll\n   * @param {string} prop - A string of the property to test for\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\n   * @param {string} [value] - A string of a css value\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\n   * @returns {string|boolean} returns the string version of the property, or `false` if it is unsupported\n   */\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\n\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\n      props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\n\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\n      return testProps(props, prefixed, value, skipValueTest);\n\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\n    } else {\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\n      return testDOMProps(props, prefixed, elem);\n    }\n  }\n\n  // Modernizr.testAllProps() investigates whether a given style property,\n  // or any of its vendor-prefixed variants, is recognized\n  //\n  // Note that the property names must be provided in the camelCase variant.\n  // Modernizr.testAllProps('boxSizing')\n  ModernizrProto.testAllProps = testPropsAll;\n\n  \n\n  /**\n   * prefixed returns the prefixed or nonprefixed property name variant of your input\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.prefixed\n   * @optionName Modernizr.prefixed()\n   * @optionProp prefixed\n   * @access public\n   * @function prefixed\n   * @param {string} prop - String name of the property to test for\n   * @param {object} [obj] - An object to test for the prefixed properties on\n   * @param {HTMLElement} [elem] - An element used to test specific properties against\n   * @returns {string|boolean} The string representing the (possibly prefixed) valid\n   * version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * Modernizr.prefixed takes a string css value in the DOM style camelCase (as\n   * opposed to the css style hyphen-case) form and returns the (possibly prefixed)\n   * version of that property that the browser actually supports.\n   *\n   * For example, in older Firefox...\n   * ```js\n   * prefixed('boxSizing')\n   * ```\n   * returns 'MozBoxSizing'\n   *\n   * In newer Firefox, as well as any other browser that support the unprefixed\n   * version would simply return `boxSizing`. Any browser that does not support\n   * the property at all, it will return `false`.\n   *\n   * By default, prefixed is checked against a DOM element. If you want to check\n   * for a property on another object, just pass it as a second argument\n   *\n   * ```js\n   * var rAF = prefixed('requestAnimationFrame', window);\n   *\n   * raf(function() {\n   *  renderFunction();\n   * })\n   * ```\n   *\n   * Note that this will return _the actual function_ - not the name of the function.\n   * If you need the actual name of the property, pass in `false` as a third argument\n   *\n   * ```js\n   * var rAFProp = prefixed('requestAnimationFrame', window, false);\n   *\n   * rafProp === 'WebkitRequestAnimationFrame' // in older webkit\n   * ```\n   *\n   * One common use case for prefixed is if you're trying to determine which transition\n   * end event to bind to, you might do something like...\n   * ```js\n   * var transEndEventNames = {\n   *     'WebkitTransition' : 'webkitTransitionEnd', * Saf 6, Android Browser\n   *     'MozTransition'    : 'transitionend',       * only for FF < 15\n   *     'transition'       : 'transitionend'        * IE10, Opera, Chrome, FF 15+, Saf 7+\n   * };\n   *\n   * var transEndEventName = transEndEventNames[ Modernizr.prefixed('transition') ];\n   * ```\n   *\n   * If you want a similar lookup, but in hyphen-case, you can use [prefixedCSS](#modernizr-prefixedcss).\n   */\n  var prefixed = ModernizrProto.prefixed = function(prop, obj, elem) {\n    if (prop.indexOf('@') === 0) {\n      return atRule(prop);\n    }\n\n    if (prop.indexOf('-') !== -1) {\n      // Convert hyphen-case to camelCase\n      prop = cssToDOM(prop);\n    }\n    if (!obj) {\n      return testPropsAll(prop, 'pfx');\n    } else {\n      // Testing DOM property e.g. Modernizr.prefixed('requestAnimationFrame', window) // 'mozRequestAnimationFrame'\n      return testPropsAll(prop, obj, elem);\n    }\n  };\n\n  \n\n  /**\n   * List of property values to set for css tests. See ticket #21\n   * https://github.com/modernizr/modernizr/issues/21\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._prefixes\n   * @optionName Modernizr._prefixes\n   * @optionProp prefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._prefixes is the internal list of prefixes that we test against\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\n   * an array of hyphen-case vendor prefixes you can use within your code.\n   *\n   * Some common use cases include\n   *\n   * Generating all possible prefixed version of a CSS property\n   * ```js\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\n   *\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\n   * ```\n   *\n   * Generating all possible prefixed version of a CSS value\n   * ```js\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\n   *\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\n   * ```\n   */\n  // we use ['',''] rather than an empty array in order to allow a pattern of .`join()`ing prefixes to test\n  // values in feature detects to continue to work\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['','']);\n\n  // expose these for the plugin API. Look in the source for how to join() them against your input\n  ModernizrProto._prefixes = prefixes;\n\n  \n\n  /**\n   * prefixedCSS is just like [prefixed](#modernizr-prefixed), but the returned values are in\n   * hyphen-case (e.g. `box-sizing`) rather than camelCase (boxSizing).\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.prefixedCSS\n   * @optionName Modernizr.prefixedCSS()\n   * @optionProp prefixedCSS\n   * @access public\n   * @function prefixedCSS\n   * @param {string} prop - String name of the property to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * `Modernizr.prefixedCSS` is like `Modernizr.prefixed`, but returns the result\n   * in hyphenated form\n   *\n   * ```js\n   * Modernizr.prefixedCSS('transition') // '-moz-transition' in old Firefox\n   * ```\n   *\n   * Since it is only useful for CSS style properties, it can only be tested against\n   * an HTMLElement.\n   *\n   * Properties can be passed as both the DOM style camelCase or CSS style hyphen-case.\n   */\n  var prefixedCSS = ModernizrProto.prefixedCSS = function(prop) {\n    var prefixedProp = prefixed(prop);\n    return prefixedProp && domToCSS(prefixedProp);\n  };\n\n  \n\n  /**\n   * testAllProps determines whether a given CSS property is supported in the browser\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testAllProps\n   * @optionName Modernizr.testAllProps()\n   * @optionProp testAllProps\n   * @access public\n   * @function testAllProps\n   * @param {string} prop - String naming the property to test (either camelCase or hyphen-case)\n   * @param {string} [value] - String of the value to test\n   * @param {boolean} [skipValueTest=false] - Whether to skip testing that the value is supported when using non-native detection\n   * @returns {string|boolean} returns the string version of the property, or `false` if it is unsupported\n   * @example\n   *\n   * testAllProps determines whether a given CSS property, in some prefixed form,\n   * is supported by the browser.\n   *\n   * ```js\n   * testAllProps('boxSizing')  // true\n   * ```\n   *\n   * It can optionally be given a CSS value in string form to test if a property\n   * value is valid\n   *\n   * ```js\n   * testAllProps('display', 'block') // true\n   * testAllProps('display', 'penguin') // false\n   * ```\n   *\n   * A boolean can be passed as a third parameter to skip the value check when\n   * native detection (@supports) isn't available.\n   *\n   * ```js\n   * testAllProps('shapeOutside', 'content-box', true);\n   * ```\n   */\n  function testAllProps(prop, value, skipValueTest) {\n    return testPropsAll(prop, undefined, undefined, value, skipValueTest);\n  }\n\n  ModernizrProto.testAllProps = testAllProps;\n\n  \n\n  /**\n   * testProp() investigates whether a given style property is recognized\n   * Property names can be provided in either camelCase or hyphen-case.\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testProp\n   * @access public\n   * @optionName Modernizr.testProp()\n   * @optionProp testProp\n   * @function testProp\n   * @param {string} prop - Name of the CSS property to check\n   * @param {string} [value] - Name of the CSS value to check\n   * @param {boolean} [useValue] - Whether or not to check the value if @supports isn't supported\n   * @returns {boolean} an empty string if the property is supported, undefined if its unsupported\n   * @example\n   *\n   * Just like [testAllProps](#modernizr-testallprops), only it does not check any vendor prefixed\n   * version of the string.\n   *\n   * Note that the property name must be provided in camelCase (e.g. boxSizing not box-sizing)\n   *\n   * ```js\n   * Modernizr.testProp('pointerEvents')  // true\n   * ```\n   *\n   * You can also provide a value as an optional second argument to check if a\n   * specific value is supported\n   *\n   * ```js\n   * Modernizr.testProp('pointerEvents', 'none') // true\n   * Modernizr.testProp('pointerEvents', 'penguin') // false\n   * ```\n   */\n  var testProp = ModernizrProto.testProp = function(prop, value, useValue) {\n    return testProps([prop], undefined, value, useValue);\n  };\n\n  \n\n  /**\n   * testStyles injects an element with style element and some CSS rules\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testStyles\n   * @optionName Modernizr.testStyles()\n   * @optionProp testStyles\n   * @access public\n   * @function testStyles\n   * @param {string} rule - String representing a css rule\n   * @param {Function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   * @example\n   *\n   * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page\n   * along with (possibly multiple) DOM elements. This lets you check for features\n   * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules).\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) {\n   *   // elem is the first DOM node in the page (by default #modernizr)\n   *   // rule is the first argument you supplied - the CSS rule in string form\n   *\n   *   addTest('widthworks', elem.style.width === '9px')\n   * });\n   * ```\n   *\n   * If your test requires multiple nodes, you can include a third argument\n   * indicating how many additional div elements to include on the page. The\n   * additional nodes are injected as children of the `elem` that is returned as\n   * the first argument to the callback.\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) {\n   *   document.getElementById('modernizr').style.width === '1px'; // true\n   *   document.getElementById('modernizr2').style.width === '2px'; // true\n   *   elem.firstChild === document.getElementById('modernizr2'); // true\n   * }, 1);\n   * ```\n   *\n   * By default, all of the additional elements have an ID of `modernizr[n]`, where\n   * `n` is its index (e.g. the first additional, second overall is `#modernizr2`,\n   * the second additional is `#modernizr3`, etc.).\n   * If you want to have more meaningful IDs for your function, you can provide\n   * them as the fourth argument, as an array of strings\n   *\n   * ```js\n   * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) {\n   *   elem.firstChild === document.getElementById('foo'); // true\n   *   elem.lastChild === document.getElementById('bar'); // true\n   * }, 2, ['foo', 'bar']);\n   * ```\n   */\n  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\n  \n/*!\n{\n  \"name\": \"a[download] Attribute\",\n  \"property\": \"adownload\",\n  \"caniuse\": \"download\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"builderAliases\": [\"a_download\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://developers.whatwg.org/links.html#downloading-resources\"\n  }]\n}\n!*/\n/* DOC\nWhen used on an `<a>`, this attribute signifies that the resource it points to should be downloaded by the browser rather than navigating to it.\n*/\n\n  Modernizr.addTest('adownload', !window.externalHost && 'download' in createElement('a'));\n\n/*!\n{\n  \"name\": \"Application Cache\",\n  \"property\": \"applicationcache\",\n  \"caniuse\": \"offline-apps\",\n  \"tags\": [\"storage\", \"offline\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/docs/HTML/Using_the_application_cache\"\n  }],\n  \"polyfills\": [\"html5gears\"]\n}\n!*/\n/* DOC\nDetects support for the Application Cache, for storing data to enable web-based applications run offline.\n\nThe API has been [heavily criticized](https://alistapart.com/article/application-cache-is-a-douchebag) and discussions are underway to address this.\n*/\n\n  Modernizr.addTest('applicationcache', 'applicationCache' in window);\n\n/*!\n{\n  \"name\": \"Blob constructor\",\n  \"property\": \"blobconstructor\",\n  \"aliases\": [\"blob-constructor\"],\n  \"builderAliases\": [\"blob_constructor\"],\n  \"caniuse\": \"blobbuilder\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://w3c.github.io/FileAPI/#constructorBlob\"\n  }],\n  \"polyfills\": [\"blobjs\"]\n}\n!*/\n/* DOC\nDetects support for the Blob constructor, for creating file-like objects of immutable, raw data.\n*/\n\n  Modernizr.addTest('blobconstructor', function() {\n    try {\n      return !!new Blob();\n    } catch (e) {\n      return false;\n    }\n  }, {\n    aliases: ['blob-constructor']\n  });\n\n/*!\n{\n  \"name\": \"Canvas\",\n  \"property\": \"canvas\",\n  \"caniuse\": \"canvas\",\n  \"tags\": [\"canvas\", \"graphics\"],\n  \"polyfills\": [\"flashcanvas\", \"excanvas\", \"slcanvas\", \"fxcanvas\"]\n}\n!*/\n/* DOC\nDetects support for the `<canvas>` element for 2D drawing.\n*/\n\n  // On the S60 and BB Storm, getContext exists, but always returns undefined\n  // so we actually have to call getContext() to verify\n  // github.com/Modernizr/Modernizr/issues/issue/97/\n  Modernizr.addTest('canvas', function() {\n    var elem = createElement('canvas');\n    return !!(elem.getContext && elem.getContext('2d'));\n  });\n\n/*!\n{\n  \"name\": \"canvas blending support\",\n  \"property\": \"canvasblending\",\n  \"caniuse\": \"canvas-blending\",\n  \"tags\": [\"canvas\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://drafts.fxtf.org/compositing-1/\"\n  }, {\n    \"name\": \"Article\",\n    \"href\": \"https://web.archive.org/web/20171003232921/http://blogs.adobe.com/webplatform/2013/01/28/blending-features-in-canvas/\"\n  }]\n}\n!*/\n/* DOC\nDetects if Photoshop style blending modes are available in canvas.\n*/\n\n  Modernizr.addTest('canvasblending', function() {\n    if (Modernizr.canvas === false) {\n      return false;\n    }\n    var ctx = createElement('canvas').getContext('2d');\n    // firefox 3 throws an error when setting an invalid `globalCompositeOperation`\n    try {\n      ctx.globalCompositeOperation = 'screen';\n    } catch (e) {}\n\n    return ctx.globalCompositeOperation === 'screen';\n  });\n\n/*!\n{\n  \"name\": \"canvas.toDataURL type support\",\n  \"property\": [\"todataurljpeg\", \"todataurlpng\", \"todataurlwebp\"],\n  \"tags\": [\"canvas\"],\n  \"builderAliases\": [\"canvas_todataurl_type\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement.toDataURL\"\n  }]\n}\n!*/\n\n\n  var canvas = createElement('canvas');\n\n  Modernizr.addTest('todataurljpeg', function() {\n    var supports = false;\n\n    // AVG secure browser with 'Anti-Fingerprinting' turned on throws an exception when using an \"invalid\" toDataUrl\n    try {\n      supports = !!Modernizr.canvas && canvas.toDataURL('image/jpeg').indexOf('data:image/jpeg') === 0;\n    } catch (e) {}\n\n    return supports;\n  });\n  Modernizr.addTest('todataurlpng', function() {\n    var supports = false;\n\n    // AVG secure browser with 'Anti-Fingerprinting' turned on throws an exception when using an \"invalid\" toDataUrl\n    try {\n      supports = !!Modernizr.canvas && canvas.toDataURL('image/png').indexOf('data:image/png') === 0;\n    } catch (e) {}\n\n    return supports;\n  });\n  Modernizr.addTest('todataurlwebp', function() {\n    var supports = false;\n\n    // firefox 3 throws an error when you use an \"invalid\" toDataUrl\n    try {\n      supports = !!Modernizr.canvas && canvas.toDataURL('image/webp').indexOf('data:image/webp') === 0;\n    } catch (e) {}\n\n    return supports;\n  });\n\n\n/*!\n{\n  \"name\": \"canvas winding support\",\n  \"property\": \"canvaswinding\",\n  \"tags\": [\"canvas\"],\n  \"notes\": [{\n    \"name\": \"Article\",\n    \"href\": \"https://web.archive.org/web/20170825024655/http://blogs.adobe.com/webplatform/2013/01/30/winding-rules-in-canvas/\"\n  }]\n}\n!*/\n/* DOC\nDetermines if winding rules, which controls if a path can go clockwise or counterclockwise\n*/\n\n\n  Modernizr.addTest('canvaswinding', function() {\n    if (Modernizr.canvas === false) {\n      return false;\n    }\n    var ctx = createElement('canvas').getContext('2d');\n\n    ctx.rect(0, 0, 10, 10);\n    ctx.rect(2, 2, 6, 6);\n    return ctx.isPointInPath(5, 5, 'evenodd') === false;\n  });\n\n\n/*!\n{\n  \"name\": \"Canvas text\",\n  \"property\": \"canvastext\",\n  \"caniuse\": \"canvas-text\",\n  \"tags\": [\"canvas\", \"graphics\"],\n  \"polyfills\": [\"canvastext\"]\n}\n!*/\n/* DOC\nDetects support for the text APIs for `<canvas>` elements.\n*/\n\n  Modernizr.addTest('canvastext', function() {\n    if (Modernizr.canvas === false) {\n      return false;\n    }\n    return typeof createElement('canvas').getContext('2d').fillText === 'function';\n  });\n\n/*!\n{\n  \"name\": \"Content Editable\",\n  \"property\": \"contenteditable\",\n  \"caniuse\": \"contenteditable\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/interaction.html#contenteditable\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the `contenteditable` attribute of elements, allowing their DOM text contents to be edited directly by the user.\n*/\n\n  Modernizr.addTest('contenteditable', function() {\n    // early bail out\n    if (!('contentEditable' in docElement)) {\n      return;\n    }\n\n    // some mobile browsers (android < 3.0, iOS < 5) claim to support\n    // contentEditable, but but don't really. This test checks to see\n    // confirms whether or not it actually supports it.\n\n    var div = createElement('div');\n    div.contentEditable = true;\n    return div.contentEditable === 'true';\n  });\n\n/*!\n{\n  \"name\": \"Context menus\",\n  \"property\": \"contextmenu\",\n  \"caniuse\": \"menu\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/html5/interactive-elements.html#context-menus\"\n  }, {\n    \"name\": \"thewebrocks.com Demo\",\n    \"href\": \"http://thewebrocks.com/demos/context-menu/\"\n  }],\n  \"polyfills\": [\"jquery-contextmenu\"]\n}\n!*/\n/* DOC\nDetects support for custom context menus.\n*/\n\n  Modernizr.addTest(\n    'contextmenu',\n    ('contextMenu' in docElement && 'HTMLMenuItemElement' in window)\n  );\n\n/*!\n{\n  \"name\": \"Cookies\",\n  \"property\": \"cookies\",\n  \"tags\": [\"storage\"],\n  \"authors\": [\"tauren\"]\n}\n!*/\n/* DOC\nDetects whether cookie support is enabled.\n*/\n\n  // https://github.com/Modernizr/Modernizr/issues/191\n\n  Modernizr.addTest('cookies', function() {\n    // navigator.cookieEnabled cannot detect custom or nuanced cookie blocking\n    // configurations. For example, when blocking cookies via the Advanced\n    // Privacy Settings in IE9, it always returns true. And there have been\n    // issues in the past with site-specific exceptions.\n    // Don't rely on it.\n\n    // try..catch because some in situations `document.cookie` is exposed but throws a\n    // SecurityError if you try to access it; e.g. documents created from data URIs\n    // or in sandboxed iframes (depending on flags/context)\n    try {\n      // Create cookie\n      document.cookie = 'cookietest=1';\n      var ret = document.cookie.indexOf('cookietest=') !== -1;\n      // Delete cookie\n      document.cookie = 'cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT';\n      return ret;\n    }\n    catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"name\": \"Cross-Origin Resource Sharing\",\n  \"property\": \"cors\",\n  \"caniuse\": \"cors\",\n  \"authors\": [\"Theodoor van Donge\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/HTTP/Access_control_CORS\"\n  }],\n  \"polyfills\": [\"pmxdr\", \"ppx\", \"flxhr\"]\n}\n!*/\n/* DOC\nDetects support for Cross-Origin Resource Sharing: method of performing XMLHttpRequests across domains.\n*/\n\n  Modernizr.addTest('cors', 'XMLHttpRequest' in window && 'withCredentials' in new XMLHttpRequest());\n\n/*!\n{\n  \"name\": \"Custom Elements API\",\n  \"property\": \"customelements\",\n  \"caniuse\": \"custom-elementsv1\",\n  \"tags\": [\"customelements\"],\n  \"polyfills\": [\"customelements\"],\n  \"notes\": [{\n    \"name\": \"Specs for Custom Elements\",\n    \"href\": \"https://www.w3.org/TR/custom-elements/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the Custom Elements API, to create custom html elements via js\n*/\n\n  Modernizr.addTest('customelements', 'customElements' in window);\n\n/*!\n{\n  \"name\": \"cssall\",\n  \"property\": \"cssall\",\n  \"notes\": [{\n    \"name\": \"Spec\",\n    \"href\": \"https://drafts.csswg.org/css-cascade/#all-shorthand\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the `all` css property, which is a shorthand to reset all css properties (except direction and unicode-bidi) to their original value\n*/\n\n\n  Modernizr.addTest('cssall', 'all' in docElement.style);\n\n/*!\n{\n  \"name\": \"CSS Animations\",\n  \"property\": \"cssanimations\",\n  \"caniuse\": \"css-animation\",\n  \"polyfills\": [\"transformie\", \"csssandpaper\"],\n  \"tags\": [\"css\"],\n  \"warnings\": [\"Android < 4 will pass this test, but can only animate a single property at a time\"],\n  \"notes\": [{\n    \"name\": \"Article: 'Dispelling the Android CSS animation myths'\",\n    \"href\": \"https://web.archive.org/web/20180602074607/https://daneden.me/2011/12/14/putting-up-with-androids-bullshit/\"\n  }]\n}\n!*/\n/* DOC\nDetects whether or not elements can be animated using CSS\n*/\n\n  Modernizr.addTest('cssanimations', testAllProps('animationName', 'a', true));\n\n/*!\n{\n  \"name\": \"Appearance\",\n  \"property\": \"appearance\",\n  \"caniuse\": \"css-appearance\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-appearance\"\n  }, {\n    \"name\": \"CSS-Tricks CSS Almanac: appearance\",\n    \"href\": \"https://css-tricks.com/almanac/properties/a/appearance/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the `appearance` css property, which is used to make an\nelement inherit the style of a standard user interface element. It can also be\nused to remove the default styles of an element, such as input and buttons.\n*/\n\n  Modernizr.addTest('appearance', testAllProps('appearance'));\n\n/*!\n{\n  \"name\": \"Backdrop Filter\",\n  \"property\": \"backdropfilter\",\n  \"authors\": [\"Brian Seward\"],\n  \"tags\": [\"css\"],\n  \"caniuse\": \"css-backdrop-filter\",\n  \"notes\": [{\n    \"name\": \"W3C Editor’s Draft Spec\",\n    \"href\": \"https://drafts.fxtf.org/filters-2/#BackdropFilterProperty\"\n  }, {\n    \"name\": \"WebKit Blog introduction + Demo\",\n    \"href\": \"https://www.webkit.org/blog/3632/introducing-backdrop-filters/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for CSS Backdrop Filters, allowing for background blur effects like those introduced in iOS 7. Support for this was added to iOS Safari/WebKit in iOS 9.\n*/\n\n  Modernizr.addTest('backdropfilter', testAllProps('backdropFilter'));\n\n/*!\n{\n  \"name\": \"CSS Background Blend Mode\",\n  \"property\": \"backgroundblendmode\",\n  \"caniuse\": \"css-backgroundblendmode\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"CSS Blend Modes could be the next big thing in Web Design\",\n    \"href\": \"https://medium.com/@bennettfeely/css-blend-modes-could-be-the-next-big-thing-in-web-design-6b51bf53743a\"\n  }, {\n    \"name\": \"Demo\",\n    \"href\": \"https://bennettfeely.com/gradients/\"\n  }]\n}\n!*/\n/* DOC\nDetects the ability for the browser to composite backgrounds using blending modes similar to ones found in Photoshop or Illustrator.\n*/\n\n  Modernizr.addTest('backgroundblendmode', prefixed('backgroundBlendMode', 'text'));\n\n/*!\n{\n  \"name\": \"CSS Background Clip Text\",\n  \"property\": \"backgroundcliptext\",\n  \"authors\": [\"ausi\"],\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"CSS Tricks Article\",\n    \"href\": \"https://css-tricks.com/image-under-text/\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/background-clip\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/199\"\n  }]\n}\n!*/\n/* DOC\nDetects the ability to control specifies whether or not an element's background\nextends beyond its border in CSS\n*/\n\n  Modernizr.addTest('backgroundcliptext', function() {\n    return testAllProps('backgroundClip', 'text');\n  });\n\n/*!\n{\n  \"name\": \"Background Position Shorthand\",\n  \"property\": \"bgpositionshorthand\",\n  \"caniuse\": \"css-background-offsets\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_backgroundposition_shorthand\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/CSS/background-position\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-background/#background-position\"\n  }, {\n    \"name\": \"Demo\",\n    \"href\": \"https://jsfiddle.net/Blink/bBXvt/\"\n  }]\n}\n!*/\n/* DOC\nDetects if you can use the shorthand method to define multiple parts of an\nelement's background-position simultaneously.\n\neg `background-position: right 10px bottom 10px`\n*/\n\n  Modernizr.addTest('bgpositionshorthand', function() {\n    var elem = createElement('a');\n    var eStyle = elem.style;\n    var val = 'right 10px bottom 10px';\n    eStyle.cssText = 'background-position: ' + val + ';';\n    return (eStyle.backgroundPosition === val);\n  });\n\n/*!\n{\n  \"name\": \"Background Position XY\",\n  \"property\": \"bgpositionxy\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_backgroundposition_xy\"],\n  \"authors\": [\"Allan Lei\", \"Brandom Aaron\"],\n  \"notes\": [{\n    \"name\": \"Demo\",\n    \"href\": \"https://jsfiddle.net/allanlei/R8AYS/\"\n  }, {\n    \"name\": \"Adapted From\",\n    \"href\": \"https://github.com/brandonaaron/jquery-cssHooks/blob/master/bgpos.js\"\n  }]\n}\n!*/\n/* DOC\nDetects the ability to control an element's background position using css\n*/\n\n  Modernizr.addTest('bgpositionxy', function() {\n    return testAllProps('backgroundPositionX', '3px', true) && testAllProps('backgroundPositionY', '5px', true);\n  });\n\n/*!\n{\n  \"name\": \"Background Repeat\",\n  \"property\": [\"bgrepeatspace\", \"bgrepeatround\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_backgroundrepeat\"],\n  \"authors\": [\"Ryan Seddon\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/background-repeat\"\n  }, {\n    \"name\": \"Test Page\",\n    \"href\": \"https://jsbin.com/uzesun/\"\n  }, {\n    \"name\": \"Demo\",\n    \"href\": \"https://jsfiddle.net/ryanseddon/yMLTQ/6/\"\n  }]\n}\n!*/\n/* DOC\nDetects the ability to use round and space as properties for background-repeat\n*/\n\n  // Must value-test these\n  Modernizr.addTest('bgrepeatround', testAllProps('backgroundRepeat', 'round'));\n  Modernizr.addTest('bgrepeatspace', testAllProps('backgroundRepeat', 'space'));\n\n/*!\n{\n  \"name\": \"Background Size\",\n  \"property\": \"backgroundsize\",\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\"This will false positive in Opera Mini - https://github.com/Modernizr/Modernizr/issues/396\"],\n  \"notes\": [{\n    \"name\": \"Related Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/396\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('backgroundsize', testAllProps('backgroundSize', '100%', true));\n\n/*!\n{\n  \"name\": \"Background Size Cover\",\n  \"property\": \"bgsizecover\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_backgroundsizecover\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/CSS/background-size\"\n  }]\n}\n!*/\n\n  // Must test value, as this specifically tests the `cover` value\n  Modernizr.addTest('bgsizecover', testAllProps('backgroundSize', 'cover'));\n\n/*!\n{\n  \"name\": \"Border Image\",\n  \"property\": \"borderimage\",\n  \"caniuse\": \"border-image\",\n  \"polyfills\": [\"css3pie\"],\n  \"knownBugs\": [\"Android < 2.0 is true, but has a broken implementation\"],\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('borderimage', testAllProps('borderImage', 'url() 1', true));\n\n/*!\n{\n  \"name\": \"Border Radius\",\n  \"property\": \"borderradius\",\n  \"caniuse\": \"border-radius\",\n  \"polyfills\": [\"css3pie\"],\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"Comprehensive Compat Chart\",\n    \"href\": \"https://muddledramblings.com/table-of-css3-border-radius-compliance\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('borderradius', testAllProps('borderRadius', '0px', true));\n\n/*!\n{\n  \"name\": \"Box Shadow\",\n  \"property\": \"boxshadow\",\n  \"caniuse\": \"css-boxshadow\",\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\n    \"WebOS false positives on this test.\",\n    \"The Kindle Silk browser false positives\"\n  ]\n}\n!*/\n\n  Modernizr.addTest('boxshadow', testAllProps('boxShadow', '1px 1px', true));\n\n/*!\n{\n  \"name\": \"Box Sizing\",\n  \"property\": \"boxsizing\",\n  \"caniuse\": \"css3-boxsizing\",\n  \"polyfills\": [\"borderboxmodel\", \"boxsizingpolyfill\", \"borderbox\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_boxsizing\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/box-sizing\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/248\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('boxsizing', testAllProps('boxSizing', 'border-box', true) && (document.documentMode === undefined || document.documentMode > 7));\n\n/*!\n{\n  \"name\": \"CSS Calc\",\n  \"property\": \"csscalc\",\n  \"caniuse\": \"calc\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_calc\"],\n  \"authors\": [\"@calvein\"]\n}\n!*/\n/* DOC\nMethod of allowing calculated values for length units. For example:\n\n```css\n//lem {\n  width: calc(100% - 3em);\n}\n```\n*/\n\n  Modernizr.addTest('csscalc', function() {\n    var prop = 'width:';\n    var value = 'calc(10px);';\n    var el = createElement('a');\n\n    el.style.cssText = prop + prefixes.join(value + prop);\n\n    return !!el.style.length;\n  });\n\n/*!\n{\n  \"name\": \"CSS :checked pseudo-selector\",\n  \"caniuse\": \"css-sel3\",\n  \"property\": \"checked\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/pull/879\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('checked', function() {\n    return testStyles('#modernizr {position:absolute} #modernizr input {margin-left:10px} #modernizr :checked {margin-left:20px;display:block}', function(elem) {\n      var cb = createElement('input');\n      cb.setAttribute('type', 'checkbox');\n      cb.setAttribute('checked', 'checked');\n      elem.appendChild(cb);\n      return cb.offsetLeft === 20;\n    });\n  });\n\n/*!\n{\n  \"name\": \"CSS Font ch Units\",\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"property\": \"csschunit\",\n  \"caniuse\": \"ch-unit\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-values/#font-relative-lengths\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('csschunit', function() {\n    var elemStyle = modElem.elem.style;\n    var supports;\n    try {\n      elemStyle.fontSize = '3ch';\n      supports = elemStyle.fontSize.indexOf('ch') !== -1;\n    } catch (e) {\n      supports = false;\n    }\n    return supports;\n  });\n\n/*!\n{\n  \"name\": \"CSS Columns\",\n  \"property\": \"csscolumns\",\n  \"caniuse\": \"multicolumn\",\n  \"polyfills\": [\"css3multicolumnjs\"],\n  \"tags\": [\"css\"]\n}\n!*/\n\n\n  (function() {\n\n    Modernizr.addTest('csscolumns', function() {\n      var bool = false;\n      var test = testAllProps('columnCount');\n      try {\n        bool = !!test;\n        if (bool) {\n          bool = new Boolean(bool);\n        }\n      } catch (e) {}\n\n      return bool;\n    });\n\n    var props = ['Width', 'Span', 'Fill', 'Gap', 'Rule', 'RuleColor', 'RuleStyle', 'RuleWidth', 'BreakBefore', 'BreakAfter', 'BreakInside'];\n    var name, test;\n\n    for (var i = 0; i < props.length; i++) {\n      name = props[i].toLowerCase();\n      test = testAllProps('column' + props[i]);\n\n      // break-before, break-after & break-inside are not \"column\"-prefixed in spec\n      if (name === 'breakbefore' || name === 'breakafter' || name === 'breakinside') {\n        test = test || testAllProps(props[i]);\n      }\n\n      Modernizr.addTest('csscolumns.' + name, test);\n    }\n  })();\n\n/*!\n{\n  \"name\": \"CSS Grid (old & new)\",\n  \"property\": [\"cssgrid\", \"cssgridlegacy\"],\n  \"authors\": [\"Faruk Ates\"],\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"The new, standardized CSS Grid\",\n    \"href\": \"https://www.w3.org/TR/css3-grid-layout/\"\n  }, {\n    \"name\": \"The _old_ CSS Grid (legacy)\",\n    \"href\": \"https://www.w3.org/TR/2011/WD-css3-grid-layout-20110407/\"\n  }]\n}\n!*/\n\n  // `grid-columns` is only in the old syntax, `grid-column` exists in both and so `grid-template-rows` is used for the new syntax.\n  Modernizr.addTest('cssgridlegacy', testAllProps('grid-columns', '10px', true));\n  Modernizr.addTest('cssgrid', testAllProps('grid-template-rows', 'none', true));\n\n/*!\n{\n  \"name\": \"CSS Cubic Bezier Range\",\n  \"property\": \"cubicbezierrange\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_cubicbezierrange\"],\n  \"authors\": [\"@calvein\"],\n  \"warnings\": [\"cubic-bezier values can't be > 1 for Webkit until [bug #45761](https://bugs.webkit.org/show_bug.cgi?id=45761) is fixed\"],\n  \"notes\": [{\n    \"name\": \"Comprehensive Compat Chart\",\n    \"href\": \"https://muddledramblings.com/table-of-css3-border-radius-compliance/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('cubicbezierrange', function() {\n    var el = createElement('a');\n    el.style.cssText = prefixes.join('transition-timing-function:cubic-bezier(1,0,0,1.1); ');\n    return !!el.style.length;\n  });\n\n/*!\n{\n  \"name\": \"CSS Display run-in\",\n  \"property\": \"display-runin\",\n  \"authors\": [\"alanhogan\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_displayrunin\"],\n  \"notes\": [{\n    \"name\": \"CSS Tricks Article\",\n    \"href\": \"https://web.archive.org/web/20111204150927/http://css-tricks.com:80/596-run-in/\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/198\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('displayrunin', testAllProps('display', 'run-in'),\n    {aliases: ['display-runin']});\n\n/*!\n{\n  \"name\": \"CSS Display table\",\n  \"property\": \"displaytable\",\n  \"caniuse\": \"css-table\",\n  \"authors\": [\"scottjehl\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_displaytable\"],\n  \"notes\": [{\n    \"name\": \"Detects for all additional table display values\",\n    \"href\": \"https://pastebin.com/Gk9PeVaQ\"\n  }]\n}\n!*/\n/* DOC\n`display: table` and `table-cell` test. (both are tested under one name `table-cell` )\n*/\n\n  // If a document is in rtl mode this test will fail so we force ltr mode on the injected\n  // element https://github.com/Modernizr/Modernizr/issues/716\n  testStyles('#modernizr{display: table; direction: ltr}#modernizr div{display: table-cell; padding: 10px}', function(elem) {\n    var ret;\n    var child = elem.childNodes;\n    ret = child[0].offsetLeft < child[1].offsetLeft;\n    Modernizr.addTest('displaytable', ret, {aliases: ['display-table']});\n  }, 2);\n\n/*!\n{\n  \"name\": \"CSS text-overflow ellipsis\",\n  \"property\": \"ellipsis\",\n  \"caniuse\": \"text-overflow\",\n  \"polyfills\": [\"text-overflow\"],\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('ellipsis', testAllProps('textOverflow', 'ellipsis'));\n\n/*!\n{\n  \"name\": \"CSS.escape()\",\n  \"property\": \"cssescape\",\n  \"polyfills\": [\"css-escape\"],\n  \"tags\": [\"css\", \"cssom\"]\n}\n!*/\n/* DOC\nTests for `CSS.escape()` support.\n*/\n\n  var CSS = window.CSS;\n  Modernizr.addTest('cssescape', CSS ? typeof CSS.escape === 'function' : false);\n\n/*!\n{\n  \"name\": \"CSS Font ex Units\",\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"property\": \"cssexunit\",\n  \"caniuse\": \"mdn-css_types_length_ex\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-values/#font-relative-lengths\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('cssexunit', function() {\n    var elemStyle = modElem.elem.style;\n    var supports;\n    try {\n      elemStyle.fontSize = '3ex';\n      supports = elemStyle.fontSize.indexOf('ex') !== -1;\n    } catch (e) {\n      supports = false;\n    }\n    return supports;\n  });\n\n/*!\n{\n  \"name\": \"CSS Supports\",\n  \"property\": \"supports\",\n  \"caniuse\": \"css-featurequeries\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_supports\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec (The @supports rule)\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#at-supports\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/648\"\n  }, {\n    \"name\": \"W3C Spec (The CSSSupportsRule interface)\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface\"\n  }]\n}\n!*/\n\n  var newSyntax = 'CSS' in window && 'supports' in window.CSS;\n  var oldSyntax = 'supportsCSS' in window;\n  Modernizr.addTest('supports', newSyntax || oldSyntax);\n\n/*!\n{\n  \"name\": \"CSS Filters\",\n  \"property\": \"cssfilters\",\n  \"caniuse\": \"css-filters\",\n  \"polyfills\": [\"polyfilter\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_filters\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/filter\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('cssfilters', function() {\n    if (Modernizr.supports) {\n      return testAllProps('filter', 'blur(2px)');\n    } else {\n      var el = createElement('a');\n      el.style.cssText = prefixes.join('filter:blur(2px); ');\n      // https://github.com/Modernizr/Modernizr/issues/615\n      // documentMode is needed for false positives in oldIE, please see issue above\n      return !!el.style.length && ((document.documentMode === undefined || document.documentMode > 9));\n    }\n  });\n\n\n/*!\n{\n  \"name\": \"Flexbox\",\n  \"property\": \"flexbox\",\n  \"caniuse\": \"flexbox\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"The _new_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/css-flexbox-1/\"\n  }],\n  \"warnings\": [\n    \"A `true` result for this detect does not imply that the `flex-wrap` property is supported; see the `flexwrap` detect.\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the Flexible Box Layout model, a.k.a. Flexbox, which allows easy manipulation of layout order and sizing within a container.\n*/\n\n  Modernizr.addTest('flexbox', testAllProps('flexBasis', '1px', true));\n\n/*!\n{\n  \"name\": \"Flexbox (legacy)\",\n  \"property\": \"flexboxlegacy\",\n  \"tags\": [\"css\"],\n  \"polyfills\": [\"flexie\"],\n  \"notes\": [{\n    \"name\": \"The _old_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('flexboxlegacy', testAllProps('boxDirection', 'reverse', true));\n\n/*!\n{\n  \"name\": \"Flexbox (tweener)\",\n  \"property\": \"flexboxtweener\",\n  \"tags\": [\"css\"],\n  \"polyfills\": [\"flexie\"],\n  \"notes\": [{\n    \"name\": \"The _inbetween_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/2011/WD-css3-flexbox-20111129/\"\n  }],\n  \"warnings\": [\"This represents an old syntax, not the latest standard syntax.\"]\n}\n!*/\n\n  Modernizr.addTest('flexboxtweener', testAllProps('flexAlign', 'end', true));\n\n/*!\n{\n  \"name\": \"Flex Line Wrapping\",\n  \"property\": \"flexwrap\",\n  \"tags\": [\"css\", \"flexbox\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css-flexbox-1/\"\n  }],\n  \"warnings\": [\n    \"Does not imply a modern implementation – see documentation.\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the `flex-wrap` CSS property, part of Flexbox, which isn’t present in all Flexbox implementations (notably Firefox).\n\nThis featured in both the 'tweener' syntax (implemented by IE10) and the 'modern' syntax (implemented by others). This detect will return `true` for either of these implementations, as long as the `flex-wrap` property is supported. So to ensure the modern syntax is supported, use together with `Modernizr.flexbox`:\n\n```javascript\nif (Modernizr.flexbox && Modernizr.flexwrap) {\n  // Modern Flexbox with `flex-wrap` supported\n}\nelse {\n  // Either old Flexbox syntax, or `flex-wrap` not supported\n}\n```\n*/\n\n  Modernizr.addTest('flexwrap', testAllProps('flexWrap', 'wrap', true));\n\n/*!\n{\n  \"name\": \"@font-face\",\n  \"property\": \"fontface\",\n  \"authors\": [\"Diego Perini\", \"Mat Marquis\"],\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\n    \"False Positive: WebOS https://github.com/Modernizr/Modernizr/issues/342\",\n    \"False Positive: WP7 https://github.com/Modernizr/Modernizr/issues/538\"\n  ],\n  \"notes\": [{\n    \"name\": \"@font-face detection routine by Diego Perini\",\n    \"href\": \"http://javascript.nwbox.com/CSSSupport/\"\n  }, {\n    \"name\": \"Filament Group @font-face compatibility research\",\n    \"href\": \"https://docs.google.com/presentation/d/1n4NyG4uPRjAA8zn_pSQ_Ket0RhcWC6QlZ6LMjKeECo0/edit#slide=id.p\"\n  }, {\n    \"name\": \"Filament Grunticon/@font-face device testing results\",\n    \"href\": \"https://docs.google.com/spreadsheet/ccc?key=0Ag5_yGvxpINRdHFYeUJPNnZMWUZKR2ItMEpRTXZPdUE#gid=0\"\n  }, {\n    \"name\": \"CSS fonts on Android\",\n    \"href\": \"https://stackoverflow.com/questions/3200069/css-fonts-on-android\"\n  }, {\n    \"name\": \"@font-face and Android\",\n    \"href\": \"http://archivist.incutio.com/viewlist/css-discuss/115960\"\n  }]\n}\n!*/\n\n  var unsupportedUserAgent = (function() {\n    var ua = navigator.userAgent;\n    var webos = ua.match(/w(eb)?osbrowser/gi);\n    var wppre8 = ua.match(/windows phone/gi) && ua.match(/iemobile\\/([0-9])+/gi) && parseFloat(RegExp.$1) >= 9;\n    return webos || wppre8;\n  }());\n  if (unsupportedUserAgent) {\n    Modernizr.addTest('fontface', false);\n  } else {\n    testStyles('@font-face {font-family:\"font\";src:url(\"https://\")}', function(node, rule) {\n      var style = document.getElementById('smodernizr');\n      var sheet = style.sheet || style.styleSheet;\n      var cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : '';\n      var bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0;\n      Modernizr.addTest('fontface', bool);\n    });\n  }\n;\n/*!\n{\n  \"name\": \"CSS Generated Content\",\n  \"property\": \"generatedcontent\",\n  \"tags\": [\"css\"],\n  \"warnings\": [\"Android won't return correct height for anything below 7px #738\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-selectors/#gen-content\"\n  }, {\n    \"name\": \"MDN Docs on :before\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/::before\"\n  }, {\n    \"name\": \"MDN Docs on :after\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/::after\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr{font:0/0 a}#modernizr:after{content:\":)\";visibility:hidden;font:7px/1 a}', function(node) {\n    // See bug report on why this value is 6 crbug.com/608142\n    Modernizr.addTest('generatedcontent', node.offsetHeight >= 6);\n  });\n\n/*!\n{\n  \"name\": \"CSS Gradients\",\n  \"caniuse\": \"css-gradients\",\n  \"property\": \"cssgradients\",\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\"False-positives on webOS (https://github.com/Modernizr/Modernizr/issues/202)\"],\n  \"notes\": [{\n    \"name\": \"Webkit Gradient Syntax\",\n    \"href\": \"https://webkit.org/blog/175/introducing-css-gradients/\"\n  }, {\n    \"name\": \"Linear Gradient Syntax\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://drafts.csswg.org/css-images-3/#gradients\"\n  }]\n}\n!*/\n\n\n  Modernizr.addTest('cssgradients', function() {\n\n    var str1 = 'background-image:';\n    var str2 = 'gradient(linear,left top,right bottom,from(#9f9),to(white));';\n    var css = '';\n    var angle;\n\n    for (var i = 0, len = prefixes.length - 1; i < len; i++) {\n      angle = (i === 0 ? 'to ' : '');\n      css += str1 + prefixes[i] + 'linear-gradient(' + angle + 'left top, #9f9, white);';\n    }\n\n    if (Modernizr._config.usePrefixes) {\n    // legacy webkit syntax (TODO:: remove when syntax not in use anymore)\n      css += str1 + '-webkit-' + str2;\n    }\n\n    var elem = createElement('a');\n    var style = elem.style;\n    style.cssText = css;\n\n    // IE6 returns undefined so cast to string\n    return ('' + style.backgroundImage).indexOf('gradient') > -1;\n  });\n\n/*! {\n  \"name\": \"CSS Hairline\",\n  \"property\": \"hairline\",\n  \"tags\": [\"css\"],\n  \"authors\": [\"strarsis\"],\n  \"notes\": [{\n    \"name\": \"Blog post about CSS retina hairlines\",\n    \"href\": \"http://dieulot.net/css-retina-hairline\"\n  }, {\n    \"name\": \"Derived from\",\n    \"href\": \"https://gist.github.com/dieulot/520a49463f6058fbc8d1\"\n  }]\n}\n!*/\n/* DOC\nDetects support for hidpi/retina hairlines, which are CSS borders with less than 1px in width, for being physically 1px on hidpi screens.\n*/\n\n  Modernizr.addTest('hairline', function() {\n    return testStyles('#modernizr {border:.5px solid transparent}', function(elem) {\n      return elem.offsetHeight === 1;\n    });\n  });\n\n/*!\n{\n  \"name\": \"CSS HSLA Colors\",\n  \"caniuse\": \"css3-colors\",\n  \"property\": \"hsla\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('hsla', function() {\n    var style = createElement('a').style;\n    style.cssText = 'background-color:hsla(120,40%,100%,.5)';\n    return contains(style.backgroundColor, 'rgba') || contains(style.backgroundColor, 'hsla');\n  });\n\n/*!\n{\n  \"name\": \"CSS :invalid pseudo-class\",\n  \"property\": \"cssinvalid\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/:invalid\"\n  }]\n}\n!*/\n/* DOC\n  Detects support for the ':invalid' CSS pseudo-class.\n*/\n\n  Modernizr.addTest('cssinvalid', function() {\n    return testStyles('#modernizr input{height:0;border:0;padding:0;margin:0;width:10px} #modernizr input:invalid{width:50px}', function(elem) {\n      var input = createElement('input');\n      input.required = true;\n      elem.appendChild(input);\n      return input.clientWidth > 10;\n    });\n  });\n\n/*!\n{\n  \"name\": \"CSS :last-child pseudo-selector\",\n  \"caniuse\": \"css-sel3\",\n  \"property\": \"lastchild\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_lastchild\"],\n  \"notes\": [{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/pull/304\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr div {width:100px} #modernizr :last-child{width:200px;display:block}', function(elem) {\n    Modernizr.addTest('lastchild', elem.lastChild.offsetWidth > elem.firstChild.offsetWidth);\n  }, 2);\n\n/*!\n{\n  \"name\": \"CSS Mask\",\n  \"caniuse\": \"css-masks\",\n  \"property\": \"cssmask\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_mask\"],\n  \"notes\": [{\n    \"name\": \"Webkit blog on CSS Masks\",\n    \"href\": \"https://webkit.org/blog/181/css-masks/\"\n  }, {\n    \"name\": \"Safari Docs\",\n    \"href\": \"https://developer.apple.com/library/archive/documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Masks/Masks.html\"\n  }, {\n    \"name\": \"CSS SVG mask\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/mask\"\n  }, {\n    \"name\": \"Combine with clippaths for awesomeness\",\n    \"href\": \"https://web.archive.org/web/20150508193041/http://generic.cx:80/for/webkit/test.html\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('cssmask', testAllProps('maskRepeat', 'repeat-x', true));\n\n/*!\n{\n  \"name\": \"CSS Media Queries\",\n  \"caniuse\": \"css-mediaqueries\",\n  \"property\": \"mediaqueries\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_mediaqueries\"]\n}\n!*/\n\n  Modernizr.addTest('mediaqueries', mq('only all'));\n\n/*!\n{\n  \"name\": \"CSS Multiple Backgrounds\",\n  \"caniuse\": \"multibackgrounds\",\n  \"property\": \"multiplebgs\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  // Setting multiple images AND a color on the background shorthand property\n  // and then querying the style.background property value for the number of\n  // occurrences of \"url(\" is a reliable method for detecting ACTUAL support for this!\n\n  Modernizr.addTest('multiplebgs', function() {\n    var style = createElement('a').style;\n    style.cssText = 'background:url(https://),url(https://),red url(https://)';\n\n    // If the UA supports multiple backgrounds, there should be three occurrences\n    // of the string \"url(\" in the return value for elemStyle.background\n    return (/(url\\s*\\(.*?){3}/).test(style.background);\n  });\n\n/*!\n{\n  \"name\": \"CSS :nth-child pseudo-selector\",\n  \"caniuse\": \"css-sel3\",\n  \"property\": \"nthchild\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/pull/685\"\n  }, {\n    \"name\": \"Sitepoint :nth-child documentation\",\n    \"href\": \"https://www.sitepoint.com/atoz-css-screencast-nth-child/\"\n  }],\n  \"authors\": [\"@emilchristensen\"],\n  \"warnings\": [\"Known false negative in Safari 3.1 and Safari 3.2.2\"]\n}\n!*/\n/* DOC\nDetects support for the ':nth-child()' CSS pseudo-selector.\n*/\n\n  // 4 `<div>` elements with `1px` width are created. Then every other element has its `width` set to `2px`.\n  // Then we check if the width of the even elements is different then the width of the odd elements\n  // while the two even elements have the same width (and the two odd elements too).\n  // Earlier versions of the tests tried to check for the actual width which didnt work on chrome when the\n  // browser was zoomed in our out in specific ways.\n  testStyles('#modernizr div {width:1px} #modernizr div:nth-child(2n) {width:2px;}', function(elem) {\n    var elems = elem.getElementsByTagName('div');\n    var correctWidths = elems[0].offsetWidth === elems[2].offsetWidth &&\n      elems[1].offsetWidth === elems[3].offsetWidth &&\n      elems[0].offsetWidth !== elems[1].offsetWidth;\n    Modernizr.addTest('nthchild', correctWidths);\n  }, 4);\n\n/*!\n{\n  \"name\": \"CSS Object Fit\",\n  \"caniuse\": \"object-fit\",\n  \"property\": \"objectfit\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_objectfit\"],\n  \"notes\": [{\n    \"name\": \"Opera Article on Object Fit\",\n    \"href\": \"https://dev.opera.com/articles/css3-object-fit-object-position/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('objectfit', !!prefixed('objectFit'), {aliases: ['object-fit']});\n\n/*!\n{\n  \"name\": \"CSS Opacity\",\n  \"caniuse\": \"css-opacity\",\n  \"property\": \"opacity\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  // Browsers that actually have CSS Opacity implemented have done so\n  // according to spec, which means their return values are within the\n  // range of [0.0,1.0] - including the leading zero.\n\n  Modernizr.addTest('opacity', function() {\n    var style = createElement('a').style;\n    style.cssText = prefixes.join('opacity:.55;');\n\n    // The non-literal . in this regex is intentional:\n    // German Chrome returns this value as 0,55\n    // github.com/Modernizr/Modernizr/issues/#issue/59/comment/516632\n    return (/^0.55$/).test(style.opacity);\n  });\n\n/*!\n{\n  \"name\": \"CSS Overflow Scrolling\",\n  \"property\": \"overflowscrolling\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_overflow_scrolling\"],\n  \"warnings\": [\"Introduced in iOS5b2. API is subject to change.\"],\n  \"notes\": [{\n    \"name\": \"Article on iOS overflow scrolling\",\n    \"href\": \"https://css-tricks.com/snippets/css/momentum-scrolling-on-ios-overflow-elements/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('overflowscrolling', testAllProps('overflowScrolling', 'touch', true));\n\n/*!\n{\n  \"name\": \"CSS Pointer Events\",\n  \"caniuse\": \"pointer-events\",\n  \"property\": \"csspointerevents\",\n  \"authors\": [\"ausi\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_pointerevents\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/pointer-events\"\n  }, {\n    \"name\": \"Test Project Page\",\n    \"href\": \"https://ausi.github.com/Feature-detection-technique-for-pointer-events/\"\n  }, {\n    \"name\": \"Test Project Wiki\",\n    \"href\": \"https://github.com/ausi/Feature-detection-technique-for-pointer-events/wiki\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/80\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('csspointerevents', function() {\n    var style = createElement('a').style;\n    style.cssText = 'pointer-events:auto';\n    return style.pointerEvents === 'auto';\n  });\n\n/*!\n{\n  \"name\": \"CSS position: sticky\",\n  \"property\": \"csspositionsticky\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_positionsticky\"],\n  \"notes\": [{\n    \"name\": \"Chrome bug report\",\n    \"href\":\"https://bugs.chromium.org/p/chromium/issues/detail?id=322972\"\n  }],\n  \"warnings\": [\"using position:sticky on anything but top aligned elements is buggy in Chrome < 37 and iOS <=7+\"]\n}\n!*/\n\n  // Sticky positioning - constrains an element to be positioned inside the\n  // intersection of its container box, and the viewport.\n  Modernizr.addTest('csspositionsticky', function() {\n    var prop = 'position:';\n    var value = 'sticky';\n    var el = createElement('a');\n    var mStyle = el.style;\n\n    mStyle.cssText = prop + prefixes.join(value + ';' + prop).slice(0, -prop.length);\n\n    return mStyle.position.indexOf(value) !== -1;\n  });\n\n/*!\n{\n  \"name\": \"CSS Generated Content Animations\",\n  \"property\": \"csspseudoanimations\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('csspseudoanimations', function() {\n    var result = false;\n\n    if (!Modernizr.cssanimations) {\n      return result;\n    }\n\n    var styles = [\n      '@', prefixes.join('keyframes csspseudoanimations { from { font-size: 10px; } }@').replace(/\\@$/, ''),\n      '#modernizr:before { content:\" \"; font-size:5px;',\n      prefixes.join('animation:csspseudoanimations 1ms infinite;'),\n      '}'\n    ].join('');\n\n    testStyles(styles, function(elem) {\n      result = computedStyle(elem, ':before', 'font-size') === '10px';\n    });\n\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"CSS Transitions\",\n  \"property\": \"csstransitions\",\n  \"caniuse\": \"css-transitions\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('csstransitions', testAllProps('transition', 'all', true));\n\n/*!\n{\n  \"name\": \"CSS Generated Content Transitions\",\n  \"property\": \"csspseudotransitions\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('csspseudotransitions', function() {\n    var result = false;\n\n    if (!Modernizr.csstransitions) {\n      return result;\n    }\n\n    var styles =\n      '#modernizr:before { content:\" \"; font-size:5px;' + prefixes.join('transition:0s 100s;') + '}' +\n      '#modernizr.trigger:before { font-size:10px; }';\n\n    testStyles(styles, function(elem) {\n      // Force rendering of the element's styles so that the transition will trigger\n      computedStyle(elem, ':before', 'font-size');\n      elem.className += 'trigger';\n      result = computedStyle(elem, ':before', 'font-size') === '5px';\n    });\n\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"CSS Reflections\",\n  \"caniuse\": \"css-reflections\",\n  \"property\": \"cssreflections\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('cssreflections', testAllProps('boxReflect', 'above', true));\n\n/*!\n{\n  \"name\": \"CSS Regions\",\n  \"caniuse\": \"css-regions\",\n  \"authors\": [\"Mihai Balan\"],\n  \"property\": \"regions\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_regions\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-regions/\"\n  }]\n}\n!*/\n\n  // We start with a CSS parser test then we check page geometry to see if it's affected by regions\n  // Later we might be able to retire the second part, as WebKit builds with the false positives die out\n\n  Modernizr.addTest('regions', function() {\n\n    if (isSVG) {\n      // css regions don't work inside of SVG elements. Rather than update the\n      // below test to work in an SVG context, just exit early to save bytes\n      return false;\n    }\n\n    /* Get the 'flowFrom' property name available in the browser. Either default or vendor prefixed.\n       If the property name can't be found we'll get Boolean 'false' and fail quickly */\n    var flowFromProperty = prefixed('flowFrom');\n    var flowIntoProperty = prefixed('flowInto');\n    var result = false;\n\n    if (!flowFromProperty || !flowIntoProperty) {\n      return result;\n    }\n\n    /* If CSS parsing is there, try to determine if regions actually work. */\n    var iframeContainer = createElement('iframe');\n    var container = createElement('div');\n    var content = createElement('div');\n    var region = createElement('div');\n\n    /* we create a random, unlikely to be generated flow number to make sure we don't\n       clash with anything more vanilla, like 'flow', or 'article', or 'f1' */\n    var flowName = 'modernizr_flow_for_regions_check';\n\n    /* First create a div with two adjacent divs inside it. The first will be the\n       content, the second will be the region. To be able to distinguish between the two,\n       we'll give the region a particular padding */\n    content.innerText = 'M';\n    container.style.cssText = 'top: 150px; left: 150px; padding: 0px;';\n    region.style.cssText = 'width: 50px; height: 50px; padding: 42px;';\n\n    region.style[flowFromProperty] = flowName;\n    container.appendChild(content);\n    container.appendChild(region);\n    docElement.appendChild(container);\n\n    /* Now compute the bounding client rect, before and after attempting to flow the\n       content div in the region div. If regions are enabled, the after bounding rect\n       should reflect the padding of the region div.*/\n    var flowedRect, delta;\n    var plainRect = content.getBoundingClientRect();\n\n    content.style[flowIntoProperty] = flowName;\n    flowedRect = content.getBoundingClientRect();\n\n    delta = parseInt(flowedRect.left - plainRect.left, 10);\n    docElement.removeChild(container);\n\n    if (delta === 42) {\n      result = true;\n    } else {\n      /* IE only allows for the content to come from iframes. This has the\n       * side effect of automatic collapsing of iframes once they get the flow-into\n       * property set. checking for a change on the height allows us to detect this\n       * in a sync way, without having to wait for a frame to load */\n\n      docElement.appendChild(iframeContainer);\n      plainRect = iframeContainer.getBoundingClientRect();\n      iframeContainer.style[flowIntoProperty] = flowName;\n      flowedRect = iframeContainer.getBoundingClientRect();\n\n      if (plainRect.height > 0 && plainRect.height !== flowedRect.height && flowedRect.height === 0) {\n        result = true;\n      }\n    }\n\n    content = region = container = iframeContainer = undefined;\n\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"CSS Font rem Units\",\n  \"caniuse\": \"rem\",\n  \"authors\": [\"nsfmc\"],\n  \"property\": \"cssremunit\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_remunit\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-values/#relative0\"\n  }, {\n    \"name\": \"Font Size with rem by Jonathan Snook\",\n    \"href\": \"https://snook.ca/archives/html_and_css/font-size-with-rem\"\n  }]\n}\n!*/\n\n  // \"The 'rem' unit ('root em') is relative to the computed\n  // value of the 'font-size' value of the root element.\"\n  // you can test by checking if the prop was ditched\n\n  Modernizr.addTest('cssremunit', function() {\n    var style = createElement('a').style;\n    try {\n      style.fontSize = '3rem';\n    }\n    catch (e) {}\n    return (/rem/).test(style.fontSize);\n  });\n\n/*!\n{\n  \"name\": \"CSS UI Resize\",\n  \"property\": \"cssresize\",\n  \"caniuse\": \"css-resize\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_resize\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-ui/#resize\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/CSS/resize\"\n  }]\n}\n!*/\n/* DOC\nTest for CSS 3 UI \"resize\" property\n*/\n\n  Modernizr.addTest('cssresize', testAllProps('resize', 'both', true));\n\n/*!\n{\n  \"name\": \"CSS rgba\",\n  \"caniuse\": \"css3-colors\",\n  \"property\": \"rgba\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"CSSTricks Tutorial\",\n    \"href\": \"https://css-tricks.com/rgba-browser-support/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('rgba', function() {\n    var style = createElement('a').style;\n    style.cssText = 'background-color:rgba(150,255,150,.5)';\n\n    return ('' + style.backgroundColor).indexOf('rgba') > -1;\n  });\n\n/*!\n{\n  \"name\": \"CSS Stylable Scrollbars\",\n  \"property\": \"cssscrollbar\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_scrollbars\"]\n}\n!*/\n\n  testStyles('#modernizr{overflow: scroll; width: 40px; height: 40px; }#' + prefixes\n    .join('scrollbar{width:10px}' + ' #modernizr::')\n    .split('#')\n    .slice(1)\n    .join('#') + 'scrollbar{width:10px}',\n  function(node) {\n    Modernizr.addTest('cssscrollbar', 'scrollWidth' in node && node.scrollWidth === 30);\n  });\n\n/*!\n{\n  \"name\": \"Scroll Snap Points\",\n  \"property\": \"scrollsnappoints\",\n  \"caniuse\": \"css-snappoints\",\n  \"notes\": [{\n    \"name\": \"Setting native-like scrolling offsets in CSS with Scrolling Snap Points\",\n    \"href\": \"http://generatedcontent.org/post/66817675443/setting-native-like-scrolling-offsets-in-css-with\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Scroll_Snap_Points\"\n  }],\n  \"polyfills\": [\"scrollsnap\"]\n}\n!*/\n/* DOC\nDetects support for CSS Snap Points\n*/\n\n  Modernizr.addTest('scrollsnappoints', testAllProps('scrollSnapType'));\n\n/*!\n{\n  \"name\": \"CSS Shapes\",\n  \"property\": \"shapes\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css-shapes\"\n  }, {\n    \"name\": \"Examples from Adobe\",\n    \"href\": \"https://web.archive.org/web/20171230010236/http://webplatform.adobe.com:80/shapes\"\n  }, {\n    \"name\": \"Examples from CSS-Tricks\",\n    \"href\": \"https://css-tricks.com/examples/ShapesOfCSS/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('shapes', testAllProps('shapeOutside', 'content-box', true));\n\n/*!\n{\n  \"name\": \"CSS general sibling selector\",\n  \"caniuse\": \"css-sel3\",\n  \"property\": \"siblinggeneral\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/pull/889\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('siblinggeneral', function() {\n    return testStyles('#modernizr div {width:100px} #modernizr div ~ div {width:200px;display:block}', function(elem) {\n      return elem.lastChild.offsetWidth === 200;\n    }, 2);\n  });\n\n/*!\n{\n  \"name\": \"CSS Subpixel Fonts\",\n  \"property\": \"subpixelfont\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_subpixelfont\"],\n  \"authors\": [\"@derSchepp\", \"@gerritvanaaken\", \"@rodneyrehm\", \"@yatil\", \"@ryanseddon\"],\n  \"notes\": [{\n    \"name\": \"Origin Test\",\n    \"href\": \"https://github.com/gerritvanaaken/subpixeldetect\"\n  }]\n}\n!*/\n\n  /*\n   * (to infer if GDI or DirectWrite is used on Windows)\n   */\n  testStyles(\n    '#modernizr{position: absolute; top: -10em; visibility:hidden; font: normal 10px arial;}#subpixel{float: left; font-size: 33.3333%;}',\n    function(elem) {\n      var subpixel = elem.firstChild;\n      subpixel.innerHTML = 'This is a text written in Arial';\n      Modernizr.addTest('subpixelfont', computedStyle(subpixel, null, 'width') !== '44px');\n    }, 1, ['subpixel']);\n\n/*!\n{\n  \"name\": \"CSS :target pseudo-class\",\n  \"caniuse\": \"css-sel3\",\n  \"property\": \"target\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/:target\"\n  }],\n  \"authors\": [\"@zachleat\"],\n  \"warnings\": [\"Opera Mini supports :target but doesn't update the hash for anchor links.\"]\n}\n!*/\n/* DOC\nDetects support for the ':target' CSS pseudo-class.\n*/\n\n  // querySelector\n  Modernizr.addTest('target', function() {\n    var doc = window.document;\n    if (!('querySelectorAll' in doc)) {\n      return false;\n    }\n\n    try {\n      doc.querySelectorAll(':target');\n      return true;\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"name\": \"CSS text-align-last\",\n  \"property\": \"textalignlast\",\n  \"caniuse\": \"css-text-align-last\",\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\"IE does not support the 'start' or 'end' values.\"],\n  \"notes\": [{\n    \"name\": \"Quirksmode\",\n    \"href\": \"https://www.quirksmode.org/css/text/textalignlast.html\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/text-align-last\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('textalignlast', testAllProps('textAlignLast'));\n\n/*!\n{\n  \"name\": \"CSS textshadow\",\n  \"property\": \"textshadow\",\n  \"caniuse\": \"css-textshadow\",\n  \"tags\": [\"css\"],\n  \"knownBugs\": [\"FF3.0 will false positive on this test\"]\n}\n!*/\n\n  Modernizr.addTest('textshadow', testProp('textShadow', '1px 1px'));\n\n/*!\n{\n  \"name\": \"CSS Transforms\",\n  \"property\": \"csstransforms\",\n  \"caniuse\": \"transforms2d\",\n  \"tags\": [\"css\"]\n}\n!*/\n\n  Modernizr.addTest('csstransforms', function() {\n    // Android < 3.0 is buggy, so we sniff and reject it\n    // https://github.com/Modernizr/Modernizr/issues/903\n    return navigator.userAgent.indexOf('Android 2.') === -1 &&\n           testAllProps('transform', 'scale(1)', true);\n  });\n\n/*!\n{\n  \"name\": \"CSS Transforms Level 2\",\n  \"property\": \"csstransformslevel2\",\n  \"authors\": [\"rupl\"],\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"CSSWG Draft Spec\",\n    \"href\": \"https://drafts.csswg.org/css-transforms-2/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('csstransformslevel2', function() {\n    return testAllProps('translate', '45px', true);\n  });\n\n/*!\n{\n  \"name\": \"CSS Transforms 3D\",\n  \"property\": \"csstransforms3d\",\n  \"caniuse\": \"transforms3d\",\n  \"tags\": [\"css\"],\n  \"warnings\": [\n    \"Chrome may occasionally fail this test on some systems; more info: https://bugs.chromium.org/p/chromium/issues/detail?id=129004\"\n  ]\n}\n!*/\n\n  Modernizr.addTest('csstransforms3d', function() {\n    return !!testAllProps('perspective', '1px', true);\n  });\n\n/*!\n{\n  \"name\": \"CSS Transform Style preserve-3d\",\n  \"property\": \"preserve3d\",\n  \"authors\": [\"denyskoch\", \"aFarkas\"],\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/transform-style\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/1748\"\n  }]\n}\n!*/\n/* DOC\nDetects support for `transform-style: preserve-3d`, for getting a proper 3D perspective on elements.\n*/\n\n  Modernizr.addTest('preserve3d', function() {\n    var outerAnchor, innerAnchor;\n    var CSS = window.CSS;\n    var result = false;\n\n    if (CSS && CSS.supports && CSS.supports('(transform-style: preserve-3d)')) {\n      return true;\n    }\n\n    outerAnchor = createElement('a');\n    innerAnchor = createElement('a');\n\n    outerAnchor.style.cssText = 'display: block; transform-style: preserve-3d; transform-origin: right; transform: rotateY(40deg);';\n    innerAnchor.style.cssText = 'display: block; width: 9px; height: 1px; background: #000; transform-origin: right; transform: rotateY(40deg);';\n\n    outerAnchor.appendChild(innerAnchor);\n    docElement.appendChild(outerAnchor);\n\n    result = innerAnchor.getBoundingClientRect();\n    docElement.removeChild(outerAnchor);\n\n    result = result.width && result.width < 4;\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"CSS user-select\",\n  \"property\": \"userselect\",\n  \"caniuse\": \"user-select-none\",\n  \"authors\": [\"ryan seddon\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_userselect\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/250\"\n  }]\n}\n!*/\n\n  //https://github.com/Modernizr/Modernizr/issues/250\n  Modernizr.addTest('userselect', testAllProps('userSelect', 'none', true));\n\n/*!\n{\n  \"name\": \"CSS :valid pseudo-class\",\n  \"property\": \"cssvalid\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/:valid\"\n  }]\n}\n!*/\n/* DOC\n  Detects support for the ':valid' CSS pseudo-class.\n*/\n\n  Modernizr.addTest('cssvalid', function() {\n    return testStyles('#modernizr input{height:0;border:0;padding:0;margin:0;width:10px} #modernizr input:valid{width:50px}', function(elem) {\n      var input = createElement('input');\n      elem.appendChild(input);\n      return input.clientWidth > 10;\n    });\n  });\n\n/*!\n{\n  \"name\": \"CSS vh unit\",\n  \"property\": \"cssvhunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vhunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  }, {\n    \"name\": \"Similar JSFiddle\",\n    \"href\": \"https://jsfiddle.net/FWeinb/etnYC/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr { height: 50vh; max-height: 10px; }', function(elem) {\n    var compStyle = parseInt(computedStyle(elem, null, 'height'), 10);\n    Modernizr.addTest('cssvhunit', compStyle === 10);\n  });\n\n\n  /**\n   * roundedEquals takes two integers and checks if the first is within 1 of the second\n   *\n   * @access private\n   * @function roundedEquals\n   * @param {number} a - first integer\n   * @param {number} b - second integer\n   * @returns {boolean} true if the first integer is within 1 of the second, false otherwise\n   */\n  function roundedEquals(a, b) {\n    return a - 1 === b || a === b || a + 1 === b;\n  }\n\n  ;\n/*!\n{\n  \"name\": \"CSS vmax unit\",\n  \"property\": \"cssvmaxunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vmaxunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  }, {\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/glsee/JDsWQ/4/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr1{width: 50vmax}#modernizr2{width:50px;height:50px;overflow:scroll}#modernizr3{position:fixed;top:0;left:0;bottom:0;right:0}', function(node) {\n    var elem = node.childNodes[2];\n    var scroller = node.childNodes[1];\n    var fullSizeElem = node.childNodes[0];\n    var scrollbarWidth = parseInt((scroller.offsetWidth - scroller.clientWidth) / 2, 10);\n\n    var one_vw = fullSizeElem.clientWidth / 100;\n    var one_vh = fullSizeElem.clientHeight / 100;\n    var expectedWidth = parseInt(Math.max(one_vw, one_vh) * 50, 10);\n    var compWidth = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvmaxunit', roundedEquals(expectedWidth, compWidth) || roundedEquals(expectedWidth, compWidth - scrollbarWidth));\n  }, 3);\n\n/*!\n{\n  \"name\": \"CSS vmin unit\",\n  \"property\": \"cssvminunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vminunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  }, {\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/glsee/JRmdq/8/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr1{width: 50vm;width:50vmin}#modernizr2{width:50px;height:50px;overflow:scroll}#modernizr3{position:fixed;top:0;left:0;bottom:0;right:0}', function(node) {\n    var elem = node.childNodes[2];\n    var scroller = node.childNodes[1];\n    var fullSizeElem = node.childNodes[0];\n    var scrollbarWidth = parseInt((scroller.offsetWidth - scroller.clientWidth) / 2, 10);\n\n    var one_vw = fullSizeElem.clientWidth / 100;\n    var one_vh = fullSizeElem.clientHeight / 100;\n    var expectedWidth = parseInt(Math.min(one_vw, one_vh) * 50, 10);\n    var compWidth = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvminunit', roundedEquals(expectedWidth, compWidth) || roundedEquals(expectedWidth, compWidth - scrollbarWidth));\n  }, 3);\n\n/*!\n{\n  \"name\": \"CSS vw unit\",\n  \"property\": \"cssvwunit\",\n  \"caniuse\": \"viewport-units\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_vwunit\"],\n  \"notes\": [{\n    \"name\": \"Related Modernizr Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/572\"\n  }, {\n    \"name\": \"JSFiddle Example\",\n    \"href\": \"https://jsfiddle.net/FWeinb/etnYC/\"\n  }]\n}\n!*/\n\n  testStyles('#modernizr { width: 50vw; }', function(elem) {\n    var width = parseInt(window.innerWidth / 2, 10);\n    var compStyle = parseInt(computedStyle(elem, null, 'width'), 10);\n\n    Modernizr.addTest('cssvwunit', roundedEquals(compStyle, width));\n  });\n\n/*!\n{\n  \"name\": \"will-change\",\n  \"property\": \"willchange\",\n  \"caniuse\": \"will-change\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://drafts.csswg.org/css-will-change/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the `will-change` css property, which formally signals to the\nbrowser that an element will be animating.\n*/\n\n  Modernizr.addTest('willchange', 'willChange' in docElement.style);\n\n/*!\n{\n  \"name\": \"CSS wrap-flow\",\n  \"property\": \"wrapflow\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/css3-exclusions\"\n  }, {\n    \"name\": \"Example by Louie Rootfield\",\n    \"href\": \"https://webdesign.tutsplus.com/tutorials/css-exclusions--cms-28087\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('wrapflow', function() {\n    var prefixedProperty = prefixed('wrapFlow');\n    if (!prefixedProperty || isSVG) {\n      return false;\n    }\n\n    var wrapFlowProperty = prefixedProperty.replace(/([A-Z])/g, function(str, m1) { return '-' + m1.toLowerCase(); }).replace(/^ms-/, '-ms-');\n\n    /* If the CSS parsing is there we need to determine if wrap-flow actually works to avoid false positive cases, e.g. the browser parses\n       the property, but it hasn't got the implementation for the functionality yet. */\n    var container = createElement('div');\n    var exclusion = createElement('div');\n    var content = createElement('span');\n\n    /* First we create a div with two adjacent divs inside it. The first div will be the content, the second div will be the exclusion area.\n       We use the \"wrap-flow: end\" property to test the actual behavior. (https://drafts.csswg.org/css-exclusions-1/#wrap-flow-property)\n       The wrap-flow property is applied to the exclusion area what has a 50px left offset and a 100px width.\n       If the wrap-flow property is working correctly then the content should start after the exclusion area, so the content's left offset should be 150px. */\n    exclusion.style.cssText = 'position: absolute; left: 50px; width: 100px; height: 20px;' + wrapFlowProperty + ':end;';\n    content.innerText = 'X';\n\n    container.appendChild(exclusion);\n    container.appendChild(content);\n    docElement.appendChild(container);\n\n    var leftOffset = content.offsetLeft;\n\n    docElement.removeChild(container);\n    exclusion = content = container = undefined;\n\n    return (leftOffset === 150);\n  });\n\n/*!\n{\n  \"name\": \"classList\",\n  \"caniuse\": \"classlist\",\n  \"property\": \"classlist\",\n  \"tags\": [\"dom\"],\n  \"builderAliases\": [\"dataview_api\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/DOM/element.classList\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('classlist', 'classList' in docElement);\n\n/*!\n{\n  \"name\": \"createElement with Attributes\",\n  \"property\": [\"createelementattrs\", \"createelement-attrs\"],\n  \"tags\": [\"dom\"],\n  \"builderAliases\": [\"dom_createElement_attrs\"],\n  \"authors\": [\"James A. Rosen\"],\n  \"notes\": [{\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/258\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('createelementattrs', function() {\n    try {\n      return createElement('<input name=\"test\" />').getAttribute('name') === 'test';\n    } catch (e) {\n      return false;\n    }\n  }, {\n    aliases: ['createelement-attrs']\n  });\n\n/*!\n{\n  \"name\": \"dataset API\",\n  \"caniuse\": \"dataset\",\n  \"property\": \"dataset\",\n  \"tags\": [\"dom\"],\n  \"builderAliases\": [\"dom_dataset\"],\n  \"authors\": [\"@phiggins42\"]\n}\n!*/\n\n  // dataset API for data-* attributes\n  Modernizr.addTest('dataset', function() {\n    var n = createElement('div');\n    n.setAttribute('data-a-b', 'c');\n    return !!(n.dataset && n.dataset.aB === 'c');\n  });\n\n/*!\n{\n  \"name\": \"Document Fragment\",\n  \"property\": \"documentfragment\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-B63ED1A3\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment\"\n  }, {\n    \"name\": \"QuirksMode Compatibility Tables\",\n    \"href\": \"https://www.quirksmode.org/m/w3c_core.html#t112\"\n  }],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"knownBugs\": [\"false-positive on Blackberry 9500, see QuirksMode note\"],\n  \"tags\": [\"dom\"]\n}\n!*/\n/* DOC\nAppend multiple elements to the DOM within a single insertion.\n*/\n\n  Modernizr.addTest('documentfragment', function() {\n    return 'createDocumentFragment' in document &&\n      'appendChild' in docElement;\n  });\n\n/*!\n{\n  \"name\": \"[hidden] Attribute\",\n  \"property\": \"hidden\",\n  \"tags\": [\"dom\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/dev/interaction.html#the-hidden-attribute\"\n  }, {\n    \"name\": \"original implementation of detect code\",\n    \"href\": \"https://github.com/aFarkas/html5shiv/blob/bf4fcc4/src/html5shiv.js#L38\"\n  }],\n  \"polyfills\": [\"html5shiv\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"]\n}\n!*/\n/* DOC\nDoes the browser support the HTML5 [hidden] attribute?\n*/\n\n  Modernizr.addTest('hidden', 'hidden' in createElement('a'));\n\n/*!\n{\n  \"name\": \"microdata\",\n  \"property\": \"microdata\",\n  \"tags\": [\"dom\"],\n  \"builderAliases\": [\"dom_microdata\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/microdata/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('microdata', 'getItems' in document);\n\n/*!\n{\n  \"name\": \"DOM4 MutationObserver\",\n  \"property\": \"mutationobserver\",\n  \"caniuse\": \"mutationobserver\",\n  \"tags\": [\"dom\"],\n  \"authors\": [\"Karel Sedláček (@ksdlck)\"],\n  \"polyfills\": [\"mutationobservers\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver\"\n  }]\n}\n!*/\n/* DOC\nDetermines if DOM4 MutationObserver support is available.\n*/\n\n  Modernizr.addTest('mutationobserver',\n    !!window.MutationObserver || !!window.WebKitMutationObserver);\n\n/*!\n{\n  \"property\": \"passiveeventlisteners\",\n  \"caniuse\": \"passive-event-listener\",\n  \"tags\": [\"dom\"],\n  \"authors\": [\"Rick Byers\"],\n  \"name\": \"Passive event listeners\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://dom.spec.whatwg.org/#dom-addeventlisteneroptions-passive\"\n  }, {\n    \"name\": \"WICG explainer\",\n    \"href\": \"https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the passive option to addEventListener.\n*/\n\n  Modernizr.addTest('passiveeventlisteners', function() {\n    var supportsPassiveOption = false;\n    try {\n      var opts = Object.defineProperty({}, 'passive', {\n        get: function() {\n          supportsPassiveOption = true;\n          return;\n        }\n      });\n      var noop = function () {};\n      window.addEventListener('testPassiveEventSupport', noop, opts);\n      window.removeEventListener('testPassiveEventSupport', noop, opts);\n    } catch (e) {}\n    return supportsPassiveOption;\n  });\n\n/*!\n{\n  \"name\": \"Orientation and Motion Events\",\n  \"property\": [\"devicemotion\", \"deviceorientation\"],\n  \"caniuse\": \"deviceorientation\",\n  \"notes\": [{\n    \"name\": \"W3C Editor's Draft Spec\",\n    \"href\": \"https://w3c.github.io/deviceorientation/\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/Detecting_device_orientation\"\n  }],\n  \"authors\": [\"Shi Chuan\"],\n  \"tags\": [\"event\"],\n  \"builderAliases\": [\"event_deviceorientation_motion\"]\n}\n!*/\n/* DOC\nPart of Device Access aspect of HTML5, same category as geolocation.\n\n`devicemotion` tests for Device Motion Event support, returns boolean value true/false.\n\n`deviceorientation` tests for Device Orientation Event support, returns boolean value true/false\n*/\n\n  Modernizr.addTest('devicemotion', 'DeviceMotionEvent' in window);\n  Modernizr.addTest('deviceorientation', 'DeviceOrientationEvent' in window);\n\n/*!\n{\n  \"name\": \"onInput Event\",\n  \"property\": \"oninput\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers.oninput\"\n  }, {\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/input.html#common-input-element-attributes\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/210\"\n  }],\n  \"authors\": [\"Patrick Kettner\"],\n  \"tags\": [\"event\"]\n}\n!*/\n/* DOC\n`oninput` tests if the browser is able to detect the input event\n*/\n\n\n  Modernizr.addTest('oninput', function() {\n    var input = createElement('input');\n    var supportsOnInput;\n    input.setAttribute('oninput', 'return');\n    input.style.cssText = 'position:fixed;top:0;';\n\n    if (hasEvent('oninput', docElement) || typeof input.oninput === 'function') {\n      return true;\n    }\n\n    // IE doesn't support onInput, so we wrap up the non IE APIs\n    // (createEvent, addEventListener) in a try catch, rather than test for\n    // their trident equivalent.\n    try {\n      // Older Firefox didn't map oninput attribute to oninput property\n      var testEvent = document.createEvent('KeyboardEvent');\n      supportsOnInput = false;\n      var handler = function(e) {\n        supportsOnInput = true;\n        e.preventDefault();\n        e.stopPropagation();\n      };\n\n      testEvent.initKeyEvent('keypress', true, true, window, false, false, false, false, 0, 'e'.charCodeAt(0));\n      docElement.appendChild(input);\n      input.addEventListener('input', handler, false);\n      input.focus();\n      input.dispatchEvent(testEvent);\n      input.removeEventListener('input', handler, false);\n      docElement.removeChild(input);\n    } catch (e) {\n      supportsOnInput = false;\n    }\n    return supportsOnInput;\n  });\n\n/*!\n{\n  \"name\": \"Event Listener\",\n  \"property\": \"eventlistener\",\n  \"caniuse\": \"addeventlistener\",\n  \"authors\": [\"Andrew Betts (@triblondon)\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-Registration-interfaces\"\n  }],\n  \"polyfills\": [\"eventlistener\"]\n}\n!*/\n/* DOC\nDetects native support for addEventListener\n*/\n\n  Modernizr.addTest('eventlistener', 'addEventListener' in window);\n\n/*!\n{\n  \"name\": \"EXIF Orientation\",\n  \"property\": \"exiforientation\",\n  \"tags\": [\"image\"],\n  \"builderAliases\": [\"exif_orientation\"],\n  \"async\": true,\n  \"authors\": [\"Paul Sayre\"],\n  \"notes\": [{\n    \"name\": \"Article by Dave Perrett\",\n    \"href\": \"https://www.daveperrett.com/articles/2012/07/28/exif-orientation-handling-is-a-ghetto/\"\n  }, {\n    \"name\": \"Article by Calvin Hass\",\n    \"href\": \"https://www.impulseadventure.com/photo/exif-orientation.html\"\n  }]\n}\n!*/\n/* DOC\nDetects support for EXIF Orientation in JPEG images.\n\niOS looks at the EXIF Orientation flag in JPEGs and rotates the image accordingly. Most desktop browsers just ignore this data.\n*/\n\n  // Bug trackers:\n  //    bugzil.la/298619 (unimplemented)\n  //    crbug.com/56845 (looks incomplete)\n  //    webk.it/19688 (available upstream but its up all ports to turn on individually)\n  Modernizr.addAsyncTest(function() {\n    var img = new Image();\n\n    img.onerror = function() {\n      addTest('exiforientation', false, {aliases: ['exif-orientation']});\n    };\n\n    img.onload = function() {\n      addTest('exiforientation', img.width !== 2, {aliases: ['exif-orientation']});\n    };\n\n    // There may be a way to shrink this more, it's a 1x2 white jpg with the orientation flag set to 6\n    img.src = 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/4QAiRXhpZgAASUkqAAgAAAABABIBAwABAAAABgASAAAAAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAABAAIDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+/iiiigD/2Q==';\n  });\n\n/*!\n{\n  \"name\": \"input[capture] Attribute\",\n  \"property\": \"capture\",\n  \"tags\": [\"video\", \"image\", \"audio\", \"media\", \"attribute\"],\n  \"notes\": [{\n    \"name\": \"W3C Draft Spec\",\n    \"href\": \"https://www.w3.org/TR/html-media-capture/\"\n  }]\n}\n!*/\n/* DOC\nWhen used on an `<input>`, this attribute signifies that the resource it takes should be generated via device's camera, camcorder, sound recorder.\n*/\n\n  // testing for capture attribute in inputs\n  Modernizr.addTest('capture', ('capture' in createElement('input')));\n\n/*!\n{\n  \"name\": \"input[file] Attribute\",\n  \"property\": \"fileinput\",\n  \"caniuse\": \"forms\",\n  \"tags\": [\"file\", \"forms\", \"input\"],\n  \"builderAliases\": [\"forms_fileinput\"]\n}\n!*/\n/* DOC\nDetects whether input type=\"file\" is available on the platform\n\nE.g. iOS < 6, some android versions and embedded Chrome WebViews don't support this\n*/\n\n  Modernizr.addTest('fileinput', function() {\n    var ua = navigator.userAgent;\n    if (ua.match(/(Android (1.0|1.1|1.5|1.6|2.0|2.1))|(Windows Phone (OS 7|8.0))|(XBLWP)|(ZuneWP)|(w(eb)?OSBrowser)|(webOS)|(Kindle\\/(1.0|2.0|2.5|3.0))/) ||\n        ua.match(/\\swv\\).+(chrome)\\/([\\w\\.]+)/i)) {\n      return false;\n    }\n    var elem = createElement('input');\n    elem.type = 'file';\n    return !elem.disabled;\n  });\n\n\n  /**\n   * List of JavaScript DOM values used for tests including a NON-prefix\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._domPrefixesAll\n   * @optionName Modernizr._domPrefixesAll\n   * @optionProp domPrefixesAll\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixesAll is exactly the same as [_domPrefixes](#modernizr-_domPrefixes), but also\n   * adds an empty string in the array to test for a non-prefixed value\n   *\n   * ```js\n   * Modernizr._domPrefixesAll === [ \"\", \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n  var domPrefixesAll = [''].concat(domPrefixes);\n  ModernizrProto._domPrefixesAll = domPrefixesAll;\n  \n/*!\n{\n  \"name\": \"input[directory] Attribute\",\n  \"property\": \"directory\",\n  \"authors\": [\"silverwind\"],\n  \"tags\": [\"file\", \"input\", \"attribute\"]\n}\n!*/\n/* DOC\nWhen used on an `<input type=\"file\">`, the `directory` attribute instructs\nthe user agent to present a directory selection dialog instead of the usual\nfile selection dialog.\n*/\n\n  Modernizr.addTest('fileinputdirectory', function() {\n    var elem = createElement('input'), dir = 'directory';\n    elem.type = 'file';\n    for (var i = 0, len = domPrefixesAll.length; i < len; i++) {\n      if (domPrefixesAll[i] + dir in elem) {\n        return true;\n      }\n    }\n    return false;\n  });\n\n/*!\n{\n  \"name\": \"input[form] Attribute\",\n  \"property\": \"formattribute\",\n  \"tags\": [\"attribute\", \"forms\", \"input\"],\n  \"builderAliases\": [\"forms_formattribute\"]\n}\n!*/\n/* DOC\nDetects whether input form=\"form_id\" is available on the platform\nE.g. IE 10 (and below), don't support this\n*/\n\n\n  Modernizr.addTest('formattribute', function() {\n    var form = createElement('form');\n    var input = createElement('input');\n    var div = createElement('div');\n    var id = 'formtest' + (new Date()).getTime();\n    var attr;\n    var bool = false;\n\n    form.id = id;\n\n    //IE6/7 confuses the form idl attribute and the form content attribute, so we use document.createAttribute\n    try {\n      input.setAttribute('form', id);\n    }\n    catch (e) {\n      if (document.createAttribute) {\n        attr = document.createAttribute('form');\n        attr.nodeValue = id;\n        input.setAttributeNode(attr);\n      }\n    }\n\n    div.appendChild(form);\n    div.appendChild(input);\n\n    docElement.appendChild(div);\n\n    bool = form.elements && form.elements.length === 1 && input.form === form;\n\n    div.parentNode.removeChild(div);\n    return bool;\n  });\n\n/*!\n{\n  \"name\": \"placeholder attribute\",\n  \"property\": \"placeholder\",\n  \"tags\": [\"forms\", \"attribute\"],\n  \"builderAliases\": [\"forms_placeholder\"]\n}\n!*/\n/* DOC\nTests for placeholder attribute in inputs and textareas\n*/\n\n  Modernizr.addTest('placeholder', ('placeholder' in createElement('input') && 'placeholder' in createElement('textarea')));\n\n/*!\n{\n  \"name\": \"form#requestAutocomplete()\",\n  \"property\": \"requestautocomplete\",\n  \"tags\": [\"form\", \"forms\", \"requestAutocomplete\", \"payments\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://wiki.whatwg.org/wiki/RequestAutocomplete\"\n  }]\n}\n!*/\n/* DOC\nWhen used with input[autocomplete] to annotate a form, form.requestAutocomplete() shows a dialog in Chrome that speeds up\ncheckout flows (payments specific for now).\n*/\n\n  Modernizr.addTest('requestautocomplete', !!prefixed('requestAutocomplete', createElement('form')));\n\n/*!\n{\n  \"name\": \"Form Validation\",\n  \"property\": \"formvalidation\",\n  \"tags\": [\"forms\", \"validation\", \"attribute\"],\n  \"builderAliases\": [\"forms_validation\"]\n}\n!*/\n/* DOC\nThis implementation only tests support for interactive form validation.\nTo check validation for a specific type or a specific other constraint,\nthe test can be combined:\n\n- `Modernizr.inputtypes.number && Modernizr.formvalidation` (browser supports rangeOverflow, typeMismatch etc. for type=number)\n- `Modernizr.input.required && Modernizr.formvalidation` (browser supports valueMissing)\n*/\n\n  Modernizr.addTest('formvalidation', function() {\n    var form = createElement('form');\n    if (!('checkValidity' in form) || !('addEventListener' in form)) {\n      return false;\n    }\n    if ('reportValidity' in form) {\n      return true;\n    }\n    var invalidFired = false;\n    var input;\n\n    Modernizr.formvalidationapi = true;\n\n    // Prevent form from being submitted\n    form.addEventListener('submit', function(e) {\n      // Old Presto based Opera does not validate form, if submit is prevented\n      // although Opera Mini servers use newer Presto.\n      if (!window.opera || window.operamini) {\n        e.preventDefault();\n      }\n      e.stopPropagation();\n    }, false);\n\n    // Calling form.submit() doesn't trigger interactive validation,\n    // use a submit button instead\n    //older opera browsers need a name attribute\n    form.innerHTML = '<input name=\"modTest\" required=\"required\" /><button></button>';\n\n    testStyles('#modernizr form{position:absolute;top:-99999em}', function(node) {\n      node.appendChild(form);\n\n      input = form.getElementsByTagName('input')[0];\n\n      // Record whether \"invalid\" event is fired\n      input.addEventListener('invalid', function(e) {\n        invalidFired = true;\n        e.preventDefault();\n        e.stopPropagation();\n      }, false);\n\n      //Opera does not fully support the validationMessage property\n      Modernizr.formvalidationmessage = !!input.validationMessage;\n\n      // Submit form by clicking submit button\n      form.getElementsByTagName('button')[0].click();\n    });\n\n    return invalidFired;\n  });\n\n\n  /**\n   * since we have a fairly large number of input tests that don't mutate the input\n   * we create a single element that can be shared with all of those tests for a\n   * minor perf boost\n   *\n   * @access private\n   * @returns {HTMLInputElement}\n   */\n  var inputElem = createElement('input');\n  \n/*!\n{\n  \"name\": \"Form input types\",\n  \"property\": \"inputtypes\",\n  \"caniuse\": \"forms\",\n  \"tags\": [\"forms\"],\n  \"authors\": [\"Mike Taylor\"],\n  \"polyfills\": [\n    \"jquerytools\",\n    \"webshims\",\n    \"h5f\",\n    \"webforms2\",\n    \"nwxforms\",\n    \"fdslider\",\n    \"html5slider\",\n    \"galleryhtml5forms\",\n    \"jscolor\",\n    \"html5formshim\",\n    \"selectedoptionsjs\",\n    \"formvalidationjs\"\n  ]\n}\n!*/\n/* DOC\nDetects support for HTML5 form input types and exposes Boolean subproperties with the results:\n\n```javascript\nModernizr.inputtypes.color\nModernizr.inputtypes.date\nModernizr.inputtypes.datetime\nModernizr.inputtypes['datetime-local']\nModernizr.inputtypes.email\nModernizr.inputtypes.month\nModernizr.inputtypes.number\nModernizr.inputtypes.range\nModernizr.inputtypes.search\nModernizr.inputtypes.tel\nModernizr.inputtypes.time\nModernizr.inputtypes.url\nModernizr.inputtypes.week\n```\n*/\n\n  // Run through HTML5's new input types to see if the UA understands any.\n  //   This is put behind the tests runloop because it doesn't return a\n  //   true/false like all the other tests; instead, it returns an object\n  //   containing each input type with its corresponding true/false value\n\n  // Big thanks to @miketaylr for the html5 forms expertise. miketaylr.com/\n  (function() {\n    var props = ['search', 'tel', 'url', 'email', 'datetime', 'date', 'month', 'week','time', 'datetime-local', 'number', 'range', 'color'];\n    var smile = '1)';\n    var inputElemType;\n    var defaultView;\n    var bool;\n\n    for (var i = 0; i < props.length; i++) {\n      inputElem.setAttribute('type', inputElemType = props[i]);\n      bool = inputElem.type !== 'text' && 'style' in inputElem;\n\n      // We first check to see if the type we give it sticks..\n      // If the type does, we feed it a textual value, which shouldn't be valid.\n      // If the value doesn't stick, we know there's input sanitization which infers a custom UI\n      if (bool) {\n\n        inputElem.value = smile;\n        inputElem.style.cssText = 'position:absolute;visibility:hidden;';\n\n        if (/^range$/.test(inputElemType) && inputElem.style.WebkitAppearance !== undefined) {\n\n          docElement.appendChild(inputElem);\n          defaultView = document.defaultView;\n\n          // Safari 2-4 allows the smiley as a value, despite making a slider\n          bool = defaultView.getComputedStyle &&\n            defaultView.getComputedStyle(inputElem, null).WebkitAppearance !== 'textfield' &&\n            // Mobile android web browser has false positive, so must\n            // check the height to see if the widget is actually there.\n            (inputElem.offsetHeight !== 0);\n\n          docElement.removeChild(inputElem);\n\n        } else if (/^(search|tel)$/.test(inputElemType)) {\n          // Spec doesn't define any special parsing or detectable UI\n          //   behaviors so we pass these through as true\n\n          // Interestingly, opera fails the earlier test, so it doesn't\n          //  even make it here.\n\n        } else if (/^(url|email)$/.test(inputElemType)) {\n          // Real url and email support comes with prebaked validation.\n          bool = inputElem.checkValidity && inputElem.checkValidity() === false;\n\n        } else {\n          // If the upgraded input component rejects the :) text, we got a winner\n          bool = inputElem.value !== smile;\n        }\n      }\n\n      Modernizr.addTest('inputtypes.' + inputElemType, !!bool);\n    }\n  })();\n\n/*!\n{\n  \"name\": \"Fullscreen API\",\n  \"property\": \"fullscreen\",\n  \"caniuse\": \"fullscreen\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/API/Fullscreen\"\n  }],\n  \"polyfills\": [\"screenfulljs\"],\n  \"builderAliases\": [\"fullscreen_api\"]\n}\n!*/\n/* DOC\nDetects support for the ability to make the current website take over the user's entire screen\n*/\n\n  // github.com/Modernizr/Modernizr/issues/739\n  Modernizr.addTest('fullscreen', !!(prefixed('exitFullscreen', document, false) || prefixed('cancelFullScreen', document, false)));\n\n/*!\n{\n  \"name\": \"Hashchange event\",\n  \"property\": \"hashchange\",\n  \"caniuse\": \"hashchange\",\n  \"tags\": [\"history\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onhashchange\"\n  }],\n  \"polyfills\": [\n    \"jquery-hashchange\",\n    \"moo-historymanager\",\n    \"jquery-ajaxy\",\n    \"hasher\",\n    \"shistory\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the `hashchange` event, fired when the current location fragment changes.\n*/\n\n  Modernizr.addTest('hashchange', function() {\n    if (hasEvent('hashchange', window) === false) {\n      return false;\n    }\n\n    // documentMode logic from YUI to filter out IE8 Compat Mode\n    //   which false positives.\n    return (document.documentMode === undefined || document.documentMode > 7);\n  });\n\n/*!\n{\n  \"name\": \"Hidden Scrollbar\",\n  \"property\": \"hiddenscroll\",\n  \"authors\": [\"Oleg Korsunsky\"],\n  \"tags\": [\"overlay\"],\n  \"notes\": [{\n    \"name\": \"Overlay Scrollbar description\",\n    \"href\": \"https://developer.apple.com/library/mac/releasenotes/MacOSX/WhatsNewInOSX/Articles/MacOSX10_7.html#//apple_ref/doc/uid/TP40010355-SW39\"\n  }, {\n    \"name\": \"Video example of overlay scrollbars\",\n    \"href\": \"https://gfycat.com/FoolishMeaslyAtlanticsharpnosepuffer\"\n  }]\n}\n!*/\n/* DOC\nDetects overlay scrollbars (when scrollbars on overflowed blocks are visible). This is found most commonly on mobile and OS X.\n*/\n\n  Modernizr.addTest('hiddenscroll', function() {\n    return testStyles('#modernizr {width:100px;height:100px;overflow:scroll}', function(elem) {\n      return elem.offsetWidth === elem.clientWidth;\n    });\n  });\n\n/*!\n{\n  \"name\": \"History API\",\n  \"property\": \"history\",\n  \"caniuse\": \"history\",\n  \"tags\": [\"history\"],\n  \"authors\": [\"Hay Kranen\", \"Alexander Farkas\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/html51/browsers.html#the-history-interface\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/window.history\"\n  }],\n  \"polyfills\": [\"historyjs\", \"html5historyapi\"]\n}\n!*/\n/* DOC\nDetects support for the History API for manipulating the browser session history.\n*/\n\n  Modernizr.addTest('history', function() {\n    // Issue #733\n    // The stock browser on Android 2.2 & 2.3, and 4.0.x returns positive on history support\n    // Unfortunately support is really buggy and there is no clean way to detect\n    // these bugs, so we fall back to a user agent sniff :(\n    var ua = navigator.userAgent;\n    \n    // Some browsers allow to have empty userAgent.\n    // Therefore, we need to check ua before using \"indexOf\" on it.\n    if(!ua) {\n      return false;\n    }\n\n    // We only want Android 2 and 4.0, stock browser, and not Chrome which identifies\n    // itself as 'Mobile Safari' as well, nor Windows Phone (issue #1471).\n    if ((ua.indexOf('Android 2.') !== -1 ||\n        (ua.indexOf('Android 4.0') !== -1)) &&\n        ua.indexOf('Mobile Safari') !== -1 &&\n        ua.indexOf('Chrome') === -1 &&\n        ua.indexOf('Windows Phone') === -1 &&\n    // Since all documents on file:// share an origin, the History apis are\n    // blocked there as well\n        location.protocol !== 'file:'\n    ) {\n      return false;\n    }\n\n    // Return the regular check\n    return (window.history && 'pushState' in window.history);\n  });\n\n/*!\n{\n  \"name\": \"HTML Imports\",\n  \"property\": \"htmlimports\",\n  \"tags\": [\"html\", \"import\"],\n  \"polyfills\": [\"polymer-htmlimports\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://w3c.github.io/webcomponents/spec/imports/\"\n  }, {\n    \"name\": \"HTML Imports - #include for the web\",\n    \"href\": \"https://www.html5rocks.com/en/tutorials/webcomponents/imports/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for HTML import, a feature that is used for loading in Web Components.\n */\n\n  Modernizr.addTest('htmlimports', 'import' in createElement('link'));\n\n/*!\n{\n  \"name\": \"iframe[sandbox] Attribute\",\n  \"property\": \"sandbox\",\n  \"caniuse\": \"iframe-sandbox\",\n  \"tags\": [\"iframe\"],\n  \"builderAliases\": [\"iframe_sandbox\"],\n  \"notes\": [\n  {\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-sandbox\"\n  }],\n  \"knownBugs\": [\"False-positive on Firefox < 29\"]\n}\n!*/\n/* DOC\nTest for `sandbox` attribute in iframes.\n*/\n\n  Modernizr.addTest('sandbox', 'sandbox' in createElement('iframe'));\n\n/*!\n{\n  \"name\": \"iframe[seamless] Attribute\",\n  \"property\": \"seamless\",\n  \"tags\": [\"iframe\"],\n  \"builderAliases\": [\"iframe_seamless\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-seamless\"\n  }]\n}\n!*/\n/* DOC\nTest for `seamless` attribute in iframes.\n*/\n\n  Modernizr.addTest('seamless', 'seamless' in createElement('iframe'));\n\n/*!\n{\n  \"name\": \"iframe[srcdoc] Attribute\",\n  \"property\": \"srcdoc\",\n  \"caniuse\": \"iframe-srcdoc\",\n  \"tags\": [\"iframe\"],\n  \"builderAliases\": [\"iframe_srcdoc\"],\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-srcdoc\"\n  }]\n}\n!*/\n/* DOC\nTest for `srcdoc` attribute in iframes.\n*/\n\n  Modernizr.addTest('srcdoc', 'srcdoc' in createElement('iframe'));\n\n/*!\n{\n  \"name\": \"JSON\",\n  \"property\": \"json\",\n  \"caniuse\": \"json\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Glossary/JSON\"\n  }],\n  \"polyfills\": [\"json2\"]\n}\n!*/\n/* DOC\nDetects native support for JSON handling functions.\n*/\n\n  // this will also succeed if you've loaded the JSON2.js polyfill ahead of time\n  //   ... but that should be obvious. :)\n\n  Modernizr.addTest('json', 'JSON' in window && 'parse' in JSON && 'stringify' in JSON);\n\n/*!\n{\n  \"name\": \"Hover Media Query\",\n  \"property\": \"hovermq\"\n}\n!*/\n/* DOC\nDetect support for Hover based media queries\n*/\n\n  Modernizr.addTest('hovermq', mq('(hover)'));\n\n/*!\n{\n  \"name\": \"Pointer Media Query\",\n  \"property\": \"pointermq\"\n}\n!*/\n/* DOC\nDetect support for Pointer based media queries\n*/\n\n  Modernizr.addTest('pointermq', mq(('(pointer:coarse),(pointer:fine),(pointer:none)')));\n\n/*!\n{\n  \"name\": \"Notification\",\n  \"property\": \"notification\",\n  \"caniuse\": \"notifications\",\n  \"authors\": [\"Theodoor van Donge\", \"Hendrik Beskow\"],\n  \"notes\": [{\n    \"name\": \"HTML5 Rocks Tutorial\",\n    \"href\": \"https://www.html5rocks.com/en/tutorials/notifications/quick/\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/notifications/\"\n  }, {\n    \"name\": \"Changes in Chrome to Notifications API due to Service Worker Push Notifications\",\n    \"href\": \"https://developers.google.com/web/updates/2015/05/Notifying-you-of-notificiation-changes\"\n  }],\n  \"knownBugs\": [\"Possibility of false-positive on Chrome for Android if permissions we're granted for a website prior to Chrome 44.\"],\n  \"polyfills\": [\"desktop-notify\", \"html5-notifications\"]\n}\n!*/\n/* DOC\nDetects support for the Notifications API\n*/\n\n  Modernizr.addTest('notification', function() {\n    if (!window.Notification || !window.Notification.requestPermission) {\n      return false;\n    }\n    // if permission is already granted, assume support\n    if (window.Notification.permission === 'granted') {\n      return true;\n    }\n\n    try {\n      new window.Notification('');\n    } catch (e) {\n      if (e.name === 'TypeError') {\n        return false;\n      }\n    }\n\n    return true;\n  });\n\n/*!\n{\n  \"name\": \"Page Visibility API\",\n  \"property\": \"pagevisibility\",\n  \"caniuse\": \"pagevisibility\",\n  \"tags\": [\"performance\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/DOM/Using_the_Page_Visibility_API\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/2011/WD-page-visibility-20110602/\"\n  }, {\n    \"name\": \"HTML5 Rocks Tutorial\",\n    \"href\": \"https://www.html5rocks.com/en/tutorials/pagevisibility/intro/\"\n  }],\n  \"polyfills\": [\"visibilityjs\", \"visiblyjs\", \"jquery-visibility\"]\n}\n!*/\n/* DOC\nDetects support for the Page Visibility API, which can be used to disable unnecessary actions and otherwise improve user experience.\n*/\n\n  Modernizr.addTest('pagevisibility', !!prefixed('hidden', document, false));\n\n/*!\n{\n  \"name\": \"Navigation Timing API\",\n  \"property\": \"performance\",\n  \"caniuse\": \"nav-timing\",\n  \"tags\": [\"performance\"],\n  \"authors\": [\"Scott Murphy (@uxder)\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/navigation-timing/\"\n  }, {\n    \"name\": \"HTML5 Rocks Tutorial\",\n    \"href\": \"https://www.html5rocks.com/en/tutorials/webperformance/basics/\"\n  }],\n  \"polyfills\": [\"perfnow\"]\n}\n!*/\n/* DOC\nDetects support for the Navigation Timing API, for measuring browser and connection performance.\n*/\n\n  Modernizr.addTest('performance', !!prefixed('performance', window));\n\n/*!\n{\n  \"name\": \"postMessage\",\n  \"property\": \"postmessage\",\n  \"caniuse\": \"x-doc-messaging\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/webmessaging/#crossDocumentMessages\"\n  }],\n  \"polyfills\": [\"easyxdm\", \"postmessage-jquery\"],\n  \"knownBugs\": [\"structuredclones - Android 2&3 can not send a structured clone of dates, filelists or regexps\"],\n  \"warnings\": [\"Some old WebKit versions have bugs. Stick with object, array, number and pixeldata to be safe.\"]\n}\n!*/\n/* DOC\nDetects support for the `window.postMessage` protocol for cross-document messaging.\n`Modernizr.postmessage.structuredclones` reports if `postMessage` can send objects.\n*/\n\n  var bool = true;\n  try {\n    window.postMessage({ toString: function () { bool = false; } }, '*');\n  } catch (e) {}\n\n  Modernizr.addTest('postmessage', new Boolean('postMessage' in window));\n  Modernizr.addTest('postmessage.structuredclones', bool);\n\n/*!\n{\n  \"name\": \"Proximity API\",\n  \"property\": \"proximity\",\n  \"authors\": [\"Cătălin Mariș\"],\n  \"tags\": [\"events\", \"proximity\"],\n  \"caniuse\": \"proximity\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/Proximity_Events\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/proximity/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for an API that allows users to get proximity related information from the device's proximity sensor.\n*/\n\n\n  Modernizr.addAsyncTest(function() {\n\n    var timeout;\n    var timeoutTime = 300;\n\n    function advertiseSupport() {\n\n      // Clean up after ourselves\n      clearTimeout(timeout);\n      window.removeEventListener('deviceproximity', advertiseSupport);\n\n      // Advertise support as the browser supports\n      // the API and the device has a proximity sensor\n      addTest('proximity', true);\n\n    }\n\n    // Check if the browser has support for the API\n    if ('ondeviceproximity' in window && 'onuserproximity' in window) {\n\n      // Check if the device has a proximity sensor\n      // ( devices without such a sensor support the events but\n      //   will never fire them resulting in a false positive )\n      window.addEventListener('deviceproximity', advertiseSupport);\n\n      // If the event doesn't fire in a reasonable amount of time,\n      // it means that the device doesn't have a proximity sensor,\n      // thus, we can advertise the \"lack\" of support\n      timeout = setTimeout(function() {\n        window.removeEventListener('deviceproximity', advertiseSupport);\n        addTest('proximity', false);\n      }, timeoutTime);\n\n    } else {\n      addTest('proximity', false);\n    }\n\n  });\n\n\n/*!\n{\n  \"name\": \"QuerySelector\",\n  \"property\": \"queryselector\",\n  \"caniuse\": \"queryselector\",\n  \"tags\": [\"queryselector\"],\n  \"authors\": [\"Andrew Betts (@triblondon)\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/selectors-api/#queryselectorall\"\n  }],\n  \"polyfills\": [\"css-selector-engine\"]\n}\n!*/\n/* DOC\nDetects support for querySelector.\n*/\n\n  Modernizr.addTest('queryselector', 'querySelector' in document && 'querySelectorAll' in document);\n\n/*!\n{\n  \"name\": \"requestAnimationFrame\",\n  \"property\": \"requestanimationframe\",\n  \"aliases\": [\"raf\"],\n  \"caniuse\": \"requestanimationframe\",\n  \"tags\": [\"animation\"],\n  \"authors\": [\"Addy Osmani\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/animation-timing/\"\n  }],\n  \"polyfills\": [\"raf\"]\n}\n!*/\n/* DOC\nDetects support for the `window.requestAnimationFrame` API, for offloading animation repainting to the browser for optimized performance.\n*/\n\n  Modernizr.addTest('requestanimationframe', !!prefixed('requestAnimationFrame', window), {aliases: ['raf']});\n\n/*!\n{\n  \"name\": \"Local Storage\",\n  \"property\": \"localstorage\",\n  \"caniuse\": \"namevalue-storage\",\n  \"tags\": [\"storage\"],\n  \"polyfills\": [\n    \"joshuabell-polyfill\",\n    \"cupcake\",\n    \"storagepolyfill\",\n    \"amplifyjs\",\n    \"yui-cacheoffline\"\n  ]\n}\n!*/\n\n  // In FF4, if disabled, window.localStorage should === null.\n\n  // Normally, we could not test that directly and need to do a\n  //   `('localStorage' in window)` test first because otherwise Firefox will\n  //   throw bugzil.la/365772 if cookies are disabled\n\n  // Similarly, in Chrome with \"Block third-party cookies and site data\" enabled,\n  // attempting to access `window.sessionStorage` will throw an exception. crbug.com/357625\n\n  // Also in iOS5 Private Browsing mode, attempting to use localStorage.setItem\n  // will throw the exception:\n  //   QUOTA_EXCEEDED_ERROR DOM Exception 22.\n  // Peculiarly, getItem and removeItem calls do not throw.\n\n  // Because we are forced to try/catch this, we'll go aggressive.\n\n  // Just FWIW: IE8 Compat mode supports these features completely:\n  //   www.quirksmode.org/dom/html5.html\n  // But IE8 doesn't support either with local files\n\n  Modernizr.addTest('localstorage', function() {\n    var mod = 'modernizr';\n    try {\n      localStorage.setItem(mod, mod);\n      localStorage.removeItem(mod);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"name\": \"Session Storage\",\n  \"property\": \"sessionstorage\",\n  \"tags\": [\"storage\"],\n  \"polyfills\": [\"joshuabell-polyfill\", \"cupcake\", \"sessionstorage\"]\n}\n!*/\n\n  // Because we are forced to try/catch this, we'll go aggressive.\n\n  // Just FWIW: IE8 Compat mode supports these features completely:\n  //   www.quirksmode.org/dom/html5.html\n  // But IE8 doesn't support either with local files\n  Modernizr.addTest('sessionstorage', function() {\n    var mod = 'modernizr';\n    try {\n      sessionStorage.setItem(mod, mod);\n      sessionStorage.removeItem(mod);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"name\": \"Web SQL Database\",\n  \"property\": \"websqldatabase\",\n  \"caniuse\": \"sql-storage\",\n  \"tags\": [\"storage\"]\n}\n!*/\n\n  // Chrome incognito mode used to throw an exception when using openDatabase\n  // It doesn't anymore.\n  Modernizr.addTest('websqldatabase', 'openDatabase' in window);\n\n/*!\n{\n  \"name\": \"Touch Events\",\n  \"property\": \"touchevents\",\n  \"caniuse\": \"touch\",\n  \"tags\": [\"media\", \"attribute\"],\n  \"notes\": [{\n    \"name\": \"Touch Events spec\",\n    \"href\": \"https://www.w3.org/TR/2013/WD-touch-events-20130124/\"\n  }],\n  \"warnings\": [\n    \"** DEPRECATED see https://github.com/Modernizr/Modernizr/pull/2432 **\",\n    \"Indicates if the browser supports the Touch Events spec, and does not necessarily reflect a touchscreen device\"\n  ],\n  \"knownBugs\": [\n    \"False-positive on some configurations of Nokia N900\",\n    \"False-positive on some BlackBerry 6.0 builds – https://github.com/Modernizr/Modernizr/issues/372#issuecomment-3112695\"\n  ]\n}\n!*/\n/* DOC\nIndicates if the browser supports the W3C Touch Events API.\n\nThis *does not* necessarily reflect a touchscreen device:\n\n* Older touchscreen devices only emulate mouse events\n* Modern IE touch devices implement the Pointer Events API instead: use `Modernizr.pointerevents` to detect support for that\n* Some browsers & OS setups may enable touch APIs when no touchscreen is connected\n* Future browsers may implement other event models for touch interactions\n\nSee this article: [You Can't Detect A Touchscreen](http://www.stucox.com/blog/you-cant-detect-a-touchscreen/).\n\nIt's recommended to bind both mouse and touch/pointer events simultaneously – see [this HTML5 Rocks tutorial](https://www.html5rocks.com/en/mobile/touchandmouse/).\n\nThis test will also return `true` for Firefox 4 Multitouch support.\n*/\n\n  // Chrome (desktop) used to lie about its support on this, but that has since been rectified: https://bugs.chromium.org/p/chromium/issues/detail?id=36415\n  // Chrome also changed its behaviour since v70 and recommends the TouchEvent object for detection: https://www.chromestatus.com/feature/4764225348042752\n  Modernizr.addTest('touchevents', function() {\n    if (('ontouchstart' in window) || window.TouchEvent || window.DocumentTouch && document instanceof DocumentTouch) {\n      return true;\n    }\n\n    // include the 'heartz' as a way to have a non matching MQ to help terminate the join\n    // https://github.com/Modernizr/Modernizr/issues/1814\n    var query = ['(', prefixes.join('touch-enabled),('), 'heartz', ')'].join('');\n    return mq(query);\n  });\n\n/*!\n{\n  \"name\": \"Unicode characters\",\n  \"property\": \"unicode\",\n  \"tags\": [\"encoding\"],\n  \"warnings\": [\n    \"** DEPRECATED see https://github.com/Modernizr/Modernizr/issues/2468 **\",\n    \"positive Unicode support doesn't mean you can use it inside <title>, this seems more related to OS & Language packs\"\n  ]\n}\n!*/\n/* DOC\nDetects if unicode characters are supported in the current document.\n*/\n\n  /**\n   * Unicode special character support\n   *\n   * Detection is made by testing missing glyph box rendering against star character\n   * If widths are the same, this \"probably\" means the browser didn't support the star character and rendered a glyph box instead\n   * Just need to ensure the font characters have different widths\n   */\n  Modernizr.addTest('unicode', function() {\n    var bool;\n    var missingGlyph = createElement('span');\n    var star = createElement('span');\n\n    testStyles('#modernizr{font-family:Arial,sans;font-size:300em;}', function(node) {\n\n      missingGlyph.innerHTML = isSVG ? '\\u5987' : '&#5987;';\n      star.innerHTML = isSVG ? '\\u2606' : '&#9734;';\n\n      node.appendChild(missingGlyph);\n      node.appendChild(star);\n\n      bool = 'offsetWidth' in missingGlyph && missingGlyph.offsetWidth !== star.offsetWidth;\n    });\n\n    return bool;\n  });\n\n/*!\n{\n  \"name\": \"Unicode Range\",\n  \"property\": \"unicoderange\",\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/2013/CR-css-fonts-3-20131003/#descdef-unicode-range\"\n  }, {\n    \"name\": \"24 Way article\",\n    \"href\": \"https://24ways.org/2011/creating-custom-font-stacks-with-unicode-range\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('unicoderange', function() {\n\n    return testStyles('@font-face{font-family:\"unicodeRange\";src:local(\"Arial\");unicode-range:U+0020,U+002E}#modernizr span{font-size:20px;display:inline-block;font-family:\"unicodeRange\",monospace}#modernizr .mono{font-family:monospace}', function(elem) {\n\n      // we use specify a unicode-range of 002E (the `.` glyph,\n      // and a monospace font as the fallback. If the first of\n      // these test glyphs is a different width than the other\n      // the other three (which are all monospace), then we\n      // have a winner.\n      var testGlyphs = ['.', '.', 'm', 'm'];\n\n      for (var i = 0; i < testGlyphs.length; i++) {\n        var elm = createElement('span');\n        elm.innerHTML = testGlyphs[i];\n        elm.className = i % 2 ? 'mono' : '';\n        elem.appendChild(elm);\n        testGlyphs[i] = elm.clientWidth;\n      }\n\n      return (testGlyphs[0] !== testGlyphs[1] && testGlyphs[2] === testGlyphs[3]);\n    });\n  });\n\n/*!\n{\n  \"name\": \"Blob URLs\",\n  \"property\": \"bloburls\",\n  \"caniuse\": \"bloburls\",\n  \"notes\": [{\n    \"name\": \"W3C Working Draft Spec\",\n    \"href\": \"https://www.w3.org/TR/FileAPI/#creating-revoking\"\n  }],\n  \"tags\": [\"file\", \"url\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"]\n}\n!*/\n/* DOC\nDetects support for creating Blob URLs\n*/\n\n  var url = prefixed('URL', window, false);\n  url = url && window[url];\n  Modernizr.addTest('bloburls', url && 'revokeObjectURL' in url && 'createObjectURL' in url);\n\n/*!\n{\n  \"name\": \"Data URI\",\n  \"property\": \"datauri\",\n  \"caniuse\": \"datauri\",\n  \"tags\": [\"url\"],\n  \"builderAliases\": [\"url_data_uri\"],\n  \"async\": true,\n  \"notes\": [{\n    \"name\": \"Wikipedia article\",\n    \"href\": \"https://en.wikipedia.org/wiki/Data_URI_scheme\"\n  }],\n  \"warnings\": [\"Support in Internet Explorer 8 is limited to images and linked resources like CSS files, not HTML files\"]\n}\n!*/\n/* DOC\nDetects support for data URIs. Provides a subproperty to report support for data URIs over 32kb in size:\n\n```javascript\nModernizr.datauri           // true\nModernizr.datauri.over32kb  // false in IE8\n```\n*/\n\n  // https://github.com/Modernizr/Modernizr/issues/14\n  Modernizr.addAsyncTest(function() {\n\n    // IE7 throw a mixed content warning on HTTPS for this test, so we'll\n    // just reject it (we know it doesn't support data URIs anyway)\n    // https://github.com/Modernizr/Modernizr/issues/362\n    if (navigator.userAgent.indexOf('MSIE 7.') !== -1) {\n      // Keep the test async\n      setTimeout(function() {\n        Modernizr.addTest('datauri', new Boolean(false));\n      }, 10);\n    }\n\n    var datauri = new Image();\n\n    datauri.onerror = function() {\n      Modernizr.addTest('datauri', new Boolean(false));\n    };\n    datauri.onload = function() {\n      if (datauri.width === 1 && datauri.height === 1) {\n        testOver32kb();\n      }\n      else {\n        Modernizr.addTest('datauri', new Boolean(false));\n      }\n    };\n\n    datauri.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==';\n\n    // Once we have datauri, let's check to see if we can use data URIs over\n    // 32kb (IE8 can't). https://github.com/Modernizr/Modernizr/issues/321\n    function testOver32kb() {\n\n      var datauriBig = new Image();\n\n      datauriBig.onerror = function() {\n        Modernizr.addTest('datauri', new Boolean(true));\n        Modernizr.addTest('datauri.over32kb', false);\n      };\n      datauriBig.onload = function() {\n        Modernizr.addTest('datauri', new Boolean(true));\n        Modernizr.addTest('datauri.over32kb', datauriBig.width === 1 && datauriBig.height === 1);\n      };\n\n      var base64str = 'R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==';\n      while (base64str.length < 33000) {\n        base64str = '\\r\\n' + base64str;\n      }\n      datauriBig.src = 'data:image/gif;base64,' + base64str;\n    }\n  });\n\n/*!\n{\n  \"name\": \"URL parser\",\n  \"property\": \"urlparser\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://url.spec.whatwg.org/\"\n  }],\n  \"polyfills\": [\"urlparser\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"url\"]\n}\n!*/\n/* DOC\nCheck if browser implements the URL constructor for parsing URLs.\n*/\n\n  Modernizr.addTest('urlparser', function() {\n    var url;\n    try {\n      // have to actually try use it, because Safari defines a dud constructor\n      url = new URL('http://modernizr.com/');\n      return url.href === 'http://modernizr.com/';\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"property\": \"urlsearchparams\",\n  \"caniuse\": \"urlsearchparams\",\n  \"tags\": [\"querystring\", \"url\"],\n  \"authors\": [\"Cătălin Mariș\"],\n  \"name\": \"URLSearchParams API\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://url.spec.whatwg.org/#interface-urlsearchparams\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams\"\n  }]\n}\n!*/\n/* DOC\nDetects support for an API that provides utility methods for working with the query string of a URL.\n*/\n\n  Modernizr.addTest('urlsearchparams', 'URLSearchParams' in window);\n\n/*!\n{\n  \"name\": \"IE User Data API\",\n  \"property\": \"userdata\",\n  \"tags\": [\"storage\"],\n  \"authors\": [\"@stereobooster\"],\n  \"notes\": [{\n    \"name\": \"MSDN Documentation\",\n    \"href\": \"https://msdn.microsoft.com/en-us/library/ms531424.aspx\"\n  }]\n}\n!*/\n/* DOC\nDetects support for IE userData for persisting data, an API similar to localStorage but supported since IE5.\n*/\n\n  Modernizr.addTest('userdata', !!createElement('div').addBehavior);\n\n/*!\n{\n  \"name\": \"Vibration API\",\n  \"property\": \"vibrate\",\n  \"caniuse\": \"vibration\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en/DOM/window.navigator.mozVibrate\"\n  }, {\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/vibration/\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the API that provides access to the vibration mechanism of the hosting device, to provide tactile feedback.\n*/\n\n  Modernizr.addTest('vibrate', !!prefixed('vibrate', navigator));\n\n/*!\n{\n  \"name\": \"HTML5 Video\",\n  \"property\": \"video\",\n  \"caniuse\": \"video\",\n  \"tags\": [\"html5\", \"video\", \"media\"],\n  \"knownBugs\": [\"Without QuickTime, `Modernizr.video.h264` will be `undefined`; https://github.com/Modernizr/Modernizr/issues/546\"],\n  \"polyfills\": [\n    \"html5media\",\n    \"mediaelementjs\",\n    \"sublimevideo\",\n    \"videojs\",\n    \"leanbackplayer\",\n    \"videoforeverybody\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the video element, as well as testing what types of content it supports.\n\nSubproperties are provided to describe support for `ogg`, `h264`, `h265`, `webm`, `vp9`, `hls` and `av1` formats, e.g.:\n\n```javascript\nModernizr.video         // true\nModernizr.video.ogg     // 'probably'\n```\n*/\n\n  // Codec values from : github.com/NielsLeenheer/html5test/blob/9106a8/index.html#L845\n  //                     thx to NielsLeenheer and zcorpan\n\n  // Note: in some older browsers, \"no\" was a return value instead of empty string.\n  //   It was live in FF3.5.0 and 3.5.1, but fixed in 3.5.2\n  //   It was also live in Safari 4.0.0 - 4.0.4, but fixed in 4.0.5\n  (function() {\n    var elem = createElement('video');\n\n    Modernizr.addTest('video', function() {\n      var bool = false;\n      try {\n        bool = !!elem.canPlayType;\n        if (bool) {\n          bool = new Boolean(bool);\n        }\n      } catch (e) {}\n\n      return bool;\n    });\n\n    // IE9 Running on Windows Server SKU can cause an exception to be thrown, bug #224\n    try {\n      if (!!elem.canPlayType) {\n        Modernizr.addTest('video.ogg', elem.canPlayType('video/ogg; codecs=\"theora\"').replace(/^no$/, ''));\n\n        // Without QuickTime, this value will be `undefined`. github.com/Modernizr/Modernizr/issues/546\n        Modernizr.addTest('video.h264', elem.canPlayType('video/mp4; codecs=\"avc1.42E01E\"').replace(/^no$/, ''));\n        Modernizr.addTest('video.h265', elem.canPlayType('video/mp4; codecs=\"hev1\"').replace(/^no$/, ''));\n        Modernizr.addTest('video.webm', elem.canPlayType('video/webm; codecs=\"vp8, vorbis\"').replace(/^no$/, ''));\n        Modernizr.addTest('video.vp9', elem.canPlayType('video/webm; codecs=\"vp9\"').replace(/^no$/, ''));\n        Modernizr.addTest('video.hls', elem.canPlayType('application/x-mpegURL; codecs=\"avc1.42E01E\"').replace(/^no$/, ''));\n        Modernizr.addTest('video.av1', elem.canPlayType('video/mp4; codecs=\"av01\"').replace(/^no$/, ''));\n      }\n    } catch (e) {}\n  })();\n\n/*!\n{\n  \"name\": \"Video Autoplay\",\n  \"property\": \"videoautoplay\",\n  \"tags\": [\"video\"],\n  \"async\": true,\n  \"warnings\": [\"This test is very large – only include it if you absolutely need it\"],\n  \"knownBugs\": [\"crashes with an alert on iOS7 when added to homescreen\"]\n}\n!*/\n/* DOC\nChecks for support of the autoplay attribute of the video element.\n*/\n\n\n  Modernizr.addAsyncTest(function() {\n    var timeout;\n    var waitTime = 200;\n    var retries = 5;\n    var currentTry = 0;\n    var elem = createElement('video');\n    var elemStyle = elem.style;\n\n    function testAutoplay(arg) {\n      currentTry++;\n      clearTimeout(timeout);\n\n      var result = arg && arg.type === 'playing' || elem.currentTime !== 0;\n\n      if (!result && currentTry < retries) {\n        //Detection can be flaky if the browser is slow, so lets retry in a little bit\n        timeout = setTimeout(testAutoplay, waitTime);\n        return;\n      }\n\n      elem.removeEventListener('playing', testAutoplay, false);\n      addTest('videoautoplay', result);\n\n      // Cleanup, but don't assume elem is still in the page -\n      // an extension (eg Flashblock) may already have removed it.\n      if (elem.parentNode) {\n        elem.parentNode.removeChild(elem);\n      }\n    }\n\n    //skip the test if video itself, or the autoplay\n    //element on it isn't supported\n    if (!Modernizr.video || !('autoplay' in elem)) {\n      addTest('videoautoplay', false);\n      return;\n    }\n\n    elemStyle.position = 'absolute';\n    elemStyle.height = 0;\n    elemStyle.width = 0;\n\n    try {\n      if (Modernizr.video.ogg) {\n        elem.src = 'data:video/ogg;base64,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';\n      }\n      else if (Modernizr.video.h264) {\n        elem.src = 'data:video/mp4;base64,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';\n      }\n      else {\n        addTest('videoautoplay', false);\n        return;\n      }\n    }\n\n    catch (e) {\n      addTest('videoautoplay', false);\n      return;\n    }\n\n    elem.setAttribute('autoplay', '');\n    elemStyle.cssText = 'display:none';\n    docElement.appendChild(elem);\n    // wait for the next tick to add the listener, otherwise the element may\n    // not have time to play in high load situations (e.g. the test suite)\n    setTimeout(function() {\n      elem.addEventListener('playing', testAutoplay, false);\n      timeout = setTimeout(testAutoplay, waitTime);\n    }, 0);\n  });\n\n/*!\n{\n  \"name\": \"Video crossOrigin\",\n  \"property\": \"videocrossorigin\",\n  \"caniuse\": \"cors\",\n  \"authors\": [\"Florian Mailliet\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes\"\n  }]\n}\n!*/\n/* DOC\nDetects support for the crossOrigin attribute on video tag\n*/\n\n  Modernizr.addTest('videocrossorigin', 'crossOrigin' in createElement('video'));\n\n/*!\n{\n  \"name\": \"Video Loop Attribute\",\n  \"property\": \"videoloop\",\n  \"tags\": [\"video\", \"media\"]\n}\n!*/\n\n  Modernizr.addTest('videoloop', 'loop' in createElement('video'));\n\n/*!\n{\n  \"name\": \"Video Preload Attribute\",\n  \"property\": \"videopreload\",\n  \"tags\": [\"video\", \"media\"]\n}\n!*/\n\n  Modernizr.addTest('videopreload', 'preload' in createElement('video'));\n\n/*!\n{\n  \"name\": \"XDomainRequest\",\n  \"property\": \"xdomainrequest\",\n  \"tags\": [\"cors\", \"xdomainrequest\", \"ie9\", \"ie8\"],\n  \"authors\": [\"Ivan Pan (@hypotenuse)\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/XDomainRequest\"\n  }]\n}\n!*/\n/* DOC\nDetects support for XDomainRequest in IE9 & IE8\n*/\n\n  Modernizr.addTest('xdomainrequest', 'XDomainRequest' in window);\n\n\n  // Run each test\n  testRunner();\n\n  // Remove the \"no-js\" class if it exists\n  setClasses(classes);\n\n  delete ModernizrProto.addTest;\n  delete ModernizrProto.addAsyncTest;\n\n  // Run the things that are supposed to run after the tests\n  for (var i = 0; i < Modernizr._q.length; i++) {\n    Modernizr._q[i]();\n  }\n\n  // Leak Modernizr namespace\n  scriptGlobalObject.Modernizr = Modernizr;\n\n\n;\n\n})(window, window, document);\nmodule.exports=window.Modernizr;if(hadGlobal){window.Modernizr=oldGlobal;}else{delete window.Modernizr;}})(window);","import $ from \"jquery\";\n\nvar parser = {\n    getOptions($el, patternName, options) {\n        /* This is the Mockup parser. An alternative parser for Patternslib\n         * patterns.\n         *\n         * NOTE: Use of the Mockup parser is discouraged and is added here for\n         * legacy support for the Plone Mockup project.\n         *\n         * It parses a DOM element for pattern configuration options.\n         */\n        options = options || {};\n        // get options from parent element first, stop if element tag name is 'body'\n        if ($el.length !== 0 && !$.nodeName($el[0], \"body\")) {\n            options = this.getOptions($el.parent(), patternName, options);\n        }\n        // collect all options from element\n        let elOptions = {};\n        if ($el.length !== 0) {\n            elOptions = $el.data(\"pat-\" + patternName);\n            if (elOptions) {\n                // parse options if string\n                if (typeof elOptions === \"string\") {\n                    const tmpOptions = {};\n                    $.each(elOptions.split(\";\"), function (i, item) {\n                        item = item.split(\":\");\n                        item.reverse();\n                        let key = item.pop();\n                        key = key.replace(/^\\s+|\\s+$/g, \"\"); // trim\n                        item.reverse();\n                        let value = item.join(\":\");\n                        value = value.replace(/^\\s+|\\s+$/g, \"\"); // trim\n                        tmpOptions[key] = value;\n                    });\n                    elOptions = tmpOptions;\n                }\n            }\n        }\n        return $.extend(true, {}, options, elOptions);\n    },\n};\n\nexport default parser;\n","/**\n * A Base pattern for creating scoped patterns. It's similar to Backbone's\n * Model class. The advantage of this approach is that each instance of a\n * pattern has its own local scope (closure).\n *\n * A new instance is created for each DOM element on which a pattern applies.\n *\n * You can assign values, such as $el, to `this` for an instance and they\n * will remain unique to that instance.\n *\n * Older Patternslib patterns on the other hand have a single global scope for\n * all DOM elements.\n */\nimport $ from \"jquery\";\nimport Registry from \"./registry\";\nimport logging from \"./logging\";\nimport mockupParser from \"./mockup-parser\";\n\nconst log = logging.getLogger(\"Patternslib Base\");\n\nconst initBasePattern = function ($el, options, trigger) {\n    if (!$el.jquery) {\n        $el = $($el);\n    }\n    const name = this.prototype.name;\n    const plog = logging.getLogger(`pat.${name}`);\n    let pattern = $el.data(`pattern-${name}`);\n    if (pattern === undefined && Registry.patterns[name]) {\n        try {\n            // Immediately set the pattern instance to the temporary value\n            // ``initializing`` before the async Base constructor is setting\n            // the value later.\n            // This prevents re-init the pattern on this element on multiple\n            // initialization calls..\n            $el.data(`pattern-${name}`, \"initializing\");\n            options =\n                this.prototype.parser === \"mockup\"\n                    ? mockupParser.getOptions($el, name, options)\n                    : options;\n            pattern = new Registry.patterns[name]($el, options, trigger);\n        } catch (e) {\n            plog.error(`Failed while initializing ${name} pattern.`, e);\n        }\n    }\n    return pattern;\n};\n\nconst Base = async function ($el, options, trigger) {\n    if (!$el) {\n        log.warn(\"No element given to pattern.\");\n        return;\n    }\n    if (!$el.jquery) {\n        $el = $($el);\n    }\n    this.$el = $el;\n    this.el = $el[0];\n    this.options = $.extend(true, {}, this.defaults || {}, options || {});\n    await this.init($el, options, trigger);\n\n    // Store pattern instance on element\n    this.$el.data(`pattern-${this.name}`, this);\n    this.el[`pattern-${this.name}`] = this;\n\n    this.emit(\"init\");\n};\n\nBase.prototype = {\n    constructor: Base,\n    on(eventName, eventCallback) {\n        this.$el.on(`${eventName}.${this.name}.patterns`, eventCallback);\n    },\n    one(eventName, eventCallback) {\n        this.$el.one(`${eventName}.${this.name}.patterns`, eventCallback);\n    },\n    emit(eventName, args) {\n        // args should be a list\n        if (args === undefined) {\n            args = [];\n        }\n        this.$el.trigger(`${eventName}.${this.name}.patterns`, args);\n    },\n};\n\nBase.extend = function (patternProps) {\n    /* Helper function to correctly set up the prototype chain for new patterns.\n     */\n    const parent = this;\n    let child;\n\n    // Check that the required configuration properties are given.\n    if (!patternProps) {\n        throw new Error(\n            \"Pattern configuration properties required when calling Base.extend\"\n        );\n    }\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent's constructor.\n    if (Object.hasOwnProperty.call(patternProps, \"constructor\")) {\n        child = patternProps.constructor;\n    } else {\n        child = function () {\n            parent.apply(this, arguments);\n        };\n    }\n\n    // Allow patterns to be extended indefinitely\n    child.extend = Base.extend;\n\n    // Static properties required by the Patternslib registry\n    child.init = initBasePattern;\n    child.jquery_plugin = true;\n    child.trigger = patternProps.trigger;\n    child.parser = patternProps?.parser || null;\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function.\n    var Surrogate = function () {\n        this.constructor = child;\n    };\n    Surrogate.prototype = parent.prototype;\n    child.prototype = new Surrogate();\n\n    // Add pattern's configuration properties (instance properties) to the subclass,\n    $.extend(true, child.prototype, patternProps);\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    // Register the pattern in the Patternslib registry.\n    if (!patternProps.name) {\n        log.warn(\"This pattern without a name attribute will not be registered!\");\n    } else if (!patternProps.trigger) {\n        log.warn(\n            `The pattern ${patternProps.name} does not have a trigger attribute, it will not be registered.`\n        );\n    } else if (patternProps.autoregister !== false) {\n        Registry.register(child, patternProps.name);\n    }\n    return child;\n};\n\nexport default Base;\n","/* Utilities for DOM traversal or navigation */\nimport events from \"./events\";\n\nconst DATA_PREFIX = \"__patternslib__data_prefix__\";\nconst DATA_STYLE_DISPLAY = \"__patternslib__style__display\";\n\n/**\n * Return an array of DOM nodes.\n *\n * @param {Node|NodeList|jQuery} nodes - The DOM node to start the search from.\n *\n * @returns {Array} - An array of DOM nodes.\n */\nconst toNodeArray = (nodes) => {\n    if (nodes.jquery || nodes instanceof NodeList) {\n        // jQuery or document.querySelectorAll\n        nodes = [...nodes];\n    } else if (nodes instanceof Array === false) {\n        nodes = [nodes];\n    }\n    return nodes;\n};\n\n/**\n * Like querySelectorAll but including the element where it starts from.\n * Returns an Array, not a NodeList\n *\n * @param {Node} el - The DOM node to start the search from.\n *\n * @returns {Array} - The DOM nodes found.\n */\nconst querySelectorAllAndMe = (el, selector) => {\n    if (!el) {\n        return [];\n    }\n\n    const all = [...el.querySelectorAll(selector)];\n    if (el.matches(selector)) {\n        all.unshift(el); // start element should be first.\n    }\n    return all;\n};\n\n/**\n * Wrap a element with a wrapper element.\n *\n * @param {Node} el - The DOM node to wrap.\n */\nconst wrap = (el, wrapper) => {\n    // See: https://stackoverflow.com/a/13169465/1337474\n    el.parentNode.insertBefore(wrapper, el);\n    wrapper.appendChild(el);\n};\n\n/**\n * Hides the element with ``display: none`` and stores the current display value.\n *\n * @param {Node} el - The DOM node to hide.\n */\nconst hide = (el) => {\n    if (el.style.display === \"none\") {\n        // Nothing to do.\n        return;\n    }\n    if (el.style.display) {\n        el[DATA_STYLE_DISPLAY] = el.style.display;\n    }\n    el.style.display = \"none\";\n};\n\n/**\n * Shows element by removing ``display: none`` and restoring the display value\n * to whatever it was before.\n *\n * @param {Node} el - The DOM node to show.\n */\nconst show = (el) => {\n    const val = el[DATA_STYLE_DISPLAY] || null;\n    el.style.display = val;\n    delete el[DATA_STYLE_DISPLAY];\n};\n\n/**\n * Return all direct parents of ``el`` matching ``selector``.\n * This matches against all parents but not the element itself.\n * The order of elements is from the search starting point up to higher\n * DOM levels.\n *\n * @param {Node} el - The DOM node to start the search from.\n * @param {String} selector - CSS selector to match against.\n * @returns {Array} - List of matching DOM nodes.\n */\nconst find_parents = (el, selector) => {\n    const ret = [];\n    let parent = el;\n    while (parent) {\n        parent = parent.parentNode?.closest?.(selector);\n        if (parent) ret.push(parent);\n    }\n    return ret;\n};\n\n/**\n * Find an element in the whole DOM tree if the selector is an ID selector,\n * otherwise use the given element as the starting point.\n *\n * @param {Node} el - The DOM node to start the search from.\n * @param {String} selector - The CSS selector to search for.\n *\n * @returns {NodeList} - The DOM nodes found.\n *\n */\nconst find_scoped = (el, selector) => {\n    // If the selector starts with an object id do a global search,\n    // otherwise do a local search.\n    return (selector.indexOf(\"#\") === 0 ? document : el).querySelectorAll(selector);\n};\n\n/**\n * Return all HTMLElement parents of el, starting from the direct parent of el.\n * The document itself is excluded because it's not a real DOM node.\n *\n * @param {Node} el - The DOM node to start the search from.\n *\n * @returns {Array} - The DOM nodes found.\n */\nconst get_parents = (el) => {\n    // Return all HTMLElement parents of el, starting from the direct parent of el.\n    const parents = [];\n    let parent = el?.parentNode;\n    while (parent) {\n        parents.push(parent);\n        parent = parent?.parentNode;\n        parent = parent instanceof HTMLElement ? parent : null;\n    }\n    return parents;\n};\n\n/**\n * Return the value of the first attribute found in the list of parents.\n *\n * @param {DOM element} el - The DOM element to start the acquisition search for the given attribute.\n * @param {string} attribute - Name of the attribute to search for.\n * @param {Boolean} include_empty - Also return empty values.\n * @param {Boolean} include_all - Return a list of attribute values found in all parents.\n *\n * @returns {*} - Returns the value of the searched attribute or a list of all attributes.\n */\nconst acquire_attribute = (\n    el,\n    attribute,\n    include_empty = false,\n    include_all = false\n) => {\n    let _el = el;\n    const ret = []; // array for ``include_all`` mode.\n    while (_el) {\n        const val = _el.getAttribute(attribute);\n        if (val || (include_empty && val === \"\")) {\n            if (!include_all) {\n                return val;\n            }\n            ret.push(val);\n        }\n        _el = _el.parentElement;\n    }\n    if (include_all) {\n        return ret;\n    }\n};\n\nconst is_visible = (el) => {\n    // Check, if element is visible in DOM.\n    // https://stackoverflow.com/a/19808107/1337474\n    return el.offsetWidth > 0 && el.offsetHeight > 0;\n};\n\n/**\n * Return a DocumentFragment from a given string.\n *\n * @param {String} string - The HTML structure as a string.\n *\n * @returns {DocumentFragment} - The DOM nodes as a DocumentFragment.\n */\nconst create_from_string = (string) => {\n    // See: https://davidwalsh.name/convert-html-stings-dom-nodes\n    return document.createRange().createContextualFragment(string.trim());\n};\n\n/**\n * Return a CSS property value for a given DOM node.\n * For length-values, relative values are converted to pixels.\n * Optionally parse as pixels, if applicable.\n *\n * Note: The element must be attached to the body to make CSS caluclations work.\n *\n * @param {Node} el - DOM node.\n * @param {String} property - CSS property to query on DOM node.\n * @param {Boolean} [as_pixels=false] - Convert value to pixels, if applicable.\n * @param {Boolean} [as_float=false] - Convert value to float, if applicable.\n *\n * @returns {(String|Number)} - The CSS value to return.\n */\nfunction get_css_value(el, property, as_pixels = false, as_float = false) {\n    let value = window.getComputedStyle(el).getPropertyValue(property);\n    if (as_pixels || as_float) {\n        value = parseFloat(value) || 0.0;\n    }\n    if (as_pixels && !as_float) {\n        value = parseInt(Math.round(value), 10);\n    }\n    return value;\n}\n\n/**\n * Find a scrollable element up in the DOM tree.\n *\n * Note: Setting the ``overflow`` shorthand property also sets the individual overflow-y and overflow-y properties.\n *\n * @param {Node} el - The DOM element to start the search on.\n * @param {String} [direction=] - Not given: Search for any scrollable element up in the DOM tree.\n *                                ``x``: Search for a horizontally scrollable element.\n *                                ``y``: Search for a vertically scrollable element.\n * @param {(DOM Node|null)} [fallback=document.body] - Fallback, if no scroll container can be found.\n *                                                     The default is to use document.body.\n *\n * @returns {Node} - Return the first scrollable element.\n *                   If no other element could be found, document.body would be returned.\n */\nconst find_scroll_container = (el, direction, fallback = document.body) => {\n    while (el && el !== document.body) {\n        if (!direction || direction === \"y\") {\n            let overflow_y = get_css_value(el, \"overflow-y\");\n            if ([\"auto\", \"scroll\"].includes(overflow_y)) {\n                return el;\n            }\n        }\n        if (!direction || direction === \"x\") {\n            let overflow_x = get_css_value(el, \"overflow-x\");\n            if ([\"auto\", \"scroll\"].includes(overflow_x)) {\n                return el;\n            }\n        }\n        el = el.parentElement;\n    }\n    return fallback;\n};\n\n/**\n * Get data stored directly on the node instance.\n * We are using a prefix to make sure the data doesn't collide with other attributes.\n *\n * @param el {Node} - The DOM node from which we want to retrieve the data.\n * @param name {String} - The name of the variable. Note - this is stored on\n *                        the DOM node prefixed with the DATA_PREFIX.\n * @param default_value {Any} - Optional default value.\n * @returns {Any} - The value which is stored on the DOM node.\n */\nconst get_data = (el, name, default_value) => {\n    return el[`${DATA_PREFIX}${name}`] || default_value;\n};\n\n/**\n * Set and store data directly on the node instance.\n * We are using a prefix to make sure the data doesn't collide with other attributes.\n *\n * @param el {Node} - The DOM node which we want to store the data on.\n * @param name {String} - The name of the variable. Note - this is stored on\n *                        the DOM node prefixed with the DATA_PREFIX.\n * @param value {Any} - The value we want to store on the DOM node.\n */\nconst set_data = (el, name, value) => {\n    el[`${DATA_PREFIX}${name}`] = value;\n};\n\n/**\n * Simple template engine, based on JS template literal\n *\n * Please note: You cannot pass a template literal as template_string.\n * JavaScript itself would try to expand it and would fail.\n *\n * See: https://stackoverflow.com/a/37217166/1337474\n *\n * @param {String} template_string - The template string as a JavaScript template literal.\n *                                   For each variable in the template you have to use ``this``.\n *                                   E.g. if you pass ``{message: \"ok\"}`` as template_variables, you can use it like so:\n *                                   `<h1>${this.message}</h1>`\n * @param {Object} template_variables - Object literal with all the variables which should be used in the template.\n *\n * @returns {String} - Returns the a string as template expanded with the template_variables.\n */\nconst template = (template_string, template_variables = {}) => {\n    return new Function(\"return `\" + template_string + \"`;\").call(template_variables);\n};\n\nconst dom = {\n    toNodeArray: toNodeArray,\n    querySelectorAllAndMe: querySelectorAllAndMe,\n    wrap: wrap,\n    hide: hide,\n    show: show,\n    find_parents: find_parents,\n    find_scoped: find_scoped,\n    get_parents: get_parents,\n    acquire_attribute: acquire_attribute,\n    is_visible: is_visible,\n    create_from_string: create_from_string,\n    get_css_value: get_css_value,\n    find_scroll_container: find_scroll_container,\n    get_data: get_data,\n    set_data: set_data,\n    template: template,\n    add_event_listener: events.add_event_listener, // BBB export. TODO: Remove in an upcoming version.\n    remove_event_listener: events.remove_event_listener, // BBB export. TODO: Remove in an upcoming version.\n};\n\nexport default dom;\n","// Event related methods and event factories\n\n// Event listener registration for easy-to-remove event listeners.\n// once Safari supports the ``signal`` option for addEventListener we can abort\n// event handlers by calling AbortController.abort().\nconst event_listener_map = {};\n\n/**\n * Add an event listener to a DOM element under a unique id.\n * If a event is registered under the same id for the same element, the old handler is removed first.\n *\n * @param {DOM Node} el - The element to register the event for.\n * @param {string} event_type - The event type to listen for.\n * @param {string} id - A unique id under which the event is registered.\n * @param {function} cb - The event handler / callback function.\n * @param {Object} opts - Options for the addEventListener API.\n *\n */\nconst add_event_listener = (el, event_type, id, cb, opts = {}) => {\n    if (!el?.addEventListener) {\n        return; // nothing to do.\n    }\n    remove_event_listener(el, id); // do not register one listener twice.\n\n    if (!event_listener_map[el]) {\n        event_listener_map[el] = {};\n    }\n    event_listener_map[el][id] = [event_type, cb, opts.capture ? opts : undefined]; // prettier-ignore\n    el.addEventListener(event_type, cb, opts);\n};\n\n/**\n * Remove an event listener from a DOM element under a unique id.\n *\n * @param {DOM Node} el - The element to register the event for.\n * @param {string} id - A unique id under which the event is registered.\n *\n */\nconst remove_event_listener = (el, id) => {\n    if (!el?.removeEventListener) {\n        return; // nothing to do.\n    }\n    const el_events = event_listener_map[el];\n    if (!el_events) {\n        return;\n    }\n    let entries;\n    if (id) {\n        // remove event listener with specific id\n        const entry = el_events[id];\n        entries = entry ? [entry] : [];\n    } else {\n        // remove all event listeners of element\n        entries = Object.entries(el_events);\n    }\n    for (const entry of entries || []) {\n        el.removeEventListener(entry[0], entry[1], entry[2]);\n    }\n};\n\n/**\n * Await an event to be thrown.\n *\n * Usage:\n *     await events.await_event(button, \"click\");\n *\n * @param {DOM Node} el - The element to listen on.\n * @param {String} event_name - The event name to listen for.\n *\n * @returns {Promise} - Returns a Promise which can be used for ``await`` and which will be resolved when the event is throwm.\n *\n */\nconst await_event = (el, event_name) => {\n    // See: https://stackoverflow.com/a/44746691/1337474\n    return new Promise((resolve) =>\n        el.addEventListener(event_name, resolve, { once: true })\n    );\n};\n\n/**\n * Await pattern init.\n *\n * Usage:\n *     await events.await_pattern_init(PATTERN);\n *\n * @param {Pattern instance} pattern - The pattern instance.\n *\n * @returns {Promise} - Returns a Promise which can be used for ``await`` and which will be resolved when the event is throwm.\n *\n */\nconst await_pattern_init = (pattern) => {\n    // See: https://stackoverflow.com/a/44746691/1337474\n    return new Promise((resolve) => pattern.one(\"init\", resolve));\n};\n\n/**\n * Event factories\n */\n\nconst blur_event = () => {\n    return new Event(\"blur\", {\n        bubbles: false,\n        cancelable: false,\n    });\n};\n\nconst click_event = () => {\n    return new Event(\"click\", {\n        bubbles: true,\n        cancelable: true,\n    });\n};\n\nconst change_event = () => {\n    return new Event(\"change\", {\n        bubbles: true,\n        cancelable: false,\n    });\n};\n\nconst focus_event = () => {\n    return new Event(\"focus\", {\n        bubbles: false,\n        cancelable: false,\n    });\n};\n\nconst input_event = () => {\n    return new Event(\"input\", {\n        bubbles: true,\n        cancelable: false,\n    });\n};\n\nconst mousedown_event = () => {\n    return new Event(\"mousedown\", {\n        bubbles: true,\n        cancelable: true,\n    });\n};\n\nconst mouseup_event = () => {\n    return new Event(\"mouseup\", {\n        bubbles: true,\n        cancelable: true,\n    });\n};\n\nconst scroll_event = () => {\n    return new Event(\"scroll\", {\n        bubbles: true,\n        cancelable: false,\n    });\n};\n\nconst submit_event = () => {\n    return new Event(\"submit\", {\n        bubbles: true,\n        cancelable: true,\n    });\n};\n\nexport default {\n    add_event_listener: add_event_listener,\n    remove_event_listener: remove_event_listener,\n    await_event: await_event,\n    await_pattern_init: await_pattern_init,\n    blur_event: blur_event,\n    click_event: click_event,\n    change_event: change_event,\n    focus_event: focus_event,\n    input_event: input_event,\n    mousedown_event: mousedown_event,\n    mouseup_event: mouseup_event,\n    scroll_event: scroll_event,\n    submit_event: submit_event,\n};\n","/* This is a stub, used by patterns that need compatibility with Mockup which\n * have i18n support.\n *\n * Eventually we might want to implement our own i18n functionality here (while\n * keeping compatibility with Mockup).\n *\n * Jed.js would be a good candidate. (http://slexaxton.github.io/Jed)\n */\n\nexport default function translate(str) {\n    return str;\n}\n","/**\n * @license\n * Patterns @VERSION@ jquery-ext - various jQuery extensions\n *\n * Copyright 2011 Humberto Sermeño\n */\n\nimport $ from \"jquery\";\n\nvar methods = {\n    init: function (options) {\n        var settings = {\n            time: 3 /* time it will wait before moving to \"timeout\" after a move event */,\n            initialTime: 8 /* time it will wait before first adding the \"timeout\" class */,\n            exceptionAreas: [] /* IDs of elements that, if the mouse is over them, will reset the timer */,\n        };\n        return this.each(function () {\n            var $this = $(this),\n                data = $this.data(\"timeout\");\n\n            if (!data) {\n                if (options) {\n                    $.extend(settings, options);\n                }\n                $this.data(\"timeout\", {\n                    lastEvent: new Date(),\n                    trueTime: settings.time,\n                    time: settings.initialTime,\n                    untouched: true,\n                    inExceptionArea: false,\n                });\n\n                $this.on(\"mouseover.timeout\", methods.mouseMoved);\n                $this.on(\"mouseenter.timeout\", methods.mouseMoved);\n\n                $(settings.exceptionAreas).each(function () {\n                    $this\n                        .find(this)\n                        .live(\n                            \"mouseover.timeout\",\n                            { parent: $this },\n                            methods.enteredException\n                        )\n                        .live(\n                            \"mouseleave.timeout\",\n                            { parent: $this },\n                            methods.leftException\n                        );\n                });\n\n                if (settings.initialTime > 0) $this.timeout(\"startTimer\");\n                else $this.addClass(\"timeout\");\n            }\n        });\n    },\n\n    enteredException: function (event) {\n        var data = event.data.parent.data(\"timeout\");\n        data.inExceptionArea = true;\n        event.data.parent.data(\"timeout\", data);\n        event.data.parent.trigger(\"mouseover\");\n    },\n\n    leftException: function (event) {\n        var data = event.data.parent.data(\"timeout\");\n        data.inExceptionArea = false;\n        event.data.parent.data(\"timeout\", data);\n    },\n\n    destroy: function () {\n        return this.each(function () {\n            var $this = $(this),\n                data = $this.data(\"timeout\");\n\n            $(window).off(\".timeout\");\n            data.timeout.remove();\n            $this.removeData(\"timeout\");\n        });\n    },\n\n    mouseMoved: function () {\n        var $this = $(this),\n            data = $this.data(\"timeout\");\n\n        if ($this.hasClass(\"timeout\")) {\n            $this.removeClass(\"timeout\");\n            $this.timeout(\"startTimer\");\n        } else if (data.untouched) {\n            data.untouched = false;\n            data.time = data.trueTime;\n        }\n\n        data.lastEvent = new Date();\n        $this.data(\"timeout\", data);\n    },\n\n    startTimer: function () {\n        var $this = $(this),\n            data = $this.data(\"timeout\");\n        var fn = function () {\n            var data = $this.data(\"timeout\");\n            if (data && data.lastEvent) {\n                if (data.inExceptionArea) {\n                    setTimeout(fn, Math.floor(data.time * 1000));\n                } else {\n                    var now = new Date();\n                    var diff = Math.floor(data.time * 1000) - (now - data.lastEvent);\n                    if (diff > 0) {\n                        // the timeout has not ocurred, so set the timeout again\n                        setTimeout(fn, diff + 100);\n                    } else {\n                        // timeout ocurred, so set the class\n                        $this.addClass(\"timeout\");\n                    }\n                }\n            }\n        };\n\n        setTimeout(fn, Math.floor(data.time * 1000));\n    },\n};\n\n$.fn.timeout = function (method) {\n    if (methods[method]) {\n        return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));\n    } else if (typeof method === \"object\" || !method) {\n        return methods.init.apply(this, arguments);\n    } else {\n        $.error(\"Method \" + method + \" does not exist on jQuery.timeout\");\n    }\n};\n\n// Custom jQuery selector to find elements with scrollbars\n$.extend($.expr[\":\"], {\n    scrollable: function (element) {\n        var vertically_scrollable, horizontally_scrollable;\n        if (\n            $(element).css(\"overflow\") === \"scroll\" ||\n            $(element).css(\"overflowX\") === \"scroll\" ||\n            $(element).css(\"overflowY\") === \"scroll\"\n        )\n            return true;\n\n        vertically_scrollable =\n            element.clientHeight < element.scrollHeight &&\n            ($.inArray($(element).css(\"overflowY\"), [\"scroll\", \"auto\"]) !== -1 ||\n                $.inArray($(element).css(\"overflow\"), [\"scroll\", \"auto\"]) !== -1);\n\n        if (vertically_scrollable) return true;\n\n        horizontally_scrollable =\n            element.clientWidth < element.scrollWidth &&\n            ($.inArray($(element).css(\"overflowX\"), [\"scroll\", \"auto\"]) !== -1 ||\n                $.inArray($(element).css(\"overflow\"), [\"scroll\", \"auto\"]) !== -1);\n        return horizontally_scrollable;\n    },\n});\n\n// Make Visible in scroll\n$.fn.makeVisibleInScroll = function (parent_id) {\n    var absoluteParent = null;\n    if (typeof parent_id === \"string\") {\n        absoluteParent = $(\"#\" + parent_id);\n    } else if (parent_id) {\n        absoluteParent = $(parent_id);\n    }\n\n    return this.each(function () {\n        var $this = $(this),\n            parent;\n        if (!absoluteParent) {\n            parent = $this.parents(\":scrollable\");\n            if (parent.length > 0) {\n                parent = $(parent[0]);\n            } else {\n                parent = $(window);\n            }\n        } else {\n            parent = absoluteParent;\n        }\n\n        var elemTop = $this.position().top;\n        var elemBottom = $this.height() + elemTop;\n\n        var viewTop = parent.scrollTop();\n        var viewBottom = parent.height() + viewTop;\n\n        if (elemTop < viewTop) {\n            parent.scrollTop(elemTop);\n        } else if (elemBottom > viewBottom - parent.height() / 2) {\n            parent.scrollTop(elemTop - (parent.height() - $this.height()) / 2);\n        }\n    });\n};\n\n//Work around warning for jQuery 3.x:\n//JQMIGRATE: jQuery.fn.offset() requires an element connected to a document\n$.fn.safeOffset = function () {\n    var docElem,\n        elem = this[0],\n        origin = { top: 0, left: 0 };\n\n    if (!elem || !elem.nodeType) {\n        return origin;\n    }\n\n    docElem = (elem.ownerDocument || document).documentElement;\n    if (!$.contains(docElem, elem)) {\n        return origin;\n    }\n\n    return $.fn.offset.apply(this, arguments);\n};\n\n//Make absolute location\n$.fn.setPositionAbsolute = function (element, offsettop, offsetleft) {\n    return this.each(function () {\n        // set absolute location for based on the element passed\n        // dynamically since every browser has different settings\n        var $this = $(this);\n        var thiswidth = $(this).width();\n        var pos = element.safeOffset();\n        var width = element.width();\n        var height = element.height();\n        var setleft = pos.left + width - thiswidth + offsetleft;\n        var settop = pos.top + height + offsettop;\n        $this.css({\n            \"z-index\": 1,\n            \"position\": \"absolute\",\n            \"marginLeft\": 0,\n            \"marginTop\": 0,\n            \"left\": setleft + \"px\",\n            \"top\": settop + \"px\",\n            \"width\": thiswidth,\n        });\n        $this.remove().appendTo(\"body\").show();\n    });\n};\n\n$.fn.positionAncestor = function (selector) {\n    var left = 0;\n    var top = 0;\n    this.each(function () {\n        // check if current element has an ancestor matching a selector\n        // and that ancestor is positioned\n        var $ancestor = $(this).closest(selector);\n        if ($ancestor.length && $ancestor.css(\"position\") !== \"static\") {\n            var $child = $(this);\n            var childMarginEdgeLeft =\n                $child.safeOffset().left - parseInt($child.css(\"marginLeft\"), 10);\n            var childMarginEdgeTop =\n                $child.safeOffset().top - parseInt($child.css(\"marginTop\"), 10);\n            var ancestorPaddingEdgeLeft =\n                $ancestor.safeOffset().left +\n                parseInt($ancestor.css(\"borderLeftWidth\"), 10);\n            var ancestorPaddingEdgeTop =\n                $ancestor.safeOffset().top +\n                parseInt($ancestor.css(\"borderTopWidth\"), 10);\n            left = childMarginEdgeLeft - ancestorPaddingEdgeLeft;\n            top = childMarginEdgeTop - ancestorPaddingEdgeTop;\n            // we have found the ancestor and computed the position\n            // stop iterating\n            return false;\n        }\n    });\n    return {\n        left: left,\n        top: top,\n    };\n};\n\n$.fn.findInclusive = function (selector) {\n    return this.find(\"*\").addBack().filter(selector);\n};\n\n$.fn.slideIn = function (speed, easing, callback) {\n    return this.animate({ width: \"show\" }, speed, easing, callback);\n};\n\n$.fn.slideOut = function (speed, easing, callback) {\n    return this.animate({ width: \"hide\" }, speed, easing, callback);\n};\n\n// case-insensitive :contains\n$.expr[\":\"].Contains = function (a, i, m) {\n    return $(a).text().toUpperCase().indexOf(m[3].toUpperCase()) >= 0;\n};\n\n$.fn.scopedFind = function (selector) {\n    /*  If the selector starts with an object id do a global search,\n     *  otherwise do a local search.\n     */\n    if (selector.indexOf(\"#\") === 0) {\n        return $(selector);\n    } else {\n        return this.find(selector);\n    }\n};\n\nexport default undefined;\n","/**\n * Patterns logging - minimal logging framework\n *\n * Copyright 2012 Simplon B.V.\n */\n\n// source: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/bind\nif (!Function.prototype.bind) {\n    Function.prototype.bind = function (oThis) {\n        if (typeof this !== \"function\") {\n            // closest thing possible to the ECMAScript 5 internal IsCallable function\n            throw new TypeError(\n                \"Function.prototype.bind - what is trying to be bound is not callable\"\n            );\n        }\n\n        var aArgs = Array.prototype.slice.call(arguments, 1),\n            fToBind = this,\n            fNOP = function () {},\n            fBound = function () {\n                return fToBind.apply(\n                    this instanceof fNOP && oThis ? this : oThis,\n                    aArgs.concat(Array.prototype.slice.call(arguments))\n                );\n            };\n        fNOP.prototype = this.prototype;\n        fBound.prototype = new fNOP();\n\n        return fBound;\n    };\n}\n\nvar root, // root logger instance\n    writer; // writer instance, used to output log entries\n\nvar Level = {\n    DEBUG: 10,\n    INFO: 20,\n    WARN: 30,\n    ERROR: 40,\n    FATAL: 50,\n};\n\nfunction ConsoleWriter() {}\n\nConsoleWriter.prototype = {\n    output: function (log_name, level, messages) {\n        if (log_name) messages.unshift(log_name + \":\");\n        if (level <= Level.DEBUG) {\n            // console.debug exists but is deprecated\n            messages.unshift(\"[DEBUG]\");\n            console.log.apply(console, messages);\n        } else if (level <= Level.INFO) console.info.apply(console, messages);\n        else if (level <= Level.WARN) console.warn.apply(console, messages);\n        else console.error.apply(console, messages);\n    },\n};\n\nfunction Logger(name, parent) {\n    this._loggers = {};\n    this.name = name || \"\";\n    this._parent = parent || null;\n    if (!parent) {\n        this._enabled = true;\n        this._level = Level.WARN;\n    }\n}\n\nLogger.prototype = {\n    getLogger: function (name) {\n        var path = name.split(\".\"),\n            root = this,\n            route = this.name ? [this.name] : [];\n        while (path.length) {\n            var entry = path.shift();\n            route.push(entry);\n            if (!(entry in root._loggers))\n                root._loggers[entry] = new Logger(route.join(\".\"), root);\n            root = root._loggers[entry];\n        }\n        return root;\n    },\n\n    _getFlag: function (flag) {\n        var context = this;\n        flag = \"_\" + flag;\n        while (context !== null) {\n            if (context[flag] !== undefined) return context[flag];\n            context = context._parent;\n        }\n        return null;\n    },\n\n    setEnabled: function (state) {\n        this._enabled = !!state;\n    },\n\n    isEnabled: function () {\n        this._getFlag(\"enabled\");\n    },\n\n    setLevel: function (level) {\n        if (typeof level === \"number\") this._level = level;\n        else if (typeof level === \"string\") {\n            level = level.toUpperCase();\n            if (level in Level) this._level = Level[level];\n        }\n    },\n\n    getLevel: function () {\n        return this._getFlag(\"level\");\n    },\n\n    log: function (level, messages) {\n        if (\n            !messages.length ||\n            !this._getFlag(\"enabled\") ||\n            level < this._getFlag(\"level\")\n        )\n            return;\n        messages = Array.prototype.slice.call(messages);\n        writer.output(this.name, level, messages);\n    },\n\n    debug: function () {\n        this.log(Level.DEBUG, arguments);\n    },\n\n    info: function () {\n        this.log(Level.INFO, arguments);\n    },\n\n    warn: function () {\n        this.log(Level.WARN, arguments);\n    },\n\n    error: function () {\n        this.log(Level.ERROR, arguments);\n    },\n\n    fatal: function () {\n        this.log(Level.FATAL, arguments);\n    },\n};\n\nfunction getWriter() {\n    return writer;\n}\n\nfunction setWriter(w) {\n    writer = w;\n}\n\nsetWriter(new ConsoleWriter());\n\nroot = new Logger();\n\nvar logconfig = /loglevel(|-[^=]+)=([^&]+)/g,\n    match;\n\nwhile ((match = logconfig.exec(window.location.search)) !== null) {\n    var logger = match[1] === \"\" ? root : root.getLogger(match[1].slice(1));\n    logger.setLevel(match[2].toUpperCase());\n}\n\nvar api = {\n    Level: Level,\n    getLogger: root.getLogger.bind(root),\n    setEnabled: root.setEnabled.bind(root),\n    isEnabled: root.isEnabled.bind(root),\n    setLevel: root.setLevel.bind(root),\n    getLevel: root.getLevel.bind(root),\n    debug: root.debug.bind(root),\n    info: root.info.bind(root),\n    warn: root.warn.bind(root),\n    error: root.error.bind(root),\n    fatal: root.fatal.bind(root),\n    getWriter: getWriter,\n    setWriter: setWriter,\n};\n\nexport default api;\n","// Patterns argument parser\nimport $ from \"jquery\";\nimport utils from \"./utils.js\";\nimport logging from \"./logging\";\n\nclass ArgumentParser {\n    constructor(name) {\n        this.order = [];\n        this.parameters = {};\n        this.attribute = \"data-pat-\" + name;\n        this.enum_values = {};\n        this.enum_conflicts = [];\n        this.groups = {};\n        this.possible_groups = {};\n        this.log = logging.getLogger(name + \".parser\");\n\n        this.group_pattern = /([a-z][a-z0-9]*)-([A-Z][a-z0-0\\-]*)/i;\n        this.json_param_pattern = /^\\s*\\[?\\s*{/i;\n        this.named_param_pattern = /^\\s*([a-z][a-z0-9\\-]*)\\s*:(.*)/is;\n        this.token_pattern = /(([\"']).*?(?!\\\\)\\2)|\\s*(\\S+)\\s*/g;\n    }\n\n    _camelCase(str) {\n        return str.replace(/\\-([a-z])/g, (__, p1) => p1.toUpperCase());\n    }\n\n    addAlias(alias, original) {\n        /* Add an alias for a previously added parser argument.\n         *\n         * Useful when you want to support both US and UK english argument\n         * names.\n         */\n        if (this.parameters[original]) {\n            this.parameters[original].alias = alias;\n        } else {\n            throw (\n                'Attempted to add an alias \"' +\n                alias +\n                '\" for a non-existing parser argument \"' +\n                original +\n                '\".'\n            );\n        }\n    }\n\n    addGroupToSpec(spec) {\n        /* Determine wether an argument being parsed can be grouped and\n         * update its specifications object accordingly.\n         *\n         * Internal method used by addArgument and addJSONArgument\n         */\n        const m = spec.name.match(this.group_pattern);\n        if (m) {\n            const group = m[1];\n            const field = m[2];\n            if (group in this.possible_groups) {\n                const first_spec = this.possible_groups[group];\n                const first_name = first_spec.name.match(this.group_pattern)[2];\n                first_spec.group = group;\n                first_spec.dest = first_name;\n                this.groups[group] = new ArgumentParser();\n                this.groups[group].addArgument(\n                    first_name,\n                    first_spec.value,\n                    first_spec.choices,\n                    first_spec.multiple\n                );\n                delete this.possible_groups[group];\n            }\n            if (group in this.groups) {\n                this.groups[group].addArgument(\n                    field,\n                    spec.value,\n                    spec.choices,\n                    spec.multiple\n                );\n                spec.group = group;\n                spec.dest = field;\n            } else {\n                this.possible_groups[group] = spec;\n                spec.dest = this._camelCase(spec.name);\n            }\n        }\n        return spec;\n    }\n\n    addJSONArgument(name, default_value) {\n        /* Add an argument where the value is provided in JSON format.\n         *\n         * This is a different usecase than specifying all arguments to\n         * the data-pat-... attributes in JSON format, and instead is part\n         * of the normal notation except that a value is in JSON instead of\n         * for example a string.\n         */\n        this.order.push(name);\n        this.parameters[name] = this.addGroupToSpec({\n            name: name,\n            value: default_value,\n            dest: name,\n            group: null,\n            type: \"json\",\n        });\n    }\n\n    addArgument(name, default_value, choices, multiple) {\n        const spec = {\n            name: name,\n            value:\n                multiple && !Array.isArray(default_value)\n                    ? [default_value]\n                    : default_value,\n            multiple: multiple,\n            dest: name,\n            group: null,\n        };\n        if (choices && Array.isArray(choices) && choices.length) {\n            spec.choices = choices;\n            spec.type = this._typeof(choices[0]);\n            for (const choice of choices) {\n                if (this.enum_conflicts.indexOf(choice) !== -1) {\n                    continue;\n                } else if (choice in this.enum_values) {\n                    this.enum_conflicts.push(choice);\n                    delete this.enum_values[choice];\n                } else {\n                    this.enum_values[choice] = name;\n                }\n            }\n        } else if (typeof spec.value === \"string\" && spec.value.slice(0, 1) === \"$\") {\n            spec.type = this.parameters[spec.value.slice(1)].type;\n        } else {\n            // Note that this will get reset by _defaults if default_value is a function.\n            spec.type = this._typeof(multiple ? spec.value[0] : spec.value);\n        }\n        this.order.push(name);\n        this.parameters[name] = this.addGroupToSpec(spec);\n    }\n\n    _typeof(obj) {\n        if (obj === null) {\n            return \"null\";\n        }\n        return typeof obj;\n    }\n\n    _coerce(name, value) {\n        const spec = this.parameters[name];\n        if (typeof value !== spec.type)\n            try {\n                switch (spec.type) {\n                    case \"json\":\n                        value = JSON.parse(value);\n                        break;\n                    case \"boolean\":\n                        if (typeof value === \"string\") {\n                            value = value.toLowerCase();\n                            const num = parseInt(value, 10);\n                            if (!isNaN(num)) value = !!num;\n                            else\n                                value =\n                                    value === \"true\" ||\n                                    value === \"y\" ||\n                                    value === \"yes\" ||\n                                    value === \"y\" ||\n                                    value === \"on\";\n                        } else if (typeof value === \"number\") {\n                            value = !!value;\n                        } else {\n                            throw \"Cannot convert value for \" + name + \" to boolean\";\n                        }\n                        break;\n                    case \"number\":\n                        if (typeof value === \"string\") {\n                            value = parseInt(value, 10);\n                            if (isNaN(value)) {\n                                throw \"Cannot convert value for \" + name + \" to number\";\n                            }\n                        } else if (typeof value === \"boolean\") {\n                            value = value + 0;\n                        } else {\n                            throw \"Cannot convert value for \" + name + \" to number\";\n                        }\n                        break;\n                    case \"string\":\n                        value = value.toString();\n                        break;\n                    case \"null\": // Missing default values\n                    case \"undefined\":\n                        break;\n                    default:\n                        throw (\n                            \"Do not know how to convert value for \" +\n                            name +\n                            \" to \" +\n                            spec.type\n                        );\n                }\n            } catch (e) {\n                this.log.warn(e);\n                return null;\n            }\n\n        if (spec.choices && spec.choices.indexOf(value) === -1) {\n            this.log.warn(\"Illegal value for \" + name + \": \" + value);\n            return null;\n        }\n        return value;\n    }\n\n    _set(opts, name, value) {\n        if (!(name in this.parameters)) {\n            this.log.debug(\"Ignoring value for unknown argument \" + name);\n            return;\n        }\n        const spec = this.parameters[name];\n        let parts;\n        if (spec.multiple) {\n            if (typeof value === \"string\") {\n                parts = value.split(/,+/);\n            } else {\n                parts = value;\n            }\n            value = [];\n            for (const part of parts) {\n                const v = this._coerce(name, part.trim());\n                if (v !== null) {\n                    value.push(v);\n                }\n            }\n        } else {\n            value = this._coerce(name, value);\n            if (value === null) {\n                return;\n            }\n        }\n        opts[name] = value;\n    }\n\n    _split(text) {\n        const tokens = [];\n        text.replace(this.token_pattern, (match, quoted, __, simple) => {\n            if (quoted) {\n                tokens.push(quoted);\n            } else if (simple) {\n                tokens.push(simple);\n            }\n        });\n        return tokens;\n    }\n\n    _parseExtendedNotation(argstring) {\n        const opts = {};\n        const parts = argstring\n            .replace(/;;/g, \"\\0x1f\")\n            .replace(/&amp;/g, \"&amp\\0x1f\")\n            .split(/;/)\n            .map((el) => el.replace(new RegExp(\"\\0x1f\", \"g\"), \";\"));\n        for (const part of parts) {\n            if (!part) {\n                continue;\n            }\n            const matches = part.match(this.named_param_pattern);\n            if (!matches) {\n                this.log.warn(\"Invalid parameter: \" + part + \": \" + argstring);\n                continue;\n            }\n            const name = matches[1];\n            const value = matches[2].trim();\n            const arg = Object.values(this.parameters).filter((it) => it.alias === name);\n\n            const is_alias = arg.length === 1;\n\n            if (is_alias) {\n                this._set(opts, arg[0].name, value);\n            } else if (name in this.parameters) {\n                this._set(opts, name, value);\n            } else if (name in this.groups) {\n                const subopt = this.groups[name]._parseShorthandNotation(value);\n                for (const field in subopt) {\n                    this._set(opts, name + \"-\" + field, subopt[field]);\n                }\n            } else {\n                this.log.warn(\"Unknown named parameter \" + matches[1]);\n                continue;\n            }\n        }\n        return opts;\n    }\n\n    _parseShorthandNotation(parameter) {\n        const parts = this._split(parameter);\n        const opts = {};\n        let i = 0;\n\n        while (parts.length) {\n            const part = parts.shift().trim();\n            let sense;\n            let flag;\n            let positional = true;\n            if (part.slice(0, 3) === \"no-\") {\n                sense = false;\n                flag = part.slice(3);\n            } else {\n                sense = true;\n                flag = part;\n            }\n            if (flag in this.parameters && this.parameters[flag].type === \"boolean\") {\n                positional = false;\n                this._set(opts, flag, sense);\n            } else if (flag in this.enum_values) {\n                positional = false;\n                this._set(opts, this.enum_values[flag], flag);\n            } else if (positional) this._set(opts, this.order[i], part);\n            else {\n                parts.unshift(part);\n                break;\n            }\n            i++;\n            if (i >= this.order.length) {\n                break;\n            }\n        }\n        if (parts.length) this.log.warn(\"Ignore extra arguments: \" + parts.join(\" \"));\n        return opts;\n    }\n\n    _parse(parameter) {\n        if (!parameter) {\n            return {};\n        }\n        if (parameter.match(this.json_param_pattern)) {\n            try {\n                return JSON.parse(parameter);\n            } catch (e) {\n                this.log.warn(\"Invalid JSON argument found: \" + parameter);\n            }\n        }\n        if (parameter.match(this.named_param_pattern)) {\n            return this._parseExtendedNotation(parameter);\n        }\n        const sep = parameter.indexOf(\";\");\n        if (sep === -1) {\n            return this._parseShorthandNotation(parameter);\n        }\n        const opts = this._parseShorthandNotation(parameter.slice(0, sep));\n        const extended = this._parseExtendedNotation(parameter.slice(sep + 1));\n        for (const name in extended) {\n            opts[name] = extended[name];\n        }\n        return opts;\n    }\n\n    _defaults($el) {\n        const result = {};\n        for (const name in this.parameters)\n            if (typeof this.parameters[name].value === \"function\")\n                try {\n                    result[name] = this.parameters[name].value($el, name);\n                    this.parameters[name].type = typeof result[name];\n                } catch (e) {\n                    this.log.error(\"Default function for \" + name + \" failed.\");\n                }\n            else result[name] = this.parameters[name].value;\n        return result;\n    }\n\n    _cleanupOptions(options, group_options = true) {\n        // Resolve references\n        for (const name of Object.keys(options)) {\n            const spec = this.parameters[name];\n            if (spec === undefined) continue;\n\n            if (\n                options[name] === spec.value &&\n                typeof spec.value === \"string\" &&\n                spec.value.slice(0, 1) === \"$\"\n            )\n                options[name] = options[spec.value.slice(1)];\n        }\n        if (group_options) {\n            // Move options into groups and do renames\n            for (const name of Object.keys(options)) {\n                const spec = this.parameters[name];\n                let target;\n                if (spec === undefined) continue;\n\n                if (spec.group) {\n                    if (typeof options[spec.group] !== \"object\")\n                        options[spec.group] = {};\n                    target = options[spec.group];\n                } else {\n                    target = options;\n                }\n\n                if (spec.dest !== name) {\n                    target[spec.dest] = options[name];\n                    delete options[name];\n                }\n            }\n        }\n        return options;\n    }\n\n    parse($el, options, multiple, inherit = true, group_options = true) {\n        if (!$el.jquery) {\n            $el = $($el);\n        }\n        if (typeof options === \"boolean\" && multiple === undefined) {\n            // Fix argument order: ``multiple`` passed instead of ``options``.\n            multiple = options;\n            options = {};\n        }\n        const stack = inherit ? [[this._defaults($el)]] : [[{}]];\n        let $possible_config_providers;\n        let final_length = 1;\n        /*\n         * XXX this is a workaround for:\n         * - https://github.com/Patternslib/Patterns/issues/393\n         *\n         * Prevents the parser to pollute the pat-modal configuration\n         * with data-pat-inject elements define in a `.pat-modal` parent element.\n         *\n         *  Probably this function should be completely revisited, see:\n         * - https://github.com/Patternslib/Patterns/issues/627\n         *\n         */\n        if (\n            !inherit ||\n            ($el.hasClass(\"pat-modal\") && this.attribute === \"data-pat-inject\")\n        ) {\n            $possible_config_providers = $el;\n        } else {\n            $possible_config_providers = $el\n                .parents(\"[\" + this.attribute + \"]\")\n                .addBack();\n        }\n\n        for (const provider of $possible_config_providers) {\n            let frame;\n            const data = ($(provider).attr(this.attribute) || \"\").trim();\n            if (!data) {\n                continue;\n            }\n            const _parse = this._parse.bind(this);\n            if (data.match(/&&/)) {\n                frame = data.split(/\\s*&&\\s*/).map(_parse);\n            } else {\n                frame = _parse(data);\n            }\n            if (!Array.isArray(frame)) {\n                frame = [frame];\n            }\n            final_length = Math.max(frame.length, final_length);\n            stack.push(frame);\n        }\n\n        if (typeof options === \"object\") {\n            if (Array.isArray(options)) {\n                stack.push(options);\n                final_length = Math.max(options.length, final_length);\n            } else {\n                stack.push([options]);\n            }\n        }\n        if (!multiple) {\n            final_length = 1;\n        }\n        const results = utils\n            .removeDuplicateObjects(utils.mergeStack(stack, final_length))\n            .map((current_value) => this._cleanupOptions(current_value, group_options));\n        return multiple ? results : results[0];\n    }\n}\n\n// BBB\nArgumentParser.prototype.add_argument = ArgumentParser.prototype.addArgument;\n\nexport default ArgumentParser;\n","// Polyfills for modern browsers\n\n// SubmitEvent.submitter polyfill for Safari < 15.4 and jsDOM\n// Original code: https://stackoverflow.com/a/61110260/1337474\n// Also see: https://caniuse.com/?search=submitter\n//\n!(function () {\n    let last_btn = null;\n    const submitable_buttons = `button, input[type=\"button\"], input[type=\"submit\"], input[type=\"image\"]`;\n    document.addEventListener(\n        \"click\",\n        function (e) {\n            if (!e.target.closest) return;\n            last_btn = e.target.closest(submitable_buttons);\n        },\n        true\n    );\n    document.addEventListener(\n        \"submit\",\n        function (e) {\n            if (\"submitter\" in e) return;\n            const canditates = [document.activeElement, last_btn];\n            last_btn = null;\n            for (const candidate of canditates) {\n                if (!candidate) continue;\n                if (!candidate.form) continue;\n                if (!candidate.matches(submitable_buttons)) continue;\n                e.submitter = candidate;\n                return;\n            }\n            e.submitter = e.target.querySelector(submitable_buttons);\n        },\n        true\n    );\n})();\n","/**\n * Patterns registry - Central registry and scan logic for patterns\n *\n * Copyright 2012-2013 Simplon B.V.\n * Copyright 2012-2013 Florian Friesdorf\n * Copyright 2013 Marko Durkovic\n * Copyright 2013 Rok Garbas\n * Copyright 2014-2015 Syslab.com GmBH, JC Brand\n */\n\n/*\n * changes to previous patterns.register/scan mechanism\n * - if you want initialised class, do it in init\n * - init returns set of elements actually initialised\n * - handle once within init\n * - no turnstile anymore\n * - set pattern.jquery_plugin if you want it\n */\nimport $ from \"jquery\";\nimport dom from \"./dom\";\nimport logging from \"./logging\";\nimport utils from \"./utils\";\n\nconst log = logging.getLogger(\"registry\");\nconst disable_re = /patterns-disable=([^&]+)/g;\nconst dont_catch_re = /patterns-dont-catch/g;\nconst disabled = {};\nlet dont_catch = false;\nlet match;\n\nwhile ((match = disable_re.exec(window.location.search)) !== null) {\n    disabled[match[1]] = true;\n    log.info(\"Pattern disabled via url config:\", match[1]);\n}\n\nwhile ((match = dont_catch_re.exec(window.location.search)) !== null) {\n    dont_catch = true;\n    log.info(\"I will not catch init exceptions\");\n}\n\n/**\n * Global pattern registry.\n *\n * This is a singleton and shared among any instance of the Patternslib\n * registry since Patternslib version 8.\n *\n * You normally don't need this as the registry handles it for you.\n */\nif (typeof window.__patternslib_registry === \"undefined\") {\n    window.__patternslib_registry = {};\n}\nexport const PATTERN_REGISTRY = window.__patternslib_registry;\nif (typeof window.__patternslib_registry_initialized === \"undefined\") {\n    window.__patternslib_registry_initialized = false;\n}\n\nconst registry = {\n    patterns: PATTERN_REGISTRY, // reference to global patterns registry\n    // as long as the registry is not initialized, pattern\n    // registration just registers a pattern. Once init is called,\n    // the DOM is scanned. After that registering a new pattern\n    // results in rescanning the DOM only for this pattern.\n    init() {\n        $(document).ready(function () {\n            if (window.__patternslib_registry_initialized) {\n                // Do not reinitialize a already initialized registry.\n                return;\n            }\n            window.__patternslib_registry_initialized = true;\n            log.debug(\"Loaded: \" + Object.keys(registry.patterns).sort().join(\", \"));\n            registry.scan(document.body);\n            log.debug(\"Finished initial scan.\");\n        });\n    },\n\n    clear() {\n        // Removes all patterns from the registry. Currently only being\n        // used in tests.\n        for (const name in registry.patterns) {\n            delete registry.patterns[name];\n        }\n    },\n\n    transformPattern(name, content) {\n        /* Call the transform method on the pattern with the given name, if\n         * it exists.\n         */\n        if (disabled[name]) {\n            log.debug(`Skipping disabled pattern: ${name}.`);\n            return;\n        }\n\n        const pattern = registry.patterns[name];\n        const transform = pattern.transform || pattern.prototype?.transform;\n        if (transform) {\n            try {\n                transform($(content));\n            } catch (e) {\n                if (dont_catch) {\n                    throw e;\n                }\n                log.error(`Transform error for pattern ${name}.`, e);\n            }\n        }\n    },\n\n    initPattern(name, el, trigger) {\n        /* Initialize the pattern with the provided name and in the context\n         * of the passed in DOM element.\n         */\n        const $el = $(el);\n        const pattern = registry.patterns[name];\n        if (pattern.init) {\n            const plog = logging.getLogger(`pat.${name}`);\n            if ($el.is(pattern.trigger)) {\n                plog.debug(\"Initialising.\", $el);\n                try {\n                    pattern.init($el, null, trigger);\n                    plog.debug(\"done.\");\n                } catch (e) {\n                    if (dont_catch) {\n                        throw e;\n                    }\n                    plog.error(\"Caught error:\", e);\n                }\n            }\n        }\n    },\n\n    orderPatterns(patterns) {\n        // Always add pat-validation as first pattern, so that it can prevent\n        // other patterns from reacting to submit events if form validation\n        // fails.\n        if (patterns.includes(\"validation\")) {\n            patterns.splice(patterns.indexOf(\"validation\"), 1);\n            patterns.unshift(\"validation\");\n        }\n        return patterns;\n    },\n\n    scan(content, patterns, trigger) {\n        if (!content) {\n            return;\n        }\n\n        if (typeof content === \"string\") {\n            content = document.querySelector(content);\n        } else if (content.jquery) {\n            content = content[0];\n        }\n\n        const selectors = [];\n        patterns = this.orderPatterns(patterns || Object.keys(registry.patterns));\n        for (const name of patterns) {\n            this.transformPattern(name, content);\n            const pattern = registry.patterns[name];\n            if (pattern.trigger) {\n                selectors.unshift(pattern.trigger);\n            }\n        }\n\n        let matches = dom.querySelectorAllAndMe(\n            content,\n            selectors.map((it) => it.trim().replace(/,$/, \"\")).join(\",\")\n        );\n        matches = matches.filter((el) => {\n            // Filter out patterns:\n            // - with class ``.disable-patterns``\n            // - wrapped in ``.disable-patterns`` elements\n            // - wrapped in ``<pre>`` elements\n            // - wrapped in ``<template>`` elements\n            return (\n                !el.matches(\".disable-patterns\") &&\n                !el?.parentNode?.closest?.(\".disable-patterns\") &&\n                !el?.parentNode?.closest?.(\"pre\") &&\n                !el?.parentNode?.closest?.(\"template\") && // NOTE: not strictly necessary. Template is a DocumentFragment and not reachable except for IE.\n                !el.matches(\".cant-touch-this\") && // BBB. TODO: Remove with next major version.\n                !el?.parentNode?.closest?.(\".cant-touch-this\") // BBB. TODO: Remove with next major version.\n            );\n        });\n\n        // walk list backwards and initialize patterns inside-out.\n        for (const el of matches.reverse()) {\n            for (const name of patterns) {\n                this.initPattern(name, el, trigger);\n            }\n        }\n        document.body.classList.add(\"patterns-loaded\");\n    },\n\n    register(pattern, name) {\n        name = name || pattern.name;\n        if (!name) {\n            log.error(\"Pattern lacks a name.\", pattern);\n            return false;\n        }\n        if (registry.patterns[name]) {\n            log.debug(`Already have a pattern called ${name}.`);\n            return false;\n        }\n        // register pattern to be used for scanning new content\n        registry.patterns[name] = pattern;\n\n        // register pattern as jquery plugin\n        if (pattern.jquery_plugin) {\n            const plugin_name = (\"pat-\" + name).replace(\n                /-([a-zA-Z])/g,\n                function (match, p1) {\n                    return p1.toUpperCase();\n                }\n            );\n            $.fn[plugin_name] = utils.jqueryPlugin(pattern);\n            // BBB 2012-12-10 and also for Mockup patterns.\n            $.fn[plugin_name.replace(/^pat/, \"pattern\")] = $.fn[plugin_name];\n        }\n        log.debug(`Registered pattern ${name}`, pattern);\n        if (window.__patternslib_registry_initialized) {\n            // Once the first initialization has been done, do only scan for\n            // newly registered patterns.\n            registry.scan(document.body, [name]);\n            log.debug(`Re-scanned dom with newly registered pattern ${name}.`);\n        }\n        return true;\n    },\n};\n\nexport default registry;\n","/**\n * Patterns store - store pattern state locally in the browser\n *\n * Copyright 2008-2012 Simplon B.V.\n * Copyright 2011 Humberto Sermeño\n * Copyright 2011 Florian Friesdorf\n */\nimport logging from \"./logging\";\n\nconst log = logging.getLogger(\"Patternslib Store\");\n\nfunction Storage(backend, prefix) {\n    this.prefix = prefix;\n    this.backend = backend;\n}\n\nStorage.prototype._key = function Storage_key(name) {\n    return this.prefix + \":\" + name;\n};\n\nStorage.prototype._allKeys = function Storage_allKeys() {\n    var keys = [],\n        prefix = this.prefix + \":\",\n        prefix_length = prefix.length,\n        key,\n        i;\n\n    for (i = 0; i < this.backend.length; i++) {\n        key = this.backend.key(i);\n        if (key.slice(0, prefix_length) === prefix) keys.push(key);\n    }\n    return keys;\n};\n\nStorage.prototype.get = function Storage_get(name) {\n    var key = this._key(name),\n        value = this.backend.getItem(key);\n    if (value !== null) {\n        try {\n            value = JSON.parse(value);\n        } catch {\n            log.warn(`Cannot parse storage value for key ${key}`);\n            return;\n        }\n    }\n    return value;\n};\n\nStorage.prototype.set = function Storage_set(name, value) {\n    var key = this._key(name);\n    return this.backend.setItem(key, JSON.stringify(value));\n};\n\nStorage.prototype.remove = function Storage_remove(name) {\n    var key = this._key(name);\n    return this.backend.removeItem(key);\n};\n\nStorage.prototype.clear = function Storage_clear() {\n    var keys = this._allKeys();\n    for (var i = 0; i < keys.length; i++) this.backend.removeItem(keys[i]);\n};\n\nStorage.prototype.all = function Storage_all() {\n    var keys = this._allKeys(),\n        prefix_length = this.prefix.length + 1,\n        lk,\n        data = {};\n\n    for (var i = 0; i < keys.length; i++) {\n        lk = keys[i].slice(prefix_length);\n        data[lk] = JSON.parse(this.backend.getItem(keys[i]));\n    }\n    return data;\n};\n\nfunction ValueStorage(store, name) {\n    this.store = store;\n    this.name = name;\n}\n\nValueStorage.prototype.get = function ValueStorage_get() {\n    return this.store.get(this.name);\n};\n\nValueStorage.prototype.set = function ValueStorage_get(value) {\n    return this.store.set(this.name, value);\n};\n\nValueStorage.prototype.remove = function ValueStorage_remove() {\n    return this.store.remove(this.name);\n};\n\nvar store = {\n    supported: false,\n\n    local: function (name) {\n        return new Storage(window.localStorage, name);\n    },\n\n    session: function (name) {\n        return new Storage(window.sessionStorage, name);\n    },\n\n    ValueStorage: ValueStorage,\n\n    // Update storage options for a given element.\n    updateOptions: function store_updateOptions(trigger, options) {\n        if (options.store !== \"none\") {\n            if (!trigger.id) {\n                log.warn(\"state persistance requested, but element has no id\");\n                options.store = \"none\";\n            } else if (!store.supported) {\n                log.warn(\n                    \"state persistance requested, but browser does not support webstorage\"\n                );\n                options.store = \"none\";\n            }\n        }\n        return options;\n    },\n};\n\n// Perform the test separately since this may throw a SecurityError as\n// reported in #326\ntry {\n    store.supported = typeof window.sessionStorage !== \"undefined\";\n} catch (e) {\n    // just ignore.\n}\n\nexport default store;\n","import $ from \"jquery\";\nimport dom from \"./dom\";\n\nconst _MS_PER_DAY = 1000 * 60 * 60 * 24; // Milliseconds per day.\n\n$.fn.safeClone = function () {\n    var $clone = this.clone();\n    // IE BUG : Placeholder text becomes actual value after deep clone on textarea\n    // https://connect.microsoft.com/IE/feedback/details/781612/placeholder-text-becomes-actual-value-after-deep-clone-on-textarea\n    if (window.document.documentMode) {\n        $clone.findInclusive(\":input[placeholder]\").each(function (i, item) {\n            var $item = $(item);\n            if ($item.attr(\"placeholder\") === $item.val()) {\n                $item.val(\"\");\n            }\n        });\n    }\n    return $clone;\n};\n\n// Production steps of ECMA-262, Edition 5, 15.4.4.18\n// Reference: http://es5.github.io/#x15.4.4.18\nif (!Array.prototype.forEach) {\n    Array.prototype.forEach = function (callback, thisArg) {\n        var T, k;\n        if (this === null) {\n            throw new TypeError(\" this is null or not defined\");\n        }\n        // 1. Let O be the result of calling ToObject passing the |this| value as the argument.\n        var O = Object(this);\n        // 2. Let lenValue be the result of calling the Get internal method of O with the argument \"length\".\n        // 3. Let len be ToUint32(lenValue).\n        var len = O.length >>> 0;\n        // 4. If IsCallable(callback) is false, throw a TypeError exception.\n        // See: http://es5.github.com/#x9.11\n        if (typeof callback !== \"function\") {\n            throw new TypeError(callback + \" is not a function\");\n        }\n        // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.\n        if (arguments.length > 1) {\n            T = thisArg;\n        }\n        // 6. Let k be 0\n        k = 0;\n        // 7. Repeat, while k < len\n        while (k < len) {\n            var kValue;\n            // a. Let Pk be ToString(k).\n            //   This is implicit for LHS operands of the in operator\n            // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.\n            //   This step can be combined with c\n            // c. If kPresent is true, then\n            if (k in O) {\n                // i. Let kValue be the result of calling the Get internal method of O with argument Pk.\n                kValue = O[k];\n                // ii. Call the Call internal method of callback with T as the this value and\n                // argument list containing kValue, k, and O.\n                callback.call(T, kValue, k, O);\n            }\n            // d. Increase k by 1.\n            k++;\n        }\n        // 8. return undefined\n    };\n}\n\nvar singleBoundJQueryPlugin = function (pattern, method, options) {\n    /* This is a jQuery plugin for patterns which are invoked ONCE FOR EACH\n     * matched element in the DOM.\n     *\n     * This is how the Mockup-type patterns behave. They are constructor\n     * functions which need to be invoked once per jQuery-wrapped DOM node\n     * for all DOM nodes on which the pattern applies.\n     */\n    var $this = this;\n    $this.each(function () {\n        var pat,\n            $el = $(this);\n        pat = pattern.init($el, options);\n        if (method) {\n            if (pat[method] === undefined) {\n                $.error(\n                    \"Method \" + method + \" does not exist on jQuery.\" + pattern.name\n                );\n                return false;\n            }\n            if (method.charAt(0) === \"_\") {\n                $.error(\"Method \" + method + \" is private on jQuery.\" + pattern.name);\n                return false;\n            }\n            pat[method].apply(pat, [options]);\n        }\n    });\n    return $this;\n};\n\nvar pluralBoundJQueryPlugin = function (pattern, method, options) {\n    /* This is a jQuery plugin for patterns which are invoked ONCE FOR ALL\n     * matched elements in the DOM.\n     *\n     * This is how the vanilla Patternslib-type patterns behave. They are\n     * simple objects with an init method and this method gets called once\n     * with a list of jQuery-wrapped DOM nodes on which the pattern\n     * applies.\n     */\n    var $this = this;\n    if (method) {\n        if (pattern[method]) {\n            return pattern[method].apply($this, [$this].concat([options]));\n        } else {\n            $.error(\"Method \" + method + \" does not exist on jQuery.\" + pattern.name);\n        }\n    } else {\n        pattern.init.apply($this, [$this].concat([options]));\n    }\n    return $this;\n};\n\nvar jqueryPlugin = function (pattern) {\n    return function (method, options) {\n        var $this = this;\n        if ($this.length === 0) {\n            return $this;\n        }\n        if (typeof method === \"object\") {\n            options = method;\n            method = undefined;\n        }\n        if (typeof pattern === \"function\") {\n            return singleBoundJQueryPlugin.call(this, pattern, method, options);\n        } else {\n            return pluralBoundJQueryPlugin.call(this, pattern, method, options);\n        }\n    };\n};\n\n// Is a given variable an object?\nfunction isObject(obj) {\n    var type = typeof obj;\n    return type === \"function\" || (type === \"object\" && !!obj);\n}\n\n// Extend a given object with all the properties in passed-in object(s).\nfunction extend(obj) {\n    if (!isObject(obj)) return obj;\n    var source, prop;\n    for (var i = 1, length = arguments.length; i < length; i++) {\n        source = arguments[i];\n        for (prop in source) {\n            if (hasOwnProperty.call(source, prop)) {\n                obj[prop] = source[prop];\n            }\n        }\n    }\n    return obj;\n}\n// END: Taken from Underscore.js until here.\n\nfunction findLabel(input) {\n    var $label;\n    for (\n        var label = input.parentNode;\n        label && label.nodeType !== 11;\n        label = label.parentNode\n    ) {\n        if (label.tagName === \"LABEL\") {\n            return label;\n        }\n    }\n    if (input.id) {\n        $label = $('label[for=\"' + input.id + '\"]');\n    }\n    if ($label && $label.length === 0 && input.form) {\n        $label = $('label[for=\"' + input.name + '\"]', input.form);\n    }\n    if ($label && $label.length) {\n        return $label[0];\n    } else {\n        return null;\n    }\n}\n\n// Taken from http://stackoverflow.com/questions/123999/how-to-tell-if-a-dom-element-is-visible-in-the-current-viewport\nfunction elementInViewport(el) {\n    var rect = el.getBoundingClientRect(),\n        docEl = document.documentElement,\n        vWidth = window.innerWidth || docEl.clientWidth,\n        vHeight = window.innerHeight || docEl.clientHeight;\n\n    if (rect.right < 0 || rect.bottom < 0 || rect.left > vWidth || rect.top > vHeight)\n        return false;\n    return true;\n}\n\n// Taken from http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex\nfunction escapeRegExp(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\n\n/**\n * Remove classes from a list of targets if they match a specific pattern.\n *\n * @param {Node, NodeList} targets: Dom Node or NodeList where the classes should be removed.\n * @param {string} classes: String matching classes to be removed.\n *                          You can add a \"*\" as wildcard to search for classes to be removed.\n *                          E.g. \"icon-*-alert\" to remove any of \"icon-1-alert icon-2-alert\".\n *\n * @returns {undefined}: This method directly operates on the targets.\n */\nfunction removeWildcardClass(targets, classes) {\n    targets = utils.ensureArray(targets);\n\n    if (classes.indexOf(\"*\") === -1) {\n        for (const target of targets) {\n            target.classList.remove(classes);\n        }\n    } else {\n        let matcher = classes.replace(/[\\-\\[\\]{}()+?.,\\\\\\^$|#\\s]/g, \"\\\\$&\");\n        matcher = matcher.replace(/[*]/g, \".*\");\n        matcher = new RegExp(\"^\" + matcher + \"$\");\n\n        for (const target of targets) {\n            const class_list = (target.getAttribute(\"class\") || \"\").split(/\\s+/);\n            if (!class_list.length) {\n                continue;\n            }\n            const ok = class_list.filter((it) => !matcher.test(it));\n            if (ok.length) {\n                target.setAttribute(\"class\", ok.join(\" \"));\n            } else {\n                target.removeAttribute(\"class\");\n            }\n        }\n    }\n}\n\nfunction hasValue(el) {\n    if (el.tagName === \"INPUT\") {\n        if (el.type === \"checkbox\" || el.type === \"radio\") {\n            return el.checked;\n        }\n        return el.value !== \"\";\n    }\n    if (el.tagName === \"SELECT\") {\n        return el.selectedIndex !== -1;\n    }\n    if (el.tagName === \"TEXTAREA\") {\n        return el.value !== \"\";\n    }\n    return false;\n}\n\nconst hideOrShow = (nodes, visible, options, pattern_name) => {\n    nodes = dom.toNodeArray(nodes);\n\n    const transitions = {\n        none: { hide: \"hide\", show: \"show\" },\n        fade: { hide: \"fadeOut\", show: \"fadeIn\" },\n        slide: { hide: \"slideUp\", show: \"slideDown\" },\n    };\n\n    const duration =\n        options.transition === \"css\" || options.transition === \"none\"\n            ? null\n            : options.effect.duration;\n\n    const on_complete = (el) => {\n        el.classList.remove(\"in-progress\");\n        el.classList.add(visible ? \"visible\" : \"hidden\");\n        $(el).trigger(\"pat-update\", {\n            pattern: pattern_name,\n            transition: \"complete\",\n        });\n    };\n\n    for (const el of nodes) {\n        el.classList.remove(\"visible\");\n        el.classList.remove(\"hidden\");\n        el.classList.remove(\"in-progress\");\n\n        if (duration) {\n            const t = transitions[options.transition];\n            el.classList.add(\"in-progress\");\n            $(el).trigger(\"pat-update\", {\n                pattern: pattern_name,\n                transition: \"start\",\n            });\n            $(el)[visible ? t.show : t.hide]({\n                duration: duration,\n                easing: options.effect.easing,\n                complete: () => on_complete(el),\n            });\n        } else {\n            if (options.transition !== \"css\") {\n                dom[visible ? \"show\" : \"hide\"](el);\n            }\n            on_complete(el);\n        }\n    }\n};\n\nfunction addURLQueryParameter(fullURL, param, value) {\n    /* Using a positive lookahead (?=\\=) to find the given parameter,\n     * preceded by a ? or &, and followed by a = with a value after\n     * than (using a non-greedy selector) and then followed by\n     * a & or the end of the string.\n     *\n     * Taken from http://stackoverflow.com/questions/7640270/adding-modify-query-string-get-variables-in-a-url-with-javascript\n     */\n    var val = new RegExp(\"(\\\\?|\\\\&)\" + param + \"=.*?(?=(&|$))\"),\n        parts = fullURL.toString().split(\"#\"),\n        url = parts[0],\n        hash = parts[1],\n        qstring = /\\?.+$/,\n        newURL = url;\n    // Check if the parameter exists\n    if (val.test(url)) {\n        // if it does, replace it, using the captured group\n        // to determine & or ? at the beginning\n        newURL = url.replace(val, \"$1\" + param + \"=\" + value);\n    } else if (qstring.test(url)) {\n        // otherwise, if there is a query string at all\n        // add the param to the end of it\n        newURL = url + \"&\" + param + \"=\" + value;\n    } else {\n        // if there's no query string, add one\n        newURL = url + \"?\" + param + \"=\" + value;\n    }\n    if (hash) {\n        newURL += \"#\" + hash;\n    }\n    return newURL;\n}\n\nfunction removeDuplicateObjects(objs) {\n    /* Given an array of objects, remove any duplicate objects which might\n     * be present.\n     */\n    const comparator = function (k, v) {\n        return this[k] === v;\n    };\n\n    return objs.reduce(function (list, next_obj) {\n        let is_duplicate = false;\n        for (const obj of list) {\n            is_duplicate =\n                Object.keys(obj).length === Object.keys(next_obj).length &&\n                Object.entries(obj).filter(\n                    (it) => !comparator.bind(next_obj)(it[0], it[1])\n                ).length === 0;\n        }\n        if (!is_duplicate) {\n            list.push(next_obj);\n        }\n        return list;\n    }, []);\n}\n\nfunction mergeStack(stack, length) {\n    /* Given a list of lists of objects (which for brevity we call a stack),\n     * return a list of objects where each object is the merge of all the\n     * corresponding original objects at that particular index.\n     *\n     * If a certain sub-list doesn't have an object at that particular\n     * index, the last object in that list is merged.\n     */\n    const results = [];\n    for (let i = 0; i < length; i++) {\n        results.push({});\n    }\n    for (const frame of stack) {\n        const frame_length = frame.length - 1;\n        for (let x = 0; x < length; x++) {\n            results[x] = $.extend(\n                results[x] || {},\n                frame[x > frame_length ? frame_length : x]\n            );\n        }\n    }\n    return results;\n}\n\nfunction isElementInViewport(el, partial = false, offset = 0) {\n    /* returns true if element is visible to the user ie. is in the viewport.\n     * Setting partial parameter to true, will only check if a part of the element is visible\n     * in the viewport, specifically that some part of that element is touching the top part\n     * of the viewport. This only applies to the vertical direction, ie. doesnt check partial\n     * visibility for horizontal scrolling\n     * some code taken from:\n     * http://stackoverflow.com/questions/123999/how-to-tell-if-a-dom-element-is-visible-in-the-current-viewport/7557433#7557433\n     */\n    if (el instanceof $) {\n        el = el[0];\n    }\n\n    const rec = el.getBoundingClientRect();\n    const rec_values = [rec.top, rec.bottom, rec.left, rec.right];\n\n    if (rec_values.every((val) => val === 0)) {\n        // if every property of rec is 0, the element is invisible;\n        return false;\n    } else if (partial) {\n        // when using getBoundingClientRect() (in the vertical case)\n        // negative means above top of viewport, positive means below top of viewport\n        // therefore for part of the element to be touching or crossing the top of the viewport\n        // rec.top must <= 0 and rec.bottom must >= 0\n        // an optional tolerance offset can be added for when the desired element is not exactly\n        // toucing the top of the viewport but needs to be considered as touching.\n        return (\n            rec.top <= 0 + offset && rec.bottom >= 0 + offset\n            //(rec.top >= 0+offset && rec.top <= window.innerHeight) // this checks if the element\n            // touches bottom part of viewport\n            // XXX do we want to include a check for the padding of an element?\n            // using window.getComputedStyle(target).paddingTop\n        );\n    } else {\n        // this will return true if the entire element is completely in the viewport\n        return (\n            rec.top >= 0 &&\n            rec.left >= 0 &&\n            rec.bottom <=\n                (window.innerHeight || document.documentElement.clientHeight) &&\n            rec.right <= (window.innerWidth || document.documentElement.clientWidth)\n        );\n    }\n}\n\n/* parseTime - Parse a duration from a string and return the parsed time in milliseconds.\n *\n * @param {String} time - A duration/time string like ``1ms``, ``1s`` or ``1m``.\n *\n * @returns {Number} - A integer which represents the parsed time in milliseconds.\n */\nfunction parseTime(time) {\n    var m = /^(\\d+(?:\\.\\d+)?)\\s*(\\w*)/.exec(time);\n    if (!m) {\n        throw new Error(\"Invalid time\");\n    }\n    var amount = parseFloat(m[1]);\n    switch (m[2]) {\n        case \"s\":\n            return Math.round(amount * 1000);\n        case \"m\":\n            return Math.round(amount * 1000 * 60);\n        case \"ms\":\n        default:\n            return Math.round(amount);\n    }\n}\n\n// Return a jQuery object with elements related to an input element.\nfunction findRelatives(el) {\n    var $el = $(el),\n        $relatives = $(el),\n        $label = $();\n\n    $relatives = $relatives.add($el.closest(\"label\"));\n    $relatives = $relatives.add($el.closest(\"fieldset\"));\n\n    if (el.id) $label = $(\"label[for='\" + el.id + \"']\");\n    if (!$label.length) {\n        var $form = $el.closest(\"form\");\n        if (!$form.length) $form = $(document.body);\n        $label = $form.find(\"label[for='\" + el.name + \"']\");\n    }\n    $relatives = $relatives.add($label);\n    return $relatives;\n}\n\nfunction get_bounds(el) {\n    // Return bounds of an element with it's values rounded and converted to ints.\n    const bounds = el.getBoundingClientRect();\n    return {\n        x: parseInt(Math.round(bounds.x), 10) || 0,\n        y: parseInt(Math.round(bounds.y), 10) || 0,\n        top: parseInt(Math.round(bounds.top), 10) || 0,\n        bottom: parseInt(Math.round(bounds.bottom), 10) || 0,\n        left: parseInt(Math.round(bounds.left), 10) || 0,\n        right: parseInt(Math.round(bounds.right), 10) || 0,\n        width: parseInt(Math.round(bounds.width), 10) || 0,\n        height: parseInt(Math.round(bounds.height), 10) || 0,\n    };\n}\n\nfunction checkInputSupport(type, invalid_value) {\n    /* Check input type support.\n     *  See: https://stackoverflow.com/a/10199306/1337474\n     */\n    let support = false;\n    const input = document.createElement(\"input\");\n    input.setAttribute(\"type\", type);\n    support = input.type == type;\n\n    if (invalid_value !== undefined) {\n        // Check for input type UI support\n        input.setAttribute(\"value\", invalid_value);\n        support = input.value !== invalid_value;\n    }\n    return support;\n}\n\nconst checkCSSFeature = (attribute, value, tag = \"div\") => {\n    /* Check for browser support of specific CSS feature.\n     */\n    tag = document.createElement(tag);\n    let supported = tag.style[attribute] !== undefined;\n    if (supported && value !== undefined) {\n        tag.style[attribute] = value;\n        supported = tag.style[attribute] === value;\n    }\n    return supported;\n};\n\nconst animation_frame = () => {\n    // Return promise to await next repaint cycle\n    // Use it in your async function like so: ``await utils.animation_frame()``\n    // From: http://www.albertlobo.com/fractals/async-await-requestanimationframe-buddhabrot\n    return new Promise(window.requestAnimationFrame);\n};\n\nconst timeout = (ms) => {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n};\n\nconst debounce = (func, ms, timer = { timer: null }) => {\n    // Returns a function, that, as long as it continues to be invoked, will not\n    // be triggered. The function will be called after it stops being called for\n    // N milliseconds.\n    // From: https://underscorejs.org/#debounce\n    //\n    // Make sure to initialize ``debounce`` only once per to-be-debounced\n    // function to not reinitialize the timer each time and debounce not being\n    // able to cancel previouse runs.\n    //\n    // Pass a module-global timer as an object ``{ timer: null }`` if you want\n    // to also cancel debounced functions from other pattern-invocations.\n    //\n    return function () {\n        clearTimeout(timer.timer);\n        const args = arguments;\n        timer.timer = setTimeout(() => func.apply(this, args), ms);\n    };\n};\n\nconst isIE = () => {\n    // See: https://stackoverflow.com/a/9851769/1337474\n    // Internet Explorer 6-11\n    return /*@cc_on!@*/ false || !!document.documentMode;\n};\n\nconst jqToNode = (el) => {\n    // Return a DOM node if a jQuery node was passed.\n    if (el.jquery) {\n        el = el[0];\n    }\n    return el;\n};\n\n/**\n * Always return an iterable object.\n *\n * @param {any} it: The object which needs to be wrapped in an array or returned as is if it is iterable.\n * @param {boolean} force_array: If the object is iterable but not an Array, convert it to an array (e.g. For jQuery items or NodeList objects).\n *\n * @returns {Array}: Returns the object wrapped in an Array, expanded to an Array or as-is if it is already iterable.\n */\nconst ensureArray = (it, force_array) => {\n    // Ensure to return always an array\n    const array_like = !!(\n        NodeList.prototype.isPrototypeOf(it) || // eslint-disable-line no-prototype-builtins\n        Array.isArray(it) ||\n        it.jquery\n    );\n    return array_like ? (force_array ? [...it] : it) : [it];\n};\n\nconst localized_isodate = (date) => {\n    // Return a iso date (date only) in the current timezone instead of a\n    // UTC ISO 8601 date+time component which toISOString returns.\n\n    const day = date.getDate().toString().padStart(2, \"0\");\n    const month = (date.getMonth() + 1).toString().padStart(2, \"0\");\n    const year = date.getFullYear().toString();\n\n    return `${year}-${month}-${day}`;\n};\n\n/**\n * Replace HTML reserved characters with html entities to add HTML for user\n * editing to e.g. a textarea or a contenteditable.\n *\n * See: https://developer.mozilla.org/en-US/docs/Glossary/Entity#reserved_characters\n *\n * @param {string} html - The HTML string to encode.\n *\n * @returns {string} - Returns the escaped html string:\n *                     ``&`` will be replaced with ``&amp;``.\n *                     ``<`` will be repalced with ``&lt;``,\n *                     ``>`` will be replaced with ``&gt;``,\n *                     ``\"`` will be replaced with ``&quot;``.\n */\nconst escape_html = (html) => {\n    return (html || \"\")\n        .replace(/&/g, \"&amp;\") // needs to be first!\n        .replace(/</g, \"&lt;\")\n        .replace(/>/g, \"&gt;\")\n        .replace(/\"/g, \"&quot;\");\n};\n\n/**\n * Return unescaped, raw HTML from an escaped HTML  string.\n *\n * See: https://developer.mozilla.org/en-US/docs/Glossary/Entity#reserved_characters\n *\n * @param {string} escaped_html - The HTML string to decode.\n *\n * @returns {string} - Returns the escaped html string:\n *                     ``&amp;`` will be replaced with ``&``,\n *                     ``&lt;`` will be repalced with ``<``,\n *                     ``&gt;`` will be replaced with ``>``,\n *                     ``&quot;`` will be replaced with ``\"``.\n */\nconst unescape_html = (escaped_html) => {\n    return (escaped_html || \"\")\n        .replace(/&amp;/g, \"&\")\n        .replace(/&lt;/g, \"<\")\n        .replace(/&gt;/g, \">\")\n        .replace(/&quot;/g, '\"');\n};\n\n/**\n * Return true, if the given value is a valid ISO 8601 date/time string with or without an optional time component.\n *\n * @param {String} value - The date/time value to be checked.\n * @param {Boolean} [optional_time=false] - True, if time component is optional.\n * @return {Boolean} - True, if the given value is a valid Date string. False if not.\n */\nconst is_iso_date_time = (value, optional_time = false) => {\n    const re_date_time = optional_time\n        ? /^\\d{4}-[01]\\d-[0-3]\\d(T[0-2]\\d:[0-5]\\d)?$/\n        : /^\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d$/;\n    return re_date_time.test(value);\n};\n\n/**\n * Return true, if the given value is a valid ISO 8601 date string and without a time component.\n *\n * @param {String} value - The date value to be checked.\n * @return {Boolean} - True, if the given value is a valid ISO 8601 date string without a time component. False if not.\n */\nconst is_iso_date = (value) => {\n    const re_date_time = /^\\d{4}-[01]\\d-[0-3]\\d$/;\n    return re_date_time.test(value);\n};\n\n/**\n * Return the number of days between two dates.\n * Based on: https://stackoverflow.com/a/15289883/1337474\n *\n * @param {Date} date_1 - First date to compare. We will substract date_2 from date_1.\n * @param {Date} date_2 - Second date to compare.\n * @return {Number} - The number of days between the two dates.\n */\nconst date_diff = (date_1, date_2) => {\n    // Discard the time and time-zone information.\n    const utc_1 = Date.UTC(date_1.getFullYear(), date_1.getMonth(), date_1.getDate());\n    const utc_2 = Date.UTC(date_2.getFullYear(), date_2.getMonth(), date_2.getDate());\n\n    return Math.floor((utc_1 - utc_2) / _MS_PER_DAY);\n};\n\nvar utils = {\n    // pattern pimping - own module?\n    jqueryPlugin: jqueryPlugin,\n    escapeRegExp: escapeRegExp,\n    isObject: isObject,\n    extend: extend,\n    findLabel: findLabel,\n    elementInViewport: elementInViewport,\n    removeWildcardClass: removeWildcardClass,\n    hideOrShow: hideOrShow,\n    addURLQueryParameter: addURLQueryParameter,\n    removeDuplicateObjects: removeDuplicateObjects,\n    mergeStack: mergeStack,\n    isElementInViewport: isElementInViewport,\n    hasValue: hasValue,\n    parseTime: parseTime,\n    findRelatives: findRelatives,\n    get_bounds: get_bounds,\n    checkInputSupport: checkInputSupport,\n    checkCSSFeature: checkCSSFeature,\n    animation_frame: animation_frame,\n    timeout: timeout,\n    debounce: debounce,\n    isIE: isIE,\n    jqToNode: jqToNode,\n    ensureArray: ensureArray,\n    localized_isodate: localized_isodate,\n    escape_html: escape_html,\n    unescape_html: unescape_html,\n    is_iso_date_time: is_iso_date_time,\n    is_iso_date: is_iso_date,\n    date_diff: date_diff,\n    getCSSValue: dom.get_css_value, // BBB: moved to dom. TODO: Remove in upcoming version.\n};\n\nexport default utils;\n","/**\n * Patterns ajax - AJAX injection for forms and anchors\n *\n * Copyright 2012-2013 Florian Friesdorf\n * Copyright 2012-2013 Marko Durkovic\n */\nimport $ from \"jquery\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\n\nconst log = logging.getLogger(\"pat.ajax\");\n\nexport const parser = new Parser(\"ajax\");\nparser.addArgument(\"accept\", \"text/html\");\nparser.addArgument(\"url\", function ($el) {\n    return (\n        $el.is(\"a\") ? $el.attr(\"href\") : $el.is(\"form\") ? $el.attr(\"action\") : \"\"\n    ).split(\"#\")[0];\n});\nparser.addArgument(\"browser-cache\", \"no-cache\", [\"cache\", \"no-cache\"]); // Cache ajax requests\n\nconst xhrCount = {};\nxhrCount.get = function (a) {\n    return this[a] !== undefined ? this[a] : 0;\n};\nxhrCount.inc = function (a) {\n    this[a] = this.get(a) + 1;\n    return this.get(a);\n};\n\nconst _ = {\n    name: \"ajax\",\n    trigger: \".pat-ajax\",\n    parser: parser,\n    init($el) {\n        $el.off(\".pat-ajax\");\n        $el.filter(\"a\").on(\"click.pat-ajax\", _.onTriggerEvents);\n        $el.filter(\"form\")\n            .on(\"submit.pat-ajax\", _.onTriggerEvents)\n            .on(\"click.pat-ajax\", \"[type=submit]\", _.onClickSubmit);\n        $el.filter(\":not(form,a)\").each(function () {\n            log.warn(\"Unsupported element:\", this);\n        });\n        return $el;\n    },\n    destroy($el) {\n        $el.off(\".pat-ajax\");\n    },\n    onClickSubmit(event) {\n        const el = event.target;\n        const form = el.closest(\"form\");\n        const data = {};\n        if (el.name) {\n            data[el.name] = el.value;\n        }\n        $(form).data(\"pat-ajax.clicked-data\", data);\n    },\n    onTriggerEvents(event) {\n        if (event) {\n            event.preventDefault();\n        }\n        _.request($(this));\n    },\n    request($el, opts) {\n        return $el.each(function () {\n            _._request($(this), opts);\n        });\n    },\n    _request($el, opts) {\n        const cfg = _.parser.parse($el, opts);\n        const onError = function (jqxhr, status, error) {\n            // error can also stem from a javascript\n            // exception, not only errors described in the\n            // jqxhr.\n            log.error(\"load error for \" + cfg.url + \":\", error, jqxhr);\n            $el.trigger({\n                type: \"pat-ajax-error\",\n                jqxhr: jqxhr,\n            });\n        };\n        const seqNumber = xhrCount.inc(cfg.url);\n        const onSuccess = function (data, status, jqxhr) {\n            log.debug(\"success: jqxhr:\", jqxhr);\n            if (seqNumber === xhrCount.get(cfg.url)) {\n                // if this url is requested multiple time, only return the last result\n                $el.trigger({\n                    type: \"pat-ajax-success\",\n                    jqxhr: jqxhr,\n                });\n            } else {\n                // ignore\n            }\n        };\n        const temp = $el.data(\"pat-ajax.clicked-data\");\n        const clickedData = temp ? $.param(temp) : \"\";\n        const args = {\n            context: $el,\n            data: [$el.serialize(), clickedData].filter(Boolean).join(\"&\"),\n            headers: {},\n            url: cfg.url,\n            method: $el.attr(\"method\") ? $el.attr(\"method\") : \"GET\",\n            cache: cfg.browserCache === \"cache\" ? true : false,\n        };\n\n        if (cfg.accept) {\n            args.headers.Accept = cfg.accept;\n        }\n\n        if (\n            $el.is(\"form\") &&\n            $el.attr(\"method\") &&\n            $el.attr(\"method\").toUpperCase() == \"POST\"\n        ) {\n            const formdata = new FormData($el[0]);\n            for (const key in temp) {\n                formdata.append(key, temp[key]);\n            }\n            args[\"method\"] = \"POST\";\n            args[\"data\"] = formdata;\n            args[\"cache\"] = false;\n            args[\"contentType\"] = false;\n            args[\"processData\"] = false;\n            args[\"type\"] = \"POST\";\n        }\n\n        $el.removeData(\"pat-ajax.clicked-data\");\n        log.debug(\"request:\", args, $el[0]);\n\n        // Make it happen\n        const ajax_deferred = $.ajax(args);\n\n        if (ajax_deferred) ajax_deferred.done(onSuccess).fail(onError);\n    },\n};\n\nregistry.register(_);\n\nexport default _;\n","import Base from \"../../core/base\";\nimport events from \"../../core/events\";\nimport utils from \"../../core/utils\";\n\nexport default Base.extend({\n    name: \"close-panel\",\n    trigger: \".close-panel\",\n\n    init() {\n        // Close panel support for dialog panels\n        // Other modals are handled in pat-modal.\n        const dialog_panel = this.el.closest(\"dialog\");\n        if (dialog_panel) {\n            events.add_event_listener(\n                dialog_panel,\n                \"close-panel\",\n                \"close-panel--dialog\",\n                () => {\n                    dialog_panel.close();\n                }\n            );\n        }\n\n        this.el.addEventListener(\"click\", async (e) => {\n            await utils.timeout(0); // Wait for other patterns, like pat-validation.\n\n            if (\n                e.target.matches(\"[type=submit], button:not([type=button])\") &&\n                this.el.closest(\"form\")?.checkValidity() === false\n            ) {\n                // Prevent closing an invalid form when submitting.\n                return;\n            }\n\n            this.el.dispatchEvent(\n                new Event(\"close-panel\", { bubbles: true, cancelable: true })\n            );\n        });\n    },\n});\n","/* pat-date-picker  - Polyfill for input type=date */\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"date-picker\");\n\nexport const parser = new Parser(\"date-picker\");\nparser.addArgument(\"behavior\", \"styled\", [\"native\", \"styled\"]);\nparser.addArgument(\"week-numbers\", [], [\"show\", \"hide\"]);\nparser.addArgument(\"i18n\"); // URL pointing to JSON resource with i18n values\nparser.addArgument(\"first-day\", 0);\nparser.addArgument(\"after\");\nparser.addArgument(\"offset-days\", 0);\n\nparser.add_argument(\"output-format\", null);\nparser.add_argument(\"locale\", null);\n\nparser.addAlias(\"behaviour\", \"behavior\");\n\n/* JSON format for i18n\n * { \"previousMonth\": \"Previous Month\",\n *   \"nextMonth\"    : \"Next Month\",\n *   \"months\"       : [\"January\",\"February\",\"March\",\"April\",\"May\",\"June\",\"July\",\"August\",\"September\",\"October\",\"November\",\"December\"],\n *   \"weekdays\"     : [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"],\n *   \"weekdaysShort\": [\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"]\n * } */\n\nexport default Base.extend({\n    name: \"date-picker\",\n    trigger: \".pat-date-picker\",\n    parser: parser,\n    format: \"YYYY-MM-DD\",\n\n    async init() {\n        const el = this.el;\n        const disabled = this.el.disabled;\n\n        //TODO: make parser with options extend missing options.\n        //this.options = parser.parse(el, opts);\n        this.options = $.extend(parser.parse(el), this.options);\n\n        if (!disabled && this.options.after) {\n            // Set the date depending on another date which must be ``offset-days``\n            // BEFORE this date. Only set it, if the other date is AFTER this\n            // date.\n            const befores = document.querySelectorAll(this.options.after);\n            for (const b_el of befores) {\n                b_el.addEventListener(\"change\", (e) => {\n                    let b_date = e.target.value; // the \"before-date\"\n                    b_date = b_date ? new Date(b_date) : null;\n                    if (!b_date) {\n                        return;\n                    }\n                    let a_date = this.el.value; // the \"after-date\"\n                    a_date = a_date ? new Date(a_date) : null;\n                    if (!a_date || a_date < b_date) {\n                        const offset = this.options.offsetDays || 0;\n                        b_date.setDate(b_date.getDate() + offset);\n                        this.el.value = b_date.toISOString().substring(0, 10);\n                        this.dispatch_change_event();\n                    }\n                });\n            }\n        }\n\n        let display_el;\n        if (this.options.behavior === \"styled\") {\n            dom.hide(el); // hide input, but keep active (e.g. for validation)\n\n            display_el = document.createElement(\"time\");\n            display_el.setAttribute(\"class\", \"output-field\");\n            display_el.setAttribute(\"datetime\", el.value);\n            if (disabled) {\n                display_el.classList.add(\"disabled\");\n            }\n            el.insertAdjacentElement(\"beforebegin\", display_el);\n\n            // Disable click on label, as this invokes a click on the invisible\n            // input field which opens the calendar in Firefox and masks a\n            // click on display_el on Chrome.\n            const label = display_el.closest(\"label\");\n            if (label) {\n                events.add_event_listener(\n                    label,\n                    \"click\",\n                    \"pat-date-picker--label\",\n                    (e) => {\n                        e.preventDefault();\n                    }\n                );\n            }\n\n            let display_el_pat;\n            if (this.options.outputFormat) {\n                const PatDisplayTime = (await import(\"../display-time/display-time\")).default; // prettier-ignore\n                const display_time_config = { format: this.format };\n                if (this.options.outputFormat) {\n                    display_time_config[\"output-format\"] = this.options.outputFormat;\n                }\n                if (this.options.locale) {\n                    display_time_config.locale = this.options.locale;\n                }\n                display_el_pat = new PatDisplayTime(display_el, display_time_config);\n            } else {\n                display_el.textContent = el.value;\n            }\n\n            $(display_el).on(\"init.display-time.patterns\", () =>\n                this.add_clear_button(display_el)\n            );\n\n            this.el.addEventListener(\"change\", () => {\n                display_el.setAttribute(\"datetime\", this.el.value);\n                if (display_el_pat) {\n                    display_el_pat.format();\n                } else {\n                    display_el.textContent = this.el.value;\n                }\n                this.add_clear_button(display_el);\n            });\n\n            if (disabled) {\n                // nothing else to do here...\n                return;\n            }\n        } else if (disabled) {\n            return;\n        } else if (utils.checkInputSupport(\"date\", \"invalid date\")) {\n            // behavior native with native support.\n            return;\n        } else if (el.getAttribute(\"type\") === \"date\") {\n            // behavior native but no native support.\n            // Fallback JS date picker with a text input field.\n            el.setAttribute(\"type\", \"text\");\n        }\n\n        if (window.__patternslib_import_styles) {\n            import(\"./_date-picker.scss\");\n        }\n        const Pikaday = (await import(\"pikaday\")).default;\n\n        const config = {\n            field: el,\n            trigger: display_el || el,\n            format: this.format,\n            firstDay: this.options.firstDay,\n            showWeekNumber: this.options.weekNumbers === \"show\",\n            onSelect: () => this.dispatch_change_event(),\n            onClose: () => {\n                if (this.options.behavior === \"styled\") {\n                    // blur the input field so that pat-validate can kick in when\n                    // nothing was selected.\n                    el.dispatchEvent(events.blur_event());\n                }\n            },\n        };\n\n        if (el.getAttribute(\"min\")) {\n            config.minDate = new Date(el.getAttribute(\"min\"));\n        }\n        if (el.getAttribute(\"max\")) {\n            config.maxDate = new Date(el.getAttribute(\"max\"));\n        }\n\n        if (this.options.i18n) {\n            try {\n                const response = await fetch(this.options.i18n);\n                config.i18n = await response.json();\n            } catch {\n                log.error(`date-picker could not load i18n for ${this.options.i18n}`);\n            }\n        }\n        this.pikaday = new Pikaday(config);\n    },\n\n    add_clear_button(el_append_to) {\n        if (!this.el.disabled && !this.el.required && this.el.value) {\n            // Add clear button\n            const clear_button = document.createElement(\"span\");\n            clear_button.setAttribute(\"class\", \"cancel-button\");\n            clear_button.addEventListener(\"click\", (e) => {\n                e.stopPropagation();\n                this.el.value = null;\n                this.dispatch_change_event();\n            });\n            el_append_to.appendChild(clear_button);\n        }\n    },\n\n    dispatch_change_event() {\n        const event = new Event(\"change\", {\n            bubbles: true,\n            cancelable: true,\n        });\n        // Set ``firedBy` to prevent pikaday to call it's own handler and land\n        // in an infinite loop.\n        event.firedBy = this.pikaday;\n        this.el.dispatchEvent(event);\n\n        // Also trigger input-change\n        $(this.el).trigger(\"input-change\");\n        $(this.el.form).trigger(\"input-change\");\n    },\n});\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\n\n// Lazy loading modules.\nlet Moment;\n\nconst log = logging.getLogger(\"pat-display-time\");\n\nexport const parser = new Parser(\"display-time\");\n// input datetime options\nparser.add_argument(\"format\", \"\");\nparser.add_argument(\"locale\", null);\nparser.add_argument(\"strict\", false);\n// output options\nparser.add_argument(\"from-now\", false);\nparser.add_argument(\"no-suffix\", false);\nparser.add_argument(\"output-format\", null);\n\nexport default Base.extend({\n    name: \"display-time\",\n    trigger: \".pat-display-time\",\n\n    async init() {\n        Moment = (await import(\"moment\")).default;\n\n        this.options = parser.parse(this.el, this.options);\n\n        let lang = this.options.locale || dom.acquire_attribute(this.el, \"lang\") || \"en\";\n        // we don't support any country-specific language variants, always use first 2 letters\n        lang = lang.substr(0, 2).toLowerCase();\n        try {\n            await import(`moment/locale/${lang}.js`);\n            Moment.locale(lang);\n            this.lang = lang;\n        } catch {\n            Moment.locale(\"en\");\n            this.lang = \"en\";\n        }\n        log.debug(`Moment.js language used: ${lang}.`);\n        this.format();\n    },\n\n    format() {\n        const datetime = this.el.getAttribute(\"datetime\");\n        let out = \"\";\n        if (datetime) {\n            const date = Moment(datetime, this.options.format, this.options.strict);\n            if (this.options.fromNow === true) {\n                if (utils.is_iso_date(datetime)) {\n                    // date-only case.\n                    const rtf = new Intl.RelativeTimeFormat(this.lang, {\n                        numeric: \"auto\",\n                    });\n                    const date_diff = utils.date_diff(date.toDate(), new Date());\n                    out = date.calendar(null, {\n                        // when the date is closer, specify custom values\n                        lastWeek: `[${rtf.format(date_diff, \"day\")}]`, // translates to \"x days ago\"\n                        lastDay: `[${rtf.format(-1, \"day\")}]`, // translates to \"yesterday\"\n                        sameDay: `[${rtf.format(0, \"day\")}]`, // translates to \"today\"\n                        nextDay: `[${rtf.format(1, \"day\")}]`, // translates to \"tomorrow\"\n                        nextWeek: \"dddd\", // translates to week day name\n                        // otherwise, just use Intl.RelativeTimeFormat.\n                        sameElse: () => {\n                            return `[${rtf.format(date_diff, \"day\")}]`;\n                        },\n                    });\n                } else {\n                    // datetime case.\n                    out = date.fromNow(this.options.noSuffix);\n                }\n            } else {\n                out = date.format(this.options.outputFormat || undefined);\n            }\n        }\n        this.el.textContent = out;\n    },\n});\n","import \"../../core/jquery-ext\"; // for :scrollable for autoLoading-visible\nimport $ from \"jquery\";\nimport ajax from \"../ajax/ajax\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.inject\");\n//log.setLevel(logging.Level.DEBUG);\n\nconst TEXT_NODE = 3;\nconst COMMENT_NODE = 8;\n\nexport const parser = new Parser(\"inject\");\nparser.addArgument(\"default-selector\");\nparser.addArgument(\"target\");\nparser.addArgument(\"data-type\", \"html\");\nparser.addArgument(\"next-href\");\nparser.addArgument(\"source\");\nparser.addArgument(\"trigger\", \"default\", [\n    \"default\",\n    \"autoload\",\n    \"autoload-visible\",\n    \"idle\",\n]);\nparser.addArgument(\"delay\"); // only used in autoload\nparser.addArgument(\"browser-cache\", \"no-cache\", [\"cache\", \"no-cache\"]); // Cache ajax requests. Pass to pat-ajax.\nparser.addArgument(\"confirm\", \"class\", [\"never\", \"always\", \"form-data\", \"class\"]);\nparser.addArgument(\"confirm-message\", \"Are you sure you want to leave this page?\");\nparser.addArgument(\"hooks\", [], [\"raptor\"], true); // After injection, pat-inject will trigger an event for each hook: pat-inject-hook-$(hook)\nparser.addArgument(\"loading-class\", \"injecting\"); // Add a class to the target while content is still loading.\nparser.addArgument(\"executing-class\", \"executing\"); // Add a class to the element while content is still loading.\nparser.addArgument(\"executed-class\", \"executed\"); // Add a class to the element when content is loaded.\nparser.addArgument(\"class\"); // Add a class to the injected content.\nparser.addArgument(\"history\", \"none\", [\"none\", \"record\"]);\nparser.addArgument(\"push-marker\");\nparser.addArgument(\"scroll\");\n// XXX: this should not be here but the parser would bail on\n// unknown parameters and expand/collapsible need to pass the url\n// to us\nparser.addArgument(\"url\");\n\nconst inject = {\n    name: \"inject\",\n    trigger:\n        \".raptor-ui .ui-button.pat-inject, a.pat-inject, form.pat-inject, .pat-subform.pat-inject\",\n    parser: parser,\n\n    init($el, opts) {\n        const cfgs = this.extractConfig($el, opts);\n        if (cfgs.some((e) => e.history === \"record\") && !(\"pushState\" in history)) {\n            // if the injection shall add a history entry and HTML5 pushState\n            // is missing, then don't initialize the injection.\n            return $el;\n        }\n        $el.data(\"pat-inject\", cfgs);\n\n        if (cfgs[0].nextHref && cfgs[0].nextHref.indexOf(\"#\") === 0) {\n            // In case the next href is an anchor, and it already\n            // exists in the page, we do not activate the injection\n            // but instead just change the anchors href.\n\n            // XXX: This is used in only one project for linked\n            // fullcalendars, it's sanity is wonky and we should\n            // probably solve it differently.\n            if ($el.is(\"a\") && $(cfgs[0].nextHref).length > 0) {\n                log.debug(\n                    \"Skipping as next href is anchor, which already exists\",\n                    cfgs[0].nextHref\n                );\n                // XXX: reconsider how the injection enters exhausted state\n                return $el.attr({\n                    href: (window.location.href.split(\"#\")[0] || \"\") + cfgs[0].nextHref,\n                });\n            }\n        }\n        if (cfgs[0].pushMarker) {\n            $(\"body\").on(\"push\", (event, data) => {\n                log.debug(\"received push message: \" + data);\n                if (data == cfgs[0].pushMarker) {\n                    log.debug(\"re-injecting \" + data);\n                    this.onTrigger({ currentTarget: $el[0] });\n                }\n            });\n        }\n        if (cfgs[0].idleTrigger) {\n            this._initIdleTrigger($el, cfgs[0].idleTrigger);\n        } else {\n            switch (cfgs[0].trigger) {\n                case \"default\":\n                    cfgs.forEach((cfg) => {\n                        if (cfg.delay) {\n                            cfg.processDelay = cfg.delay;\n                        }\n                    });\n                    // setup event handlers\n                    if ($el.is(\"form\")) {\n                        $el.on(\"submit.pat-inject\", this.onTrigger.bind(this))\n                            .on(\"click.pat-inject\", \"[type=submit]\", ajax.onClickSubmit)\n                            .on(\n                                \"click.pat-inject\",\n                                \"[type=submit][formaction], [type=image][formaction]\",\n                                this.onFormActionSubmit.bind(this)\n                            );\n                    } else if ($el.is(\".pat-subform\")) {\n                        log.debug(\"Initializing subform with injection\");\n                    } else {\n                        $el.on(\"click.pat-inject\", this.onTrigger.bind(this));\n                    }\n                    break;\n                case \"autoload\":\n                    if (!cfgs[0].delay) {\n                        this.onTrigger({ currentTarget: $el[0] });\n                    } else {\n                        // generate UID\n                        const uid = Math.random().toString(36);\n                        $el.attr(\"data-pat-inject-uid\", uid);\n\n                        // function to trigger the autoload and mark as triggered\n                        const delayed_trigger = (uid_) => {\n                            // Check if the element has been removed from the dom\n                            const still_there = $(\n                                \"[data-pat-inject-uid='\" + uid_ + \"']\"\n                            );\n                            if (still_there.length == 0) return false;\n\n                            $el.data(\"pat-inject-autoloaded\", true);\n                            this.onTrigger({ currentTarget: $el[0] });\n                            return true;\n                        };\n                        window.setTimeout(\n                            delayed_trigger.bind(null, uid),\n                            cfgs[0].delay\n                        );\n                    }\n                    break;\n                case \"autoload-visible\":\n                    this._initAutoloadVisible($el, cfgs);\n                    break;\n                case \"idle\":\n                    this._initIdleTrigger($el, cfgs[0].delay);\n                    break;\n            }\n        }\n\n        log.debug(\"initialised:\", $el);\n        return $el;\n    },\n\n    destroy($el) {\n        $el.off(\".pat-inject\");\n        $el.data(\"pat-inject\", null);\n        return $el;\n    },\n\n    onTrigger(e) {\n        /* Injection has been triggered, either via form submission or a\n         * link has been clicked.\n         */\n        const $el = $(e.currentTarget);\n        const cfgs = $el.data(\"pat-inject\");\n        if ($el.is(\"form\")) {\n            $(cfgs).each((i, v) => {\n                v.params = $.param($el.serializeArray());\n            });\n        }\n        e.preventDefault && e.preventDefault();\n        $el.trigger(\"patterns-inject-triggered\");\n        this.execute(cfgs, $el);\n    },\n\n    onFormActionSubmit(e) {\n        ajax.onClickSubmit(e); // make sure the submitting button is sent with the form\n\n        const $button = $(e.target);\n        const formaction = $button.attr(\"formaction\");\n        const $form = $button.parents(\".pat-inject\").first();\n        const opts = {\n            url: formaction,\n        };\n        const $cfg_node = $button.closest(\"[data-pat-inject]\");\n        const cfgs = this.extractConfig($cfg_node, opts);\n\n        $(cfgs).each((i, v) => {\n            v.params = $.param($form.serializeArray());\n        });\n\n        e.preventDefault();\n        $form.trigger(\"patterns-inject-triggered\");\n        this.execute(cfgs, $form);\n    },\n\n    submitSubform($sub) {\n        /* This method is called from pat-subform\n         */\n        const $el = $sub.parents(\"form\");\n        const cfgs = $sub.data(\"pat-inject\");\n\n        // store the params of the subform in the config, to be used by history\n        $(cfgs).each((i, v) => {\n            v.params = $.param($sub.serializeArray());\n        });\n\n        try {\n            $el.trigger(\"patterns-inject-triggered\");\n        } catch (e) {\n            log.error(\"patterns-inject-triggered\", e);\n        }\n        this.execute(cfgs, $el);\n    },\n\n    extractConfig($el, opts) {\n        opts = $.extend({}, opts);\n\n        const cfgs = parser.parse($el, opts, true);\n        cfgs.forEach((cfg) => {\n            cfg.$context = $el;\n            // opts and cfg have priority, fall back to href/action\n            cfg.url =\n                opts.url ||\n                cfg.url ||\n                $el.attr(\"href\") ||\n                $el.attr(\"action\") ||\n                $el.parents(\"form\").attr(\"action\") ||\n                \"\";\n\n            // separate selector from url\n            const urlparts = cfg.url.split(\"#\");\n            cfg.url = urlparts[0];\n\n            if (urlparts.length > 2) {\n                log.warn(\"Ignoring additional source ids:\", urlparts.slice(2));\n            }\n\n            if (!cfg.defaultSelector) {\n                // if no selector, check for selector as part of original url\n                cfg.defaultSelector = (urlparts[1] && \"#\" + urlparts[1]) || \"body\";\n            }\n            if (cfg.delay) {\n                try {\n                    cfg.delay = utils.parseTime(cfg.delay);\n                } catch (e) {\n                    log.warn(\"Invalid delay value: \", cfg.delay);\n                    cfg.delay = null;\n                }\n            }\n            cfg.processDelay = 0;\n        });\n        return cfgs;\n    },\n\n    elementIsDirty(m) {\n        /* Check whether the passed in form element contains a value.\n         */\n        const data = $.map(m.find(\":input:not(select)\"), (i) => {\n            const val = $(i).val();\n            return Boolean(val) && val !== $(i).attr(\"placeholder\");\n        });\n        return $.inArray(true, data) !== -1;\n    },\n\n    askForConfirmation(cfgs) {\n        /* If configured to do so, show a confirmation dialog to the user.\n         * This is done before attempting to perform injection.\n         */\n        let should_confirm = false;\n        let message;\n\n        for (const cfg of cfgs) {\n            let _confirm = false;\n            if (cfg.confirm == \"always\") {\n                _confirm = true;\n            } else if (\n                cfg.confirm === \"form-data\" &&\n                cfg.target &&\n                cfg.target !== \"none\"\n            ) {\n                _confirm = this.elementIsDirty(cfg.$target);\n            } else if (cfg.confirm === \"class\" && cfg.target && cfg.target !== \"none\") {\n                _confirm = cfg.$target.hasClass(\"is-dirty\");\n            }\n            if (_confirm) {\n                should_confirm = true;\n                message = cfg.confirmMessage;\n            }\n        }\n        if (should_confirm) {\n            if (!window.confirm(message)) {\n                return false;\n            }\n        }\n        return true;\n    },\n\n    ensureTarget(cfg) {\n        /* Make sure that a target element exists and that it's assigned to\n         * cfg.$target.\n         */\n        // make sure target exist\n        if (cfg.target === \"none\") {\n            // special case, we don't want to inject anything\n            return true;\n        }\n        cfg.$target =\n            cfg.$target || (cfg.target === \"self\" ? cfg.$context : $(cfg.target));\n        if (cfg.$target.length === 0) {\n            if (!cfg.target) {\n                log.error(\"Need target selector\", cfg);\n                return false;\n            }\n            cfg.$target = this.createTarget(cfg.target);\n            cfg.$injected = cfg.$target;\n        }\n        return true;\n    },\n\n    verifySingleConfig(url, cfg) {\n        /* Verify one of potentially multiple configs (i.e. argument lists).\n         *\n         * Extract modifiers such as ::element or ::after.\n         * Ensure that a target element exists.\n         */\n        if (cfg.url !== url) {\n            // in case of multi-injection, all injections need to use\n            // the same url\n            log.error(\"Unsupported different urls for multi-inject\");\n            return false;\n        }\n        // defaults\n        cfg.source = cfg.source || cfg.defaultSelector;\n        cfg.target = cfg.target || cfg.defaultSelector;\n\n        if (!this.extractModifiers(cfg)) {\n            return false;\n        }\n        if (!this.ensureTarget(cfg)) {\n            return false;\n        }\n        this.listenForFormReset(cfg);\n        return true;\n    },\n\n    verifyConfig(cfgs) {\n        /* Verify and post-process all the configurations.\n         * Each \"config\" is an arguments list separated by the &&\n         * combination operator.\n         *\n         * In case of multi-injection, only one URL is allowed, which\n         * should be specified in the first config (i.e. arguments list).\n         *\n         * Verification for each cfg in the array needs to succeed.\n         */\n        return cfgs.every((cfg) => this.verifySingleConfig(cfgs[0].url, cfg));\n    },\n\n    listenForFormReset(cfg) {\n        /* if pat-inject is used to populate target in some form and when\n         * Cancel button is pressed (this triggers reset event on the\n         * form) you would expect to populate with initial placeholder\n         */\n        if (cfg.target === \"none\")\n            // Special case, we don't want to display any return value.\n            return;\n        const $form = cfg.$target.parents(\"form\");\n        if ($form.length !== 0 && cfg.$target.data(\"initial-value\") === undefined) {\n            cfg.$target.data(\"initial-value\", cfg.$target.html());\n            $form.on(\"reset\", () => {\n                cfg.$target.html(cfg.$target.data(\"initial-value\"));\n            });\n        }\n    },\n\n    extractModifiers(cfg) {\n        /* The user can add modifiers to the source and target arguments.\n         * Modifiers such as ::element, ::before and ::after.\n         * We identifiy and extract these modifiers here.\n         */\n        const source_re = /^(.*?)(::element)?$/;\n        const target_re = /^(.*?)(::element)?(::after|::before)?$/;\n        const source_match = source_re.exec(cfg.source);\n        const target_match = target_re.exec(cfg.target);\n\n        cfg.source = source_match[1];\n        cfg.sourceMod = source_match[2] ? \"element\" : \"content\";\n        cfg.target = target_match[1];\n        const targetMod = target_match[2] ? \"element\" : \"content\";\n        const targetPosition = (target_match[3] || \"::\").slice(2); // position relative to target\n\n        if (cfg.loadingClass) {\n            cfg.loadingClass += \" \" + cfg.loadingClass + \"-\" + targetMod;\n            if (targetPosition && cfg.loadingClass) {\n                cfg.loadingClass += \" \" + cfg.loadingClass + \"-\" + targetPosition;\n            }\n        }\n        cfg.action = targetMod + targetPosition;\n        // Once we start detecting illegal combinations, we'll\n        // return false in case of error\n        return true;\n    },\n\n    createTarget(selector) {\n        /* create a target that matches the selector\n         *\n         * XXX: so far we only support #target and create a div with\n         * that id appended to the body.\n         */\n        if (selector.slice(0, 1) !== \"#\") {\n            log.error(\"only id supported for non-existing target\");\n            return null;\n        }\n        const $target = $(\"<div />\").attr({ id: selector.slice(1) });\n        $(\"body\").append($target);\n        return $target;\n    },\n\n    stopBubblingFromRemovedElement($el, cfgs, ev) {\n        /* IE8 fix. Stop event from propagating IF $el will be removed\n         * from the DOM. With pat-inject, often $el is the target that\n         * will itself be replaced with injected content.\n         *\n         * IE8 cannot handle events bubbling up from an element removed\n         * from the DOM.\n         *\n         * See: http://stackoverflow.com/questions/7114368/why-is-jquery-remove-throwing-attr-exception-in-ie8\n         */\n        for (const cfg of cfgs) {\n            const sel = cfg.target;\n            if ($el.parents(sel).addBack(sel) && !ev.isPropagationStopped()) {\n                ev.stopPropagation();\n                return;\n            }\n        }\n    },\n\n    _performInjection(target, $el, $source, cfg, trigger, title) {\n        /* Called after the XHR has succeeded and we have a new $source\n         * element to inject.\n         */\n        if (cfg.sourceMod === \"content\") {\n            $source = $source.contents();\n        }\n        let $src;\n        // $source.clone() does not work with shived elements in IE8\n        if (document.all && document.querySelector && !document.addEventListener) {\n            $src = $source.map((idx, el) => $(el.outerHTML)[0]);\n        } else {\n            $src = $source.safeClone();\n        }\n\n        $src.findInclusive(\"img\").on(\"load\", (e) => {\n            $(e.currentTarget).trigger(\"pat-inject-content-loaded\");\n        });\n\n        const $injected = cfg.$injected || $src;\n        // Now the injection actually happens.\n        if (this._inject(trigger, $src, $(target), cfg)) {\n            // Update history\n            this._update_history(cfg, trigger, title);\n            // Post-injection\n            this._afterInjection($el, $injected, cfg);\n        }\n    },\n\n    _update_history(cfg, trigger, title) {\n        // History support. if subform is submitted, append form params\n        const glue = cfg.url.indexOf(\"?\") > -1 ? \"&\" : \"?\";\n        if (cfg.history === \"record\" && \"pushState\" in history) {\n            if (cfg.params) {\n                history.pushState(\n                    { url: cfg.url + glue + cfg.params },\n                    \"\",\n                    cfg.url + glue + cfg.params\n                );\n            } else {\n                history.pushState({ url: cfg.url }, \"\", cfg.url);\n            }\n            // Also inject title element if we have one\n            if (title)\n                this._inject(trigger, title, $(\"title\"), {\n                    action: \"element\",\n                });\n        }\n    },\n\n    _afterInjection($el, $injected, cfg) {\n        /* Set a class on the injected elements and fire the\n         * patterns-injected event.\n         */\n        $injected\n            .filter((idx, el_) => {\n                // setting data on textnode fails in IE8\n                return el_.nodeType !== TEXT_NODE;\n            })\n            .data(\"pat-injected\", { origin: cfg.url });\n\n        if ($injected.length === 1 && $injected[0].nodeType == TEXT_NODE) {\n            // Only one element injected, and it was a text node.\n            // So we trigger \"patterns-injected\" on the parent.\n            // The event handler should check whether the\n            // injected element and the triggered element are\n            // the same.\n            $injected.parent().trigger(\"patterns-injected\", [cfg, $el[0], $injected[0]]);\n        } else {\n            $injected.each((idx, el_) => {\n                // patterns-injected event will be triggered for each injected (non-text) element.\n                if (el_.nodeType !== TEXT_NODE) {\n                    $(el_)\n                        .addClass(cfg[\"class\"])\n                        .trigger(\"patterns-injected\", [cfg, $el[0], el_]);\n                }\n            });\n        }\n\n        if (cfg.scroll && cfg.scroll !== \"none\") {\n            let scroll_container = cfg.$target.parents().addBack().filter(\":scrollable\");\n            scroll_container = scroll_container.length ? scroll_container[0] : window;\n\n            // default for scroll===top\n            let top = 0;\n            let left = 0;\n\n            if (cfg.scroll !== \"top\") {\n                const scroll_target =\n                    cfg.scroll === \"target\"\n                        ? cfg.$target[0]\n                        : $injected.filter(cfg.scroll)[0];\n\n                // Get the reference element to which against we calculate\n                // the relative position of the target.\n                // In case of a scroll container of window, we do not have\n                // getBoundingClientRect method, so get the body instead.\n                const scroll_container_ref =\n                    scroll_container === window ? document.body : scroll_container;\n\n                // Calculate absolute [¹] position difference between\n                // scroll_container and scroll_target.\n                // Substract the container's border from the scrolling\n                // value, as this one isn't respected by\n                // getBoundingClientRect [²] and would lead to covered\n                // items [³].\n                // ¹) so that it doesn't make a difference, if the element\n                // is below or above the scrolling container. We just need\n                // to know the absolute difference.\n                // ²) Calculations are based from the viewport.\n                // ³) See:\n                //      https://docs.microsoft.com/en-us/previous-versions//hh781509(v=vs.85)\n                //      https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect\n                left = Math.abs(\n                    scroll_target.getBoundingClientRect().left +\n                        scroll_container_ref.scrollLeft -\n                        scroll_container_ref.getBoundingClientRect().left -\n                        dom.get_css_value(\n                            scroll_container_ref,\n                            \"border-left-width\",\n                            true\n                        )\n                );\n                top = Math.abs(\n                    scroll_target.getBoundingClientRect().top +\n                        scroll_container_ref.scrollTop -\n                        scroll_container_ref.getBoundingClientRect().top -\n                        dom.get_css_value(scroll_container_ref, \"border-top-width\", true)\n                );\n            }\n            if (scroll_container === window) {\n                scroll_container.scrollTo(left, top);\n            } else {\n                scroll_container.scrollLeft = left;\n                scroll_container.scrollTop = top;\n            }\n        }\n\n        $el[0].dispatchEvent(\n            new Event(\"pat-inject-success\", { bubbles: true, cancelable: true })\n        );\n    },\n\n    async _onInjectSuccess($el, cfgs, ev) {\n        let data = ev?.jqxhr?.responseText;\n        if (!data) {\n            log.warn(\"No response content, aborting\", ev);\n            return;\n        }\n        if (cfgs[0].source === \"none\") {\n            // Special case, we want to call something, but we don't want to inject anything\n            data = \"\";\n        }\n        $.each(cfgs[0].hooks || [], (idx, hook) =>\n            $el.trigger(\"pat-inject-hook-\" + hook)\n        );\n        this.stopBubblingFromRemovedElement($el, cfgs, ev);\n        const sources$ = await this.callTypeHandler(cfgs[0].dataType, \"sources\", $el, [\n            cfgs,\n            data,\n            ev,\n        ]);\n        /* pick the title source for dedicated handling later\n          Title - if present - is always appended at the end. */\n        let title;\n        if (\n            sources$ &&\n            sources$[sources$.length - 1] &&\n            sources$[sources$.length - 1][0] &&\n            sources$[sources$.length - 1][0].nodeName == \"TITLE\"\n        ) {\n            title = sources$[sources$.length - 1];\n        }\n        cfgs.forEach((cfg, idx1) => {\n            const perform_inject = () => {\n                if (cfg.target !== \"none\")\n                    cfg.$target.each((idx2, target) => {\n                        this._performInjection(\n                            target,\n                            $el,\n                            sources$[idx1],\n                            cfg,\n                            ev.target,\n                            title\n                        );\n                    });\n            };\n            if (cfg.processDelay) {\n                setTimeout(() => perform_inject(), cfg.processDelay);\n            } else {\n                perform_inject();\n            }\n        });\n        if (cfgs[0].nextHref && $el.is(\"a\")) {\n            // In case next-href is specified the anchor's href will\n            // be set to it after the injection is triggered.\n            $el.attr({ href: cfgs[0].nextHref.replace(/&amp;/g, \"&\") });\n            this.destroy($el);\n        }\n        $el.off(\"pat-ajax-success.pat-inject\");\n        $el.off(\"pat-ajax-error.pat-inject\");\n    },\n\n    async _onInjectError($el, cfgs, event) {\n        let explanation = \"\";\n        const status = event.jqxhr.status;\n        const timestamp = new Date();\n        if (status % 100 == 4) {\n            explanation =\n                \"Sorry! We couldn't find the page to load. Please make a screenshot and send it to support. Thank you!\";\n        } else if (status % 100 == 5) {\n            explanation =\n                \"I am very sorry! There was an error at the server. Please make a screenshot and contact support. Thank you!\";\n        } else if (status == 0) {\n            explanation =\n                \"It seems, the server is down. Please make a screenshot and contact support. Thank you!\";\n        }\n\n        let error_page;\n        let error_page_fragment;\n        const url_params = new URLSearchParams(window.location.search);\n        if (url_params.get(\"pat-inject-errorhandler.off\") === null) {\n            // Prepare a error page to be injected into the document.\n\n            // Try to get a suitable error message from pre-configured error pages.\n            const error_page_url = document\n                ?.querySelector(`meta[name^=pat-inject-status-${status}]`)\n                ?.getAttribute(\"content\", false);\n            error_page_fragment = error_page_url?.split(\"#\")[1];\n            error_page_fragment = error_page_fragment ? `#${error_page_fragment}` : null;\n\n            if (error_page_fragment) {\n                error_page = document.createElement(\"html\");\n                error_page.innerHTML = event.jqxhr.responseText;\n                error_page = error_page.querySelector(error_page_fragment);\n            }\n\n            if (!error_page && error_page_url) {\n                try {\n                    const error_page_response = await fetch(error_page_url, {\n                        method: \"GET\",\n                    });\n                    error_page = document.createElement(\"html\");\n                    error_page.innerHTML = await error_page_response.text();\n                    error_page = error_page.querySelector(error_page_fragment || \"body\");\n                } catch {\n                    // fall back to standard error message and ignore.\n                }\n            }\n        }\n\n        // clean up\n        cfgs.forEach((cfg) => {\n            if (\"$injected\" in cfg) {\n                cfg.$injected.remove();\n            }\n            cfg.$target.removeClass(cfg.loadingClass);\n            $el.removeClass(cfg.executingClass);\n        });\n        $el.off(\"pat-ajax-success.pat-inject\");\n        $el.off(\"pat-ajax-error.pat-inject\");\n\n        if (error_page) {\n            const error_zone = document.querySelector(error_page_fragment || \"body\");\n            error_zone.innerHTML = error_page.innerHTML;\n            registry.scan(error_zone); // initialize any patterns in error page\n        } else {\n            const msg_attr = `${explanation} Status is ${status} ${event.jqxhr.statusText}, time was ${timestamp}. You can click to close this.`;\n            $(\"body\").attr(\"data-error-message\", msg_attr);\n            $(\"body\").on(\"click\", () => {\n                $(\"body\").removeAttr(\"data-error-message\");\n                window.location.href = window.location.href; // reload\n            });\n        }\n    },\n\n    execute(cfgs, $el) {\n        /* Actually execute the injection.\n         *\n         * Either by making an ajax request or by spoofing an ajax\n         * request when the content is readily available in the current page.\n         */\n        // get a kinda deep copy, we scribble on it\n        cfgs = cfgs.map((cfg) => $.extend({}, cfg));\n        if (!this.verifyConfig(cfgs)) {\n            return;\n        }\n        if (!this.askForConfirmation(cfgs)) {\n            return;\n        }\n        if ($el.data(\"pat-inject-triggered\")) {\n            // Prevent double triggers;\n            return;\n        }\n        $el.data(\"pat-inject-triggered\", true);\n\n        for (const cfg of cfgs) {\n            // Add a execute class on the pat-inject element.\n            if (cfg?.executingClass) {\n                $el[0].classList.add(cfg.executingClass);\n            }\n            // Add a loading class to the target.\n            // Can be used for loading-spinners.\n            if (cfg?.loadingClass && cfg?.target !== \"none\") {\n                cfg.$target.addClass(cfg.loadingClass);\n            }\n        }\n\n        $el.on(\n            \"pat-ajax-success.pat-inject\",\n            this._onInjectSuccess.bind(this, $el, cfgs)\n        );\n        $el.on(\"pat-ajax-error.pat-inject\", this._onInjectError.bind(this, $el, cfgs));\n        $el.on(\"pat-ajax-success.pat-inject pat-ajax-error.pat-inject\", () =>\n            $el.removeData(\"pat-inject-triggered\")\n        );\n\n        // Prevent closing the panel while injection is in progress.\n        let do_close_panel = false;\n        events.add_event_listener(\n            $el[0],\n            \"close-panel\",\n            \"pat-inject--close-panel\",\n            (e) => {\n                e.stopPropagation();\n                e.stopImmediatePropagation();\n                do_close_panel = true;\n            }\n        );\n        $el.on(\"pat-ajax-success.pat-inject\", async () => {\n            // Wait for the next tick to ensure that the close-panel listener\n            // is called before this one, even for non-async local injects.\n            await utils.timeout(1);\n            // Only close the panel if a close-panel event was catched previously.\n            if (do_close_panel) {\n                do_close_panel = false;\n                // Remove the close-panel event listener.\n                events.remove_event_listener($el[0], \"pat-inject--close-panel\");\n                // Re-trigger close-panel event if it was caught while injection was in progress.\n                $el[0].dispatchEvent(\n                    new Event(\"close-panel\", { bubbles: true, cancelable: true })\n                );\n            }\n        });\n\n        if (cfgs[0].url.length) {\n            ajax.request($el, {\n                \"url\": cfgs[0].url,\n                \"browser-cache\": cfgs[0].browserCache,\n            });\n        } else {\n            // If there is no url specified, then content is being fetched\n            // from the same page.\n            // No need to do an ajax request for this, so we spoof the ajax\n            // event.\n            $el.trigger({\n                type: \"pat-ajax-success\",\n                jqxhr: {\n                    responseText: $(\"body\").html(),\n                },\n            });\n        }\n    },\n\n    _inject(trigger, $source, $target, cfg) {\n        // action to jquery method mapping, except for \"content\"\n        // and \"element\"\n        const method = {\n            contentbefore: \"prepend\",\n            contentafter: \"append\",\n            elementbefore: \"before\",\n            elementafter: \"after\",\n        }[cfg.action];\n\n        if (cfg.source === \"none\") {\n            $target.replaceWith(\"\");\n            return true;\n        }\n        if ($source.length === 0) {\n            log.warn(\"Aborting injection, source not found:\", $source);\n            $(trigger).trigger(\"pat-inject-missingSource\", {\n                url: cfg.url,\n                selector: cfg.source,\n            });\n            return false;\n        }\n        if (cfg.target === \"none\")\n            // Special case. Don't do anything, we don't want any result\n            return true;\n        if ($target.length === 0) {\n            log.warn(\"Aborting injection, target not found:\", $target);\n            $(trigger).trigger(\"pat-inject-missingTarget\", {\n                selector: cfg.target,\n            });\n            return false;\n        }\n        if (cfg.action === \"content\") {\n            $target.empty().append($source);\n        } else if (cfg.action === \"element\") {\n            $target.replaceWith($source);\n        } else {\n            $target[method]($source);\n        }\n        return true;\n    },\n\n    _sourcesFromHtml(html, url, sources) {\n        const $html = this._parseRawHtml(html, url);\n        return sources.map((source) => {\n            if (source === \"body\") {\n                source = \"#__original_body\";\n            }\n            if (source === \"none\") {\n                return $(\"<!-- -->\");\n            }\n            const $source = $html.find(source);\n\n            if ($source.length === 0) {\n                if (source != \"title\") {\n                    log.warn(\"No source elements for selector:\", source, $html);\n                }\n            }\n\n            $source.find('a[href^=\"#\"]').each((idx, el_) => {\n                const href = el_.getAttribute(\"href\");\n                if (href.indexOf(\"#{1}\") !== -1) {\n                    // We ignore hrefs containing #{1} because they're not\n                    // valid and only applicable in the context of\n                    // pat-clone.\n                    return;\n                }\n                // Skip in-document links pointing to an id that is inside\n                // this fragment.\n                if (href.length === 1) {\n                    // Special case for top-of-page links\n                    el_.href = url;\n                } else if (!$source.find(href).length) {\n                    el_.href = url + href;\n                }\n            });\n            return $source;\n        });\n    },\n\n    _rebaseAttrs: {\n        A: \"href\",\n        FORM: \"action\",\n        IMG: \"data-pat-inject-rebase-src\",\n        OBJECT: \"data\",\n        SOURCE: \"data-pat-inject-rebase-src\",\n        VIDEO: \"data-pat-inject-rebase-src\",\n    },\n\n    _rebaseOptions: {\n        \"calendar\": [\"url\", \"event-sources\"],\n        \"collapsible\": [\"load-content\"],\n        \"date-picker\": [\"i18n\"],\n        \"datetime-picker\": [\"i18n\"],\n        \"inject\": [\"url\"],\n    },\n\n    _rebaseURL(base, url) {\n        if (url.indexOf(\"://\") !== -1 || url[0] === \"/\" || url.indexOf(\"data:\") === 0) {\n            return url;\n        }\n        base = new URL(base, window.location).href; // If base is relative make it absolute.\n        return base.slice(0, base.lastIndexOf(\"/\") + 1) + url;\n    },\n\n    _rebaseHTML(base, html) {\n        if (html === \"\") {\n            // Special case, source is none\n            return \"\";\n        }\n        const $page = $(\n            html.replace(/(\\s)(src\\s*)=/gi, '$1src=\"\" data-pat-inject-rebase-$2=').trim()\n        )\n            .wrapAll(\"<div>\")\n            .parent();\n\n        $page.find(Object.keys(this._rebaseAttrs).join(\",\")).each((idx, el_) => {\n            const $el_ = $(el_);\n            const attrName = this._rebaseAttrs[el_.tagName];\n            let value = $el_.attr(attrName);\n\n            if (\n                value &&\n                value.slice(0, 2) !== \"@@\" &&\n                value[0] !== \"#\" &&\n                value.slice(0, 7) !== \"mailto:\" &&\n                value.slice(0, 4) !== \"tel:\" &&\n                value.slice(0, 4) !== \"fax:\" &&\n                value.slice(0, 7) !== \"callto:\" &&\n                value.slice(0, 10) !== \"ts3server:\" &&\n                value.slice(0, 6) !== \"teams:\" &&\n                value.slice(0, 11) !== \"javascript:\"\n            ) {\n                value = this._rebaseURL(base, value);\n                $el_.attr(attrName, value);\n            }\n        });\n\n        for (const [pattern_name, opts] of Object.entries(this._rebaseOptions)) {\n            for (const el_ of dom.querySelectorAllAndMe(\n                $page[0],\n                `[data-pat-${pattern_name}]`\n            )) {\n                const pattern = registry.patterns?.[pattern_name];\n                const pattern_parser = pattern?.parser;\n                if (!pattern_parser) {\n                    continue;\n                }\n                // parse: no default options, possibly multiple configs, no grouping.\n                const options = pattern_parser.parse(el_, {}, true, false, false);\n                let changed = false;\n                for (const config of options) {\n                    for (const opt of opts) {\n                        const val = config[opt];\n                        if (!val) {\n                            continue;\n                        }\n                        changed = true;\n                        if (Array.isArray(val)) {\n                            config[opt] = val.map((it) => this._rebaseURL(base, it));\n                        } else {\n                            config[opt] = this._rebaseURL(base, val);\n                        }\n                    }\n                }\n                if (changed) {\n                    el_.setAttribute(\n                        `data-pat-${pattern_name}`,\n                        JSON.stringify(options.length === 1 ? options[0] : options)\n                    );\n                }\n            }\n        }\n\n        // XXX: IE8 changes the order of attributes in html. The following\n        // lines move data-pat-inject-rebase-src to src.\n        $page.find(\"[data-pat-inject-rebase-src]\").each((id, el_) => {\n            const $el = $(el_);\n            $el.attr(\"src\", $el.attr(\"data-pat-inject-rebase-src\")).removeAttr(\n                \"data-pat-inject-rebase-src\"\n            );\n        });\n\n        return $page\n            .html()\n            .replace(/src=\"\" data-pat-inject-rebase-/g, \"\")\n            .trim();\n    },\n\n    _parseRawHtml(html, url = \"\") {\n        // remove script tags and head and replace body by a div\n        const title = html.match(/\\<title\\>(.*)\\<\\/title\\>/);\n        let clean_html = html\n            .replace(/<script\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/script>/gi, \"\")\n            .replace(/<head\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/head>/gi, \"\")\n            .replace(/<body([^>]*?)>/gi, '<div id=\"__original_body\">')\n            .replace(/<\\/body([^>]*?)>/gi, \"</div>\");\n        if (title && title.length == 2) {\n            clean_html = title[0] + clean_html;\n        }\n        try {\n            clean_html = this._rebaseHTML(url, clean_html);\n        } catch (e) {\n            log.error(\"Error rebasing urls\", e);\n        }\n        const $html = $(\"<div/>\").html(clean_html);\n        if ($html.children().length === 0) {\n            log.warn(\"Parsing html resulted in empty jquery object:\", clean_html);\n        }\n        return $html;\n    },\n\n    _initAutoloadVisible($el, cfgs) {\n        if ($el.data(\"pat-inject-autoloaded\")) {\n            // ignore executed autoloads\n            return false;\n        }\n\n        const el = $el[0];\n\n        // delay: default is 200ms to allow scrolling over and past autoload-visible elements without loading them.\n        const delay = cfgs[0].delay || 200;\n        log.debug(`Delay time: ${delay}`);\n\n        // function to trigger the autoload and mark as triggered\n        const trigger = (event) => {\n            if ($el.data(\"pat-inject-autoloaded\")) {\n                log.debug(`autoload-visible trigger skipped ${el}`);\n                return false;\n            }\n            $el.data(\"pat-inject-autoloaded\", true);\n            this.onTrigger({ currentTarget: el });\n            event && event.preventDefault();\n            log.debug(`autoload-visible trigger run ${el}`);\n            return true;\n        };\n\n        // Config see: https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API\n        const intersection_observer_config = {\n            threshold: 0, // If even one pixel is visible, the callback will be run.\n            root: null, // Root is browser viewport. If the element is visible to the user, the callback will be run.\n            margin: \"0px\", // No margins. The element is not preloaded.\n        };\n\n        let timeout_id = null;\n        const observer = new IntersectionObserver((entries) => {\n            for (const entry of entries) {\n                if (entry.isIntersecting) {\n                    // Run the callback after 200ms to prevent loading all\n                    // visible elements when scrolling over.\n                    timeout_id = window.setTimeout(() => {\n                        observer.disconnect(); // Stop observing loaded elements.\n                        trigger();\n                    }, delay);\n                    log.debug(`autoload-visible intersecting ${el}`);\n                } else {\n                    window.clearTimeout(timeout_id);\n                    log.debug(`autoload-visible not intersecting ${el}`);\n                }\n            }\n        }, intersection_observer_config);\n        observer.observe(el);\n    },\n\n    _initIdleTrigger($el, delay) {\n        // XXX TODO: handle item removed from DOM\n        const timeout = parseInt(delay, 10);\n        let timer;\n\n        const onTimeout = () => {\n            this.onTrigger({ currentTarget: $el[0] });\n            unsub();\n            clearTimeout(timer);\n        };\n\n        const onInteraction = utils.debounce(() => {\n            if (!document.body.contains($el[0])) {\n                unsub();\n                return;\n            }\n            clearTimeout(timer);\n            timer = setTimeout(onTimeout, timeout);\n        }, timeout);\n\n        const unsub = () => {\n            [\"scroll\", \"resize\"].forEach((e) =>\n                window.removeEventListener(e, onInteraction)\n            );\n            [\n                \"click\",\n                \"keypress\",\n                \"keyup\",\n                \"mousemove\",\n                \"touchstart\",\n                \"touchend\",\n            ].forEach((e) => document.removeEventListener(e, onInteraction));\n        };\n\n        onInteraction();\n\n        [\"scroll\", \"resize\"].forEach((e) => window.addEventListener(e, onInteraction));\n        [\"click\", \"keypress\", \"keyup\", \"mousemove\", \"touchstart\", \"touchend\"].forEach(\n            (e) => document.addEventListener(e, onInteraction)\n        );\n    },\n\n    // XXX: simple so far to see what the team thinks of the idea\n    registerTypeHandler(type, handler) {\n        this.handlers[type] = handler;\n    },\n\n    async callTypeHandler(type, fn, context, params) {\n        type = type || \"html\";\n        if (this.handlers[type] && $.isFunction(this.handlers[type][fn])) {\n            return await this.handlers[type][fn].bind(this)(...params);\n        } else {\n            return null;\n        }\n    },\n\n    handlers: {\n        html: {\n            sources(cfgs, data) {\n                const sources = cfgs.map((cfg) => cfg.source);\n                sources.push(\"title\");\n                return this._sourcesFromHtml(data, cfgs[0].url, sources);\n            },\n        },\n    },\n};\n\n$(document).on(\"patterns-injected.inject\", async (ev, cfg, trigger, injected) => {\n    /* Listen for the patterns-injected event.\n     *\n     * Remove the \"loading-class\" classes from all injection targets and\n     * then scan the injected content for new patterns.\n     */\n    if (cfg && cfg.skipPatInjectHandler) {\n        // Allow skipping this handler but still have other handlers in other\n        // patterns listen to ``patterns-injected``.\n        return;\n    }\n    if (cfg) {\n        cfg.$target.removeClass(cfg.loadingClass);\n        // Remove the executing class, add the executed class to the element with pat.inject on it.\n        $(trigger).removeClass(cfg.executingClass).addClass(cfg.executedClass);\n    }\n    if (injected.nodeType !== TEXT_NODE && injected.nodeType !== COMMENT_NODE) {\n        registry.scan(injected, null, { type: \"injection\", element: trigger });\n        $(injected).trigger(\"patterns-injected-scanned\");\n\n        await utils.timeout(10); // Wait a bit before dispatching next event.\n        injected.dispatchEvent(\n            new CustomEvent(\"patterns-injected-delayed\", {\n                bubbles: true,\n                cancelable: true,\n                detail: {\n                    injected: injected,\n                },\n            })\n        );\n    }\n});\n\n$(window).on(\"popstate\", (event) => {\n    // popstate also triggers on traditional anchors\n    if (!event.originalEvent.state && \"replaceState\" in history) {\n        try {\n            history.replaceState(\"anchor\", \"\", document.location.href);\n        } catch (e) {\n            log.debug(e);\n        }\n        return;\n    }\n    // Not only change the URL, also reload the page.\n    window.location.reload();\n});\n\n// this entry ensures that the initally loaded page can be reached with\n// the back button\nif (\"replaceState\" in history) {\n    try {\n        history.replaceState(\"pageload\", \"\", document.location.href);\n    } catch (e) {\n        log.debug(e);\n    }\n}\n\nregistry.register(inject);\nexport default inject;\n","import $ from \"jquery\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\nimport Base from \"../../core/base\";\nimport inject from \"../inject/inject\";\n\nvar log = logging.getLogger(\"pat.markdown\");\nvar is_markdown_resource = /\\.md$/;\n\nvar Markdown = Base.extend({\n    name: \"markdown\",\n    trigger: \".pat-markdown\",\n\n    async init() {\n        if (this.$el.is(this.trigger)) {\n            /* This pattern can either be used standalone or as an enhancement\n             * to pat-inject. The following only applies to standalone, when\n             * $el is explicitly configured with the pat-markdown trigger.\n             */\n            var source = this.$el.is(\":input\") ? this.$el.val() : this.$el.text();\n            let rendered = await this.render(source);\n            rendered.replaceAll(this.$el);\n        }\n    },\n\n    async render(text) {\n        const Showdown = (await import(\"showdown\")).default;\n\n        // Add support for syntax highlighting via pat-syntax-highlight\n        Showdown.extensions.prettify = function () {\n            return [\n                {\n                    type: \"output\",\n                    filter: function (source) {\n                        return source.replace(/(<pre>)?<code>/gi, function (match, pre) {\n                            if (pre) {\n                                return '<pre class=\"pat-syntax-highlight\" tabIndex=\"0\"><code data-inner=\"1\">';\n                            } else {\n                                return '<code class=\"pat-syntax-highlight\">';\n                            }\n                        });\n                    },\n                },\n            ];\n        };\n\n        const $rendering = $(\"<div/>\");\n        const converter = new Showdown.Converter({\n            tables: true,\n            extensions: [\"prettify\"],\n        });\n        $rendering.html(converter.makeHtml(text));\n        return $rendering;\n    },\n\n    async renderForInjection(cfg, data) {\n        var header,\n            source = data;\n        if (cfg.source && (header = /^#+\\s*(.*)/.exec(cfg.source)) !== null) {\n            source = this.extractSection(source, header[1]);\n            if (source === null) {\n                log.warn('Could not find section \"' + cfg.source + '\" in ' + cfg.url);\n                return $(\"<div/>\").attr(\"data-src\", cfg.url);\n            }\n            source += \"\\n\"; // Needed for some markdown syntax\n        }\n        const rendered = await this.render(source);\n        return rendered.attr(\"data-src\", cfg.source ? cfg.url + cfg.source : cfg.url);\n    },\n\n    extractSection(text, header) {\n        var pattern, level;\n        header = utils.escapeRegExp(header);\n        var matcher = new RegExp(\n                \"^((#+)\\\\s*@TEXT@\\\\s*|@TEXT@\\\\s*\\\\n([=-])+\\\\s*)$\".replace(\n                    /@TEXT@/g,\n                    header\n                ),\n                \"m\"\n            ),\n            match = matcher.exec(text);\n        if (match === null) {\n            return null;\n        } else if (match[2]) {\n            // We have a ##-style header.\n            level = match[2].length;\n            pattern =\n                \"^#{@LEVEL@}\\\\s*@TEXT@\\\\s*$\\\\n+((?:.|\\\\n)*?(?=^#{1,@LEVEL@}\\\\s)|.*(?:.|\\\\n)*)\";\n            pattern = pattern.replace(/@LEVEL@/g, level);\n        } else if (match[3]) {\n            // We have an underscore-style header.\n            if (match[3] === \"=\")\n                pattern =\n                    \"^@TEXT@\\\\s*\\\\n=+\\\\s*\\\\n+((?:.|\\\\n)*?(?=^.*?\\\\n=+\\\\s*$)|(?:.|\\\\n)*)\";\n            else\n                pattern =\n                    \"^@TEXT@\\\\s*\\\\n-+\\\\s*\\\\n+((?:.|\\\\n)*?(?=^.*?\\\\n[-=]+\\\\s*$)|(?:.|\\\\n)*)\";\n        } else {\n            log.error(\"Unexpected section match result\", match);\n            return null;\n        }\n        pattern = pattern.replace(/@TEXT@/g, header);\n        matcher = new RegExp(pattern, \"m\");\n        match = matcher.exec(text);\n        if (match === null) {\n            log.error(\"Failed to find section with known present header?\");\n        }\n        return match !== null ? match[0] : null;\n    },\n});\n\n$(document).ready(function () {\n    $(document.body).on(\n        \"patterns-inject-triggered.pat-markdown\",\n        \"a.pat-inject\",\n        function identifyMarkdownURLs() {\n            /* Identify injected URLs which point to markdown files and set their\n             * datatype so that we can register a type handler for them.\n             */\n            var cfgs = $(this).data(\"pat-inject\");\n            cfgs.forEach(function (cfg) {\n                if (is_markdown_resource.test(cfg.url)) {\n                    cfg.dataType = \"markdown\";\n                }\n            });\n        }\n    );\n});\n\ninject.registerTypeHandler(\"markdown\", {\n    async sources(cfgs, data) {\n        return await Promise.all(\n            cfgs.map(async function (cfg) {\n                var pat = Markdown.init(cfg.$target);\n                const rendered = await pat.renderForInjection(cfg, data);\n                return rendered;\n            })\n        );\n    },\n});\n\nexport default Markdown;\n","import \"../../core/jquery-ext\";\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.scroll\");\n\nexport const parser = new Parser(\"scroll\");\nparser.addArgument(\"trigger\", \"click\", [\"click\", \"auto\", \"manual\"]);\nparser.addArgument(\"direction\", \"top\", [\"top\", \"left\"]);\nparser.addArgument(\"selector\");\nparser.addArgument(\"offset\", 0);\nparser.addArgument(\"delay\");\n\nexport default Base.extend({\n    name: \"scroll\",\n    trigger: \".pat-scroll\",\n    jquery_plugin: true,\n\n    async init($el, opts) {\n        this.options = parser.parse(this.$el, opts);\n        if (this.options.delay) {\n            this.options.delay = utils.parseTime(this.options.delay);\n        }\n        if (this.options.trigger === \"auto\") {\n            const ImagesLoaded = (await import(\"imagesloaded\")).default;\n            // Only calculate the offset when all images are loaded\n            ImagesLoaded(document.body, () => this.smoothScroll());\n        }\n        if (this.options.trigger === \"auto\" || this.options.trigger === \"click\") {\n            this.el.addEventListener(\"click\", this.onClick.bind(this));\n        }\n        this.$el.on(\"pat-update\", this.onPatternsUpdate.bind(this));\n        this.markBasedOnFragment();\n        this.on(\"hashchange\", this.clearIfHidden.bind(this));\n        $(window).scroll(utils.debounce(this.markIfVisible.bind(this), 50));\n    },\n\n    onClick() {\n        //ev.preventDefault();\n        history.pushState({}, null, this.$el.attr(\"href\"));\n        this.smoothScroll();\n        this.markBasedOnFragment();\n        // manually trigger the hashchange event on all instances of pat-scroll\n        $(\"a.pat-scroll\").trigger(\"hashchange\");\n    },\n\n    markBasedOnFragment() {\n        // Get the fragment from the URL and set the corresponding this.$el as current\n        const fragment = window.location.hash.substr(1);\n        if (fragment) {\n            const $target = $(\"#\" + fragment);\n            this.$el.addClass(\"current\"); // the element that was clicked on\n            $target.addClass(\"current\");\n        }\n    },\n\n    clearIfHidden() {\n        const active_target = \"#\" + window.location.hash.substr(1);\n        const $active_target = $(active_target);\n        const target = \"#\" + this.$el[0].href.split(\"#\").pop();\n        if ($active_target.length > 0) {\n            if (active_target != target) {\n                // if the element does not match the one listed in the url #,\n                // clear the current class from it.\n                const $target = $(\"#\" + this.$el[0].href.split(\"#\").pop());\n                $target.removeClass(\"current\");\n                this.$el.removeClass(\"current\");\n            }\n        }\n    },\n\n    markIfVisible() {\n        if (this.$el.hasClass(\"pat-scroll-animated\")) {\n            // this section is triggered when the scrolling is a result of the animate function\n            // ie. automatic scrolling as opposed to the user manually scrolling\n            this.$el.removeClass(\"pat-scroll-animated\");\n        } else if (this.$el[0].nodeName === \"A\") {\n            const href = this.$el[0].href;\n            const fragment =\n                (href.indexOf(\"#\") !== -1 && href.split(\"#\").pop()) || undefined;\n            if (fragment) {\n                const $target = $(\"#\" + fragment);\n                if ($target.length) {\n                    if (\n                        utils.isElementInViewport($target[0], true, this.options.offset)\n                    ) {\n                        // check that the anchor's target is visible\n                        // if so, mark both the anchor and the target element\n                        $target.addClass(\"current\");\n                        this.$el.addClass(\"current\");\n                    }\n                    $(this.$el).trigger(\"pat-update\", { pattern: \"scroll\" });\n                }\n            }\n        }\n    },\n\n    onPatternsUpdate(ev, data) {\n        if (data?.pattern === \"stacks\") {\n            if (data.originalEvent && data.originalEvent.type === \"click\") {\n                this.smoothScroll();\n            }\n        } else if (data?.pattern === \"scroll\") {\n            const href = this.$el[0].href;\n            const fragment =\n                (href.indexOf(\"#\") !== -1 && href.split(\"#\").pop()) || undefined;\n            if (fragment) {\n                const $target = $(\"#\" + fragment);\n                if ($target.length) {\n                    if (\n                        !utils.isElementInViewport($target[0], true, this.options.offset)\n                    ) {\n                        // if the anchor's target is invisible, remove current class from anchor and target.\n                        $target.removeClass(\"current\");\n                        $(this.$el).removeClass(\"current\");\n                    }\n                }\n            }\n        }\n    },\n\n    _get_selector_target() {\n        const selector = this.options.selector;\n        if (!selector && this.el.href?.includes(\"#\")) {\n            return document.querySelector(`#${this.el.href.split(\"#\").pop()}`);\n        } else if (!selector || selector === \"self\") {\n            return this.el;\n        }\n        return document.querySelector(selector);\n    },\n\n    async smoothScroll() {\n        if (this.options.delay) {\n            await utils.timeout(this.options.delay);\n        }\n        const scroll = this.options.direction == \"top\" ? \"scrollTop\" : \"scrollLeft\";\n        const options = {};\n        let scrollable;\n        if (this.options.selector === \"top\") {\n            // Just scroll up or left, period.\n            scrollable = $(\n                dom.find_scroll_container(\n                    this.el.parentElement,\n                    this.options.direction === \"top\" ? \"y\" : \"x\"\n                )\n            );\n            options[scroll] = 0;\n        } else if (this.options.selector === \"bottom\") {\n            // Just scroll down or right, period.\n            scrollable = $(\n                dom.find_scroll_container(\n                    this.el.parentElement,\n                    this.options.direction === \"top\" ? \"y\" : \"x\"\n                )\n            );\n            if (scroll === \"scrollTop\") {\n                options.scrollTop = scrollable[0].scrollHeight;\n            } else {\n                options.scrollLeft = scrollable[0].scrollWidth;\n            }\n        } else {\n            // Get the first element with overflow (the scroll container)\n            // starting from the *target*\n            // The intent is to move target into view within scrollable\n            // if the scrollable has no scrollbar, do not scroll body\n\n            const target = $(this._get_selector_target());\n\n            if (!target.length) {\n                return;\n            }\n\n            scrollable = $(\n                dom.find_scroll_container(\n                    target[0].parentElement,\n                    this.options.direction === \"top\" ? \"y\" : \"x\"\n                )\n            );\n\n            if (scrollable[0] === document.body) {\n                // positioning context is document\n                if (scroll === \"scrollTop\") {\n                    options[scroll] = Math.floor(target.safeOffset().top);\n                } else {\n                    options[scroll] = Math.floor(target.safeOffset().left);\n                }\n            } else if (scroll === \"scrollTop\") {\n                // difference between target top and scrollable top becomes 0\n                options[scroll] = Math.floor(\n                    scrollable.scrollTop() +\n                        target.safeOffset().top -\n                        scrollable.safeOffset().top\n                );\n            } else {\n                options[scroll] = Math.floor(\n                    scrollable.scrollLeft() +\n                        target.safeOffset().left -\n                        scrollable.safeOffset().left\n                );\n            }\n        }\n\n        options[scroll] -= this.options.offset;\n\n        // Fix scrolling on body - need to scroll on HTML, howsoever.\n        if (scrollable[0] === document.body) {\n            scrollable = $(\"html\");\n        }\n\n        // execute the scroll\n        await scrollable\n            .animate(options, {\n                duration: 500,\n                start: () => {\n                    $(\".pat-scroll\").addClass(\"pat-scroll-animated\");\n                    log.debug(\"scrolling.\");\n                },\n            })\n            .promise();\n    },\n});\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport events from \"../../core/events\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\n// Initialize close-panel functionality.\nimport \"../close-panel/close-panel\";\n\nconst log = logging.getLogger(\"pat-tooltip\");\n\nexport const parser = new Parser(\"tooltip\");\nconst all_positions = [\n    \"tl\",\n    \"tm\",\n    \"tr\",\n    \"rt\",\n    \"rm\",\n    \"rb\",\n    \"br\",\n    \"bm\",\n    \"bl\",\n    \"lb\",\n    \"lm\",\n    \"lt\",\n];\nparser.addArgument(\"position-list\", [], all_positions, true);\nparser.addArgument(\"position-policy\", \"auto\", [\"auto\", \"force\"]);\nparser.addArgument(\"trigger\", \"click\", [\"click\", \"hover\", \"none\"]);\nparser.addArgument(\"source\", \"title\", [\"ajax\", \"content\", \"title\"]);\nparser.addArgument(\"ajax-data-type\", \"html\", [\"html\", \"markdown\"]);\nparser.addArgument(\"closing\", \"auto\", [\"auto\", \"sticky\", \"close-button\"]);\nparser.addArgument(\"delay\");\nparser.addArgument(\"mark-inactive\", true);\nparser.addArgument(\"class\");\nparser.addArgument(\"target\", \"body\");\nparser.addArgument(\"arrow-padding\", null);\nparser.addArgument(\"url\", null);\n\n// Tippy Lifecycle-hooks\n// See: https://tippyjs.bootcss.com/lifecycle-hooks/\n// onCreate\n// onTrigger\n// onShow\n// onMount\n// onShown\n// onUntrigger\n// onHide\n// onHidden\n//\n// onBeforeUpdate\n// onAfterUpdate\n// onDestroy\n\nexport default Base.extend({\n    name: \"tooltip\",\n    trigger: \".pat-tooltip, .pat-tooltip-ng\",\n\n    tippy: null,\n\n    active_class: \"tooltip-active-hover\",\n    inactive_class: \"tooltip-inactive\",\n\n    async init() {\n        const el = this.el;\n\n        if (window.__patternslib_import_styles) {\n            import(\"tippy.js/dist/tippy.css\");\n        }\n        const Tippy = (await import(\"tippy.js\")).default;\n\n        this.options = parser.parse(el, this.options);\n        this.tippy_options = this.parseOptionsForTippy(this.options);\n\n        const defaultProps = {\n            animation: false,\n            arrow: true,\n            //'delay': [0, 1800],\n            //'duration': [325, 275],\n            hideOnClick: this.options.closing === \"close-button\" ? false : true,\n            ignoreAttributes: true,\n            interactive: true,\n            onHide: this._onHide.bind(this),\n            onShow: this._onShow.bind(this),\n            trigger: \"click\",\n        };\n\n        Tippy.setDefaultProps(defaultProps);\n        this.tippy = new Tippy(el, this.tippy_options);\n\n        if (this.options.source === \"title\") {\n            // Remove ``title`` attribute when source is set to ``title`` to\n            // disable the browser's built-in tooltip feature\n            el.removeAttribute(\"title\");\n        }\n\n        if (this.options.trigger === \"click\" && this.options.source === \"ajax\") {\n            // prevent default action for \"click\" and \"mouseenter click\"\n            events.add_event_listener(\n                el,\n                \"click\",\n                \"pat-tooltip--click-prevent-default\",\n                (event) => {\n                    event.preventDefault();\n                    event.stopPropagation();\n                }\n            );\n        }\n\n        if (this.options.trigger === \"click\") {\n            this.active_class = \"tooltip-active-click\";\n        }\n        if (this.options.markInactive) {\n            // Initially mark as inactive\n            el.classList.add(this.inactive_class);\n        }\n    },\n\n    show() {\n        // Show this tooltip\n        // API method.\n        this.tippy.show();\n    },\n\n    async hide() {\n        // Hide this tooltip\n        await utils.timeout(1); // wait a tick for event being processed by other handlers.\n        this.tippy.hide();\n    },\n\n    destroy() {\n        // Remove this tooltip\n        // API method.\n        this.tippy.destroy();\n    },\n\n    parseOptionsForTippy(opts) {\n        const placement = (pos) => {\n            // note that Cornelis needs the positioning to be the placement of the thingy on the bubble\n            // tippy though refers to positioning as the placement of the bubble relatively to the reference element\n            // so we invert the meaning below. It's intentional.\n            const primary = (pos0) =>\n                ({\n                    t: \"bottom\",\n                    r: \"left\",\n                    b: \"top\",\n                    l: \"right\",\n                }[pos0]);\n\n            const secondary = (pos1) =>\n                ({\n                    l: \"-start\",\n                    r: \"-end\",\n                    m: \"\",\n                    t: \"-start\",\n                    b: \"-end\",\n                }[pos1]);\n\n            return `${primary(pos[0])}${secondary(pos[1])}`;\n        };\n\n        const tippy_options = { popperOptions: { modifiers: [] } };\n\n        if (opts.arrowPadding !== null) {\n            tippy_options.popperOptions.modifiers.push({\n                name: \"arrow\",\n                options: {\n                    padding: parseInt(opts.arrowPadding, 10),\n                },\n            });\n        }\n\n        const parsers = {\n            position: () => {\n                if (!opts.position?.list?.length) {\n                    return;\n                }\n                tippy_options.placement = placement(opts.position.list[0]); // main position\n\n                const flip_options = {\n                    name: \"flip\",\n                    enabled: true,\n                };\n\n                if (opts.position.policy === \"force\") {\n                    flip_options.enabled = false;\n                } else if (opts.position.length > 1) {\n                    const fallbacks = opts.position.list.slice(1).map(placement);\n                    flip_options.fallbackPlacements = fallbacks;\n                }\n\n                tippy_options.popperOptions.modifiers.push(flip_options);\n            },\n\n            trigger() {\n                if (opts.trigger === \"hover\") {\n                    tippy_options.trigger = \"mouseenter focus\";\n                } else if (opts.trigger === \"none\") {\n                    tippy_options.trigger = \"manual\";\n                    tippy_options.hideOnClick = false;\n                }\n            },\n\n            source: () => {\n                let content;\n                if (opts.source === \"title\") {\n                    // Tooltip content from title attribute\n                    content = this.el.getAttribute(\"title\");\n                } else if (opts.source === \"content\") {\n                    // Tooltip content from trigger childs.\n                    content = this.el.innerHTML;\n                    tippy_options.allowHTML = true;\n                } else if (opts.source === \"ajax\") {\n                    // Tooltiop content from AJAX request.\n                    content = document.createElement(\"progress\");\n                    tippy_options.allowHTML = true;\n                }\n                tippy_options.content = content;\n            },\n\n            delay() {\n                if (opts.delay) {\n                    tippy_options.delay = [utils.parseTime(opts.delay), 0];\n                }\n            },\n\n            target: () => {\n                if (!opts.target) {\n                    return;\n                }\n                if (opts.target === \"parent\") {\n                    tippy_options.appendTo = \"parent\";\n                } else if (opts.target === \"body\") {\n                    tippy_options.appendTo = document.body;\n                } else {\n                    tippy_options.appendTo = document.querySelector(opts.target);\n                }\n            },\n        };\n\n        for (let arg in opts) {\n            switch (arg) {\n                case \"ajax-data-type\":\n                    arg = \"ajaxDataType\";\n                    break;\n                case \"mark-inactive\":\n                    arg = \"markInactive\";\n                    break;\n            }\n            parsers[arg] && parsers[arg](arg);\n        }\n\n        return tippy_options;\n    },\n\n    _initialize_content() {\n        // Initialize any other patterns.\n        registry.scan(this.tippy.popper);\n    },\n\n    async _onShow() {\n        const tippy_classes = [];\n\n        // Group DOM manipulations\n\n        if (this.options.class) {\n            tippy_classes.push(...this.options.class.split(\" \"));\n        }\n\n        // Add a generic non-tippy related class to identify the tooltip container\n        tippy_classes.push(\"tooltip-container\");\n\n        if (this.options.closing === \"close-button\") {\n            // First, remove previously automatically added close buttons.\n            // Otherwise we would end up adding another close button with every\n            // click on it.\n            for (const close_button of this.tippy.popper.querySelectorAll(\n                \".pat-tooltip--close-button\"\n            )) {\n                close_button.remove();\n            }\n\n            const close_button = document.createElement(\"button\");\n            close_button.setAttribute(\"class\", \"close-panel pat-tooltip--close-button\");\n            const content = this.tippy.popper.querySelector(\".tippy-content\");\n            content.parentNode.insertBefore(close_button, content);\n        }\n\n        // Store reference to method for closing panels on the tooltip element instance.\n        events.add_event_listener(\n            this.tippy.popper,\n            \"close-panel\",\n            \"pat-tooltip--close-panel\",\n            () => this.hide()\n        );\n\n        this.tippy.popper.classList.add(...tippy_classes);\n\n        if (this.options.markInactive) {\n            this.el.classList.remove(this.inactive_class);\n            this.el.classList.add(this.active_class);\n        }\n\n        if (this.options.closing !== \"auto\" && this.options.trigger === \"hover\") {\n            // no auto-close when hovering when closing mode is \"sticky\" or \"close-button\".\n            this.tippy.setProps({ trigger: \"click\" });\n        }\n\n        if (this.options.source === \"ajax\") {\n            await this._get_content();\n        }\n\n        // Notify parent patterns about injected content.\n        // Do not call pat-inject's handler, because all necessary\n        // initialization after injection is done here.\n        $(this.tippy.popper).trigger(\"patterns-injected\", [\n            { skipPatInjectHandler: true },\n            this.el,\n            this.tippy.popper,\n        ]);\n\n        this._initialize_content();\n    },\n\n    _onHide() {\n        if (this.options.markInactive) {\n            this.el.classList.remove(this.active_class);\n            this.el.classList.add(this.inactive_class);\n        }\n\n        if (this.options.closing !== \"auto\" && this.options.trigger === \"hover\") {\n            // re-set hover behavior\n            this.tippy.setProps({ trigger: \"mouseenter focus\" });\n        }\n\n        if (this.options.source === \"ajax\") {\n            this.tippy.setContent(document.createElement(\"progress\"));\n        }\n    },\n\n    async _get_content(url = this.options.url) {\n        let selector;\n        ({ url, selector } = this.get_url_parts(url || this.el.getAttribute(\"href\")));\n        let content;\n        if (url) {\n            // Tooltip from remote page.\n            const handler = this._ajaxDataTypeHandlers[this.options.ajaxDataType];\n            try {\n                // TODO: use pat-inject, once it supports async\n                const response = await fetch(url, {\n                    headers: {\n                        Accept: \"text/html,application/xhtml+xml,application/xml\",\n                    },\n                });\n                const text = await response.text();\n                content = await handler(text, url, selector);\n            } catch (e) {\n                log.error(\"Error on ajax request. ${e}\");\n            }\n        } else if (selector) {\n            // Tooltip content from current DOM tree.\n            content = document.querySelector(selector);\n            content = content?.innerHTML || undefined;\n        }\n        if (content) {\n            this.tippy.setContent(content);\n            await utils.timeout(1); // Wait a tick before forceUpdate. Might fail due to unset popperInstance.\n            this.tippy.popperInstance.forceUpdate(); // re-position tippy after content is known.\n        }\n    },\n\n    async get_content(url = this.options.url) {\n        // API method: _get_content + _initialize_content\n        await this._get_content(url);\n        this._initialize_content();\n    },\n\n    get_url_parts(href) {\n        // Return the URL and a CSS ID selector.\n        let url, selector, query;\n        if (!href) {\n            return { url, selector };\n        }\n        [url, selector] = href.split(\"#\");\n        if (selector) {\n            selector = `#${selector}`;\n            [selector, query] = selector.split(\"?\");\n        }\n        if (query) {\n            url = `${url}?${query}`;\n        }\n        return { url, selector };\n    },\n\n    _ajaxDataTypeHandlers: {\n        html(text, url, selector) {\n            let tmp = document.createElement(\"div\");\n            tmp.innerHTML = text;\n            if (selector) {\n                tmp = tmp.querySelector(selector);\n            }\n            return tmp?.innerHTML || \"\";\n        },\n\n        async markdown(text, url, selector) {\n            const pat_markdown = await import(\"../markdown/markdown\");\n            const pat = pat_markdown.default.init($(\"<div/>\"));\n            const cfg = { url };\n            if (selector) {\n                cfg.source = selector;\n            }\n            const ret = await pat.renderForInjection(cfg, text);\n            return ret[0];\n        },\n    },\n});\n","import jquery from \"jquery\";\n// Register jQuery globally\nwindow.jQuery = jquery;\nwindow.$ = jquery;\n","/**\n * Patterns Push Kit - client to support websocket connection push\n *\n * Copyright 2018-2020 Johannes Raggam, Alexander Pilz, Syslab.com GmbH\n *\n * Basic push support connects to a push server and an exchange prefix.\n * it reads the name of the server and the exchange prefix from entries\n * in the meta header of the page\n * Then it sets up two bindings to two different exchanges, one to receive\n * push markers and one to receive desktop notifications.\n * It assumes that the exchanges are named [prefix]_event and [prefix]_notification\n *\n * If a message comes in on the [prefix]_event exchange, a javascript push event is triggered\n * which is listened to by all dom elements with class .pat-push on them.\n * pat-push will then compare the sent message with its own push_marker value and execute on match.\n *\n * If a message comes in on the [prefix]_notification exchange, a desktop notification is triggered\n * which will show a desktop marker.\n *\n * User filtering\n * all subscriptions are topic subscriptions and will only bind to topics that start with the userid\n * that way, users will only receive updates explicitly directed to them.\n *\n * This pattern expects the following meta tags to be available in the page to get the necessary configuration\n * - patterns-push-url containing a url pointing to a message queue server. Eg. ws://127.0.0.1:15674/ws\n * - patterns-push-exchange containing the exchange nanem to subscribe to.\n * - patterns-push-filter containing a topic filter including dot-seperated namespaces and wildcards. A commonly used filter value would be the currently logged in user. This will subscribe only to updates for this specific user.\n * - patterns-push-login containing the name of a read only user on the message queue server used to connect.\n * - patterns-push-password containing the password of a read only user on the message queue server used to connect.\n */\nimport logging from \"./logging\";\n\nconst logger = logging.getLogger(\"core push kit\");\n\nconst push_kit = {\n    async init() {\n        const url = document.querySelector(\"meta[name=patterns-push-url]\")?.content;\n        const exchange = document.querySelector(\"meta[name=patterns-push-exchange]\")?.content; // prettier-ignore\n\n        if (!url || !exchange) {\n            return;\n        }\n\n        const topicfilter = document.querySelector(\"meta[name=patterns-push-filter]\")?.content; // prettier-ignore\n        const user_login = document.querySelector(\"meta[name=patterns-push-login]\")?.content; // prettier-ignore\n        const user_pass = document.querySelector(\"meta[name=patterns-push-password]\")?.content; // prettier-ignore\n\n        const StompJS = await import(\"@stomp/stompjs\");\n        const client = new StompJS.Client({\n            brokerURL: url,\n            connectHeaders: {\n                login: user_login,\n                passcode: user_pass,\n            },\n            debug: function (str) {\n                logger.debug(str);\n            },\n            reconnectDelay: 5000,\n            heartbeatIncoming: 0,\n            heartbeatOutgoing: 20000,\n        });\n\n        client.onConnect = () => {\n            if (exchange) {\n                client.subscribe(\n                    `/exchange/${exchange}/${topicfilter}.#`,\n                    this.on_push_marker.bind(this)\n                );\n            }\n        };\n\n        client.onStompError = (frame) => {\n            logger.error(\"Broker reported error: \" + frame.headers[\"message\"]);\n            logger.debug(\"Additional details: \" + frame.body);\n        };\n\n        client.activate();\n        logger.debug(\"StompJS push support initialised on \" + url);\n    },\n\n    on_push_marker(message) {\n        logger.debug(\"Received push marker: \", message);\n        if (!message || !message.body) {\n            return;\n        }\n        document.body.dispatchEvent(\n            new CustomEvent(\"push\", { detail: { body: message.body } })\n        );\n    },\n};\n\npush_kit.init();\n\nexport default push_kit;\n","/**\n * Patterns autoscale - scale elements to fit available space\n *\n * Copyright 2012 Humberto Sermeno\n * Copyright 2013 Simplon B.V. - Wichert Akkerman\n */\n\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nexport const parser = new Parser(\"auto-scale\");\nparser.addArgument(\"method\", \"scale\", [\"scale\", \"zoom\"]);\nparser.addArgument(\"size\", \"width\", [\"width\", \"height\", \"contain\", \"cover\"]);\nparser.addArgument(\"min-width\", 0);\nparser.addArgument(\"max-width\", 1000000);\nparser.addArgument(\"min-height\", 0);\nparser.addArgument(\"max-height\", 1000000);\n\nexport default Base.extend({\n    name: \"autoscale\",\n    trigger: \".pat-auto-scale\",\n    force_method: null,\n\n    init: function ($el, opts) {\n        this.options = parser.parse(this.$el, opts);\n        if (this.force_method !== null) {\n            this.options.method = this.force_method;\n        }\n        this._setup().scale();\n        return this.$el;\n    },\n\n    _setup: function () {\n        if (!utils.checkCSSFeature(\"zoom\")) {\n            // See https://bugzilla.mozilla.org/show_bug.cgi?id=390936\n            this.force_method = \"scale\";\n        }\n        var scaler = utils.debounce(this.scale.bind(this), 250);\n        $(window).on(\"resize.autoscale\", scaler);\n        $(document).on(\"pat-update.autoscale\", scaler);\n        return this;\n    },\n\n    scale: function () {\n        var available_space, scale, scaled_height, scaled_width, container;\n\n        if (this.$el[0].tagName === \"BODY\") {\n            container = this.$el[0];\n        } else {\n            if (this.$el.closest(\".auto-scale-wrapper\").length != 0) {\n                container = this.$el.closest(\".auto-scale-wrapper\").parent()[0];\n            } else {\n                container = this.$el.parent()[0];\n            }\n        }\n        if (!container) {\n            // Element has not been added to the DOM yet.\n            return;\n        }\n\n        var style = window.getComputedStyle(container);\n        available_space = {\n            width: parseInt(style.width, 10),\n            height: parseInt(style.height, 10),\n        };\n\n        available_space.width = Math.min(available_space.width, this.options.max.width);\n        available_space.width = Math.max(available_space.width, this.options.min.width);\n        available_space.height = Math.min(\n            available_space.height,\n            this.options.max.height\n        );\n        available_space.height = Math.max(\n            available_space.height,\n            this.options.min.height\n        );\n        switch (this.options.size) {\n            case \"width\":\n                scale = available_space.width / this.$el.outerWidth();\n                break;\n            case \"height\":\n                scale = available_space.height / this.$el.outerHeight();\n                break;\n            case \"contain\":\n                // Fit entire content on area, allowing for extra space\n                scale = Math.min(\n                    available_space.width / this.$el.outerWidth(),\n                    available_space.height / this.$el.outerHeight()\n                );\n                break;\n            case \"cover\":\n                // Covert entire area, possible clipping\n                scale = Math.max(\n                    available_space.width / this.$el.outerWidth(),\n                    available_space.height / this.$el.outerHeight()\n                );\n                break;\n            default:\n                return;\n        }\n\n        scaled_height = this.$el.outerHeight() * scale;\n        scaled_width = this.$el.outerWidth() * scale;\n\n        switch (this.options.method) {\n            case \"scale\":\n                this.$el.css(\"transform\", \"scale(\" + scale + \")\");\n                if (\n                    this.$el.parent().attr(\"class\") === undefined ||\n                    (this.$el.parent().attr(\"class\") != undefined &&\n                        $.inArray(\n                            \"auto-scale-wrapper\",\n                            this.$el.parent().attr(\"class\").split(/\\s+/)\n                        ) === -1)\n                ) {\n                    this.$el.wrap(\"<div class='auto-scale-wrapper'></div>\");\n                }\n                this.$el.parent().height(scaled_height).width(scaled_width);\n                break;\n            case \"zoom\":\n                this.$el.css(\"zoom\", scale);\n                break;\n        }\n        this.$el.addClass(\"scaled\");\n        return this;\n    },\n});\n","// helper functions to make all input elements\nimport $ from \"jquery\";\nimport logging from \"../core/logging\";\nvar namespace = \"input-change-events\";\nconst log = logging.getLogger(namespace);\n\nvar _ = {\n    setup: function ($el, pat) {\n        if (!pat) {\n            log.error(\"The name of the calling pattern has to be set.\");\n            return;\n        }\n        // list of patterns that installed input-change-event handlers\n        var patterns = $el.data(namespace) || [];\n        log.debug(\"setup handlers for \" + pat);\n\n        if (!patterns.length) {\n            log.debug(\"installing handlers\");\n            _.setupInputHandlers($el);\n\n            $el.on(\"patterns-injected.\" + namespace, function (event) {\n                _.setupInputHandlers($(event.target));\n            });\n        }\n        if (patterns.indexOf(pat) === -1) {\n            patterns.push(pat);\n            $el.data(namespace, patterns);\n        }\n    },\n\n    setupInputHandlers: function ($el) {\n        if (!$el.is(\":input\")) {\n            // We've been given an element that is not a form input. We\n            // therefore assume that it's a container of form inputs and\n            // register handlers for its children.\n            $el.findInclusive(\":input\").each(_.registerHandlersForElement);\n        } else {\n            // The element itself is an input, se we simply register a\n            // handler fot it.\n            _.registerHandlersForElement.bind($el)();\n        }\n    },\n\n    registerHandlersForElement: function () {\n        var $el = $(this),\n            isNumber = $el.is(\"input[type=number]\"),\n            isText = $el.is(\"input:text, input[type=search], textarea\");\n\n        if (isNumber) {\n            // for <input type=\"number\" /> we want to trigger the change\n            // on keyup\n            if (\"onkeyup\" in window) {\n                $el.on(\"keyup.\" + namespace, function () {\n                    log.debug(\"translating keyup\");\n                    $el.trigger(\"input-change\");\n                });\n            }\n        }\n        if (isText || isNumber) {\n            if (\"oninput\" in window) {\n                $el.on(\"input.\" + namespace, function () {\n                    log.debug(\"translating input\");\n                    $el.trigger(\"input-change\");\n                });\n            } else {\n                // this is the legacy code path for IE8\n                // Work around buggy placeholder polyfill.\n                if ($el.attr(\"placeholder\")) {\n                    $el.on(\"keyup.\" + namespace, function () {\n                        log.debug(\"translating keyup\");\n                        $el.trigger(\"input-change\");\n                    });\n                } else {\n                    $el.on(\"propertychange.\" + namespace, function (ev) {\n                        if (ev.originalEvent.propertyName === \"value\") {\n                            log.debug(\"translating propertychange\");\n                            $el.trigger(\"input-change\");\n                        }\n                    });\n                }\n            }\n        } else {\n            $el.on(\"change.\" + namespace, function () {\n                log.debug(\"translating change\");\n                $el.trigger(\"input-change\");\n            });\n        }\n\n        $el.on(\"blur\", function () {\n            $el.trigger(\"input-defocus\");\n        });\n    },\n\n    remove: function ($el, pat) {\n        var patterns = $el.data(namespace) || [];\n        if (patterns.indexOf(pat) === -1) {\n            log.warn(\"input-change-events were never installed for \" + pat);\n        } else {\n            patterns = patterns.filter(function (e) {\n                return e !== pat;\n            });\n            if (patterns.length) {\n                $el.data(namespace, patterns);\n            } else {\n                log.debug(\"remove handlers\");\n                $el.removeData(namespace);\n                $el.find(\":input\").off(\".\" + namespace);\n                $el.off(\".\" + namespace);\n            }\n        }\n    },\n};\n\nexport default _;\n","import \"../../core/jquery-ext\";\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport input_change_events from \"../../lib/input-change-events\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"autosubmit\");\n\nexport const parser = new Parser(\"autosubmit\");\n// - 400ms -> 400\n// - 400 -> 400\n// - defocus\nparser.addArgument(\"delay\", \"400ms\");\n\nexport default Base.extend({\n    name: \"autosubmit\",\n    trigger: \".pat-autosubmit, .pat-auto-submit\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n        if (this.options.delay !== \"defocus\") {\n            this.options.delay = parseInt(this.options.delay.replace(/[^\\d]*/g, \"\"), 10);\n        }\n\n        input_change_events.setup(this.$el, \"autosubmit\");\n        this.registerListeners();\n        this.registerTriggers();\n    },\n\n    registerListeners() {\n        this.$el.on(\n            \"input-change-delayed.pat-autosubmit\",\n            this.onInputChange.bind(this)\n        );\n        this.registerSubformListeners();\n        this.$el.on(\"patterns-injected\", this.refreshListeners.bind(this));\n        this.$el.on(\"pat-update\", (e, data) => {\n            // Refresh on some pat-update events.\n            if (\n                (data?.pattern === \"clone\" && data?.action === \"remove\") ||\n                data?.pattern === \"sortable\"\n            ) {\n                // Directly submit when removing a clone or changing the sorting.\n                this.$el.submit();\n                log.debug(\n                    `triggered by pat-update, pattern: ${data.pattern}, action: ${data.action}`\n                );\n            } else if (data?.pattern === \"clone\") {\n                // Refresh listeners on cloning.\n                this.refreshListeners(e, null, null, data.$el);\n            }\n        });\n    },\n\n    registerSubformListeners(ev) {\n        /* If there are subforms, we need to listen on them as well, so\n         * that only the subform gets submitted if an element inside it\n         * changes.\n         */\n        const $el = typeof ev !== \"undefined\" ? $(ev.target) : this.$el;\n        $el.find(\".pat-subform\")\n            .not(\".pat-autosubmit\")\n            .each((idx, el) => {\n                $(el).on(\n                    \"input-change-delayed.pat-autosubmit\",\n                    this.onInputChange.bind(this)\n                );\n            });\n    },\n\n    refreshListeners(ev, cfg, el, injected) {\n        this.registerSubformListeners();\n        // Register change event handlers for new inputs injected into this form\n        input_change_events.setup($(injected), \"autosubmit\");\n    },\n\n    registerTriggers() {\n        const isText = this.$el.is(\"input:text, input[type=search], textarea\");\n        if (this.options.delay === \"defocus\" && !isText) {\n            log.error(\n                \"The defocus delay value makes only sense on text input elements.\"\n            );\n            return this.$el;\n        }\n\n        function trigger_event(ev) {\n            if ($(ev.target).closest(\".pat-autosubmit\")[0] !== this) {\n                return;\n            }\n            $(ev.target).trigger(\"input-change-delayed\");\n        }\n        if (this.options.delay === \"defocus\") {\n            this.$el.on(\"input-defocus.pat-autosubmit\", trigger_event);\n        } else if (this.options.delay > 0) {\n            this.$el.on(\n                \"input-change.pat-autosubmit\",\n                utils.debounce(trigger_event, this.options.delay)\n            );\n        } else {\n            this.$el.on(\"input-change.pat-autosubmit\", trigger_event);\n        }\n    },\n\n    destroy($el) {\n        input_change_events.remove($el, \"autosubmit\");\n        if (this.$el.is(\"form\")) {\n            this.$el\n                .find(\".pat-subform\")\n                .addBack(this.$el)\n                .each((idx, el) => {\n                    $(el).off(\".pat-autosubmit\");\n                });\n        } else {\n            $el.off(\".pat-autosubmit\");\n        }\n    },\n\n    onInputChange(e) {\n        e.stopPropagation();\n        this.$el.submit();\n        log.debug(\"triggered by \" + e.type);\n    },\n});\n","import \"../../core/jquery-ext\";\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\n\nconst log = logging.getLogger(\"autosuggest\");\n\nexport const parser = new Parser(\"autosuggest\");\nparser.addArgument(\"ajax-data-type\", \"JSON\");\nparser.addArgument(\"ajax-search-index\", \"\");\nparser.addArgument(\"ajax-url\", \"\");\nparser.addArgument(\"allow-new-words\", true); // Should custom tags be allowed?\nparser.addArgument(\"max-selection-size\", 0);\nparser.addArgument(\"minimum-input-length\"); // Don't restrict by default so that all results show\nparser.addArgument(\"placeholder\", function ($el) {\n    return $el.attr(\"placeholder\") || undefined;\n});\nparser.addArgument(\"prefill\", function ($el) {\n    return $el.val();\n});\nparser.addArgument(\"prefill-json\", \"\"); // JSON format for pre-filling\nparser.addArgument(\"words\", \"\");\nparser.addArgument(\"words-json\");\n\n// \"selection-classes\" allows you to add custom CSS classes to currently\n// selected elements.\n// The value passed in must be an object with each id being the text inside\n// a selection and value being a list of classes to be added to the\n// selection.\n// e.g. {'BMW': ['selected', 'car'], 'BMX': ['selected', 'bicycle']}\nparser.addArgument(\"selection-classes\", \"\");\n\nparser.addAlias(\"maximum-selection-size\", \"max-selection-size\");\nparser.addAlias(\"data\", \"prefill-json\");\nparser.addAlias(\"pre-fill\", \"prefill\");\n\nexport default Base.extend({\n    name: \"autosuggest\",\n    trigger: \".pat-autosuggest,.pat-auto-suggest\",\n\n    async init() {\n        if (window.__patternslib_import_styles) {\n            import(\"select2/select2.css\");\n        }\n        await import(\"select2\");\n\n        this.options = parser.parse(this.el, this.options);\n\n        let config = {\n            tokenSeparators: [\",\"],\n            openOnEnter: false,\n            maximumSelectionSize: this.options.maxSelectionSize,\n            minimumInputLength: this.options.minimumInputLength,\n            allowClear:\n                this.options.maxSelectionSize === 1 && !this.el.hasAttribute(\"required\"),\n        };\n        if (this.el.hasAttribute(\"readonly\")) {\n            config.placeholder = \"\";\n        } else if (this.options.placeholder) {\n            config.placeholder = this.options.placeholder;\n        }\n\n        if (this.options.selectionClasses) {\n            // We need to customize the formatting/markup of the selection\n            config.formatSelection = (obj, container) => {\n                let selectionClasses = null;\n                try {\n                    selectionClasses = JSON.parse(this.options.selectionClasses)[\n                        obj.text\n                    ];\n                } catch (SyntaxError) {\n                    log.error(\n                        \"SyntaxError: non-JSON data given to pat-autosuggest (selection-classes)\"\n                    );\n                }\n                if (selectionClasses) {\n                    // According to Cornelis the classes need to be applied on\n                    // the <li>, which is the container's parent\n                    container.parent().addClass(selectionClasses.join(\" \"));\n                }\n                return obj.text;\n            };\n        }\n\n        if (this.el.tagName === \"INPUT\") {\n            config = this.create_input_config(config);\n        }\n        const $sel2 = this.$el.select2(config);\n\n        dom.hide(this.el); // hide input, but keep active (e.g. for validation)\n\n        this.$el.on(\"pat-update\", (e, data) => {\n            if (data?.pattern === \"depends\") {\n                if (data?.enabled === true) {\n                    this.$el.select2(\"enable\", true);\n                } else if (data?.enabled === false) {\n                    this.$el.select2(\"disable\", true);\n                }\n            }\n        });\n\n        // Allow pat-validate to check for validity when select2 was interacted\n        // with but no value selected.\n        const initiate_empty_check = () => {\n            const val = $sel2.select2(\"val\");\n            if (val?.length === 0) {\n                // catches \"\" and []\n                // blur the input field so that pat-validate can kick in when\n                // nothing was selected.\n                this.el.dispatchEvent(events.blur_event());\n            }\n        };\n        this.$el.on(\"select2-close\", initiate_empty_check.bind(this));\n        this.$el.on(\"select2-blur\", initiate_empty_check.bind(this));\n\n        this.$el.on(\"change\", () => {\n            // The jQuery \"change\" event isn't caught by normal JavaScript\n            // event listeners, e.g. in pat-validation.\n            // Let's re-trigger as input-event, so that pat-validation but also\n            // ``input-change-events`` can pick it up.\n            this.el.dispatchEvent(events.input_event());\n        });\n\n        // Clear values on reset.\n        events.add_event_listener(\n            this.el.closest(\"form\"),\n            \"reset\",\n            \"pat-auto-suggest--reset\",\n            () => this.$el.select2(\"val\", \"\")\n        );\n    },\n\n    create_input_config(config) {\n        let words = [];\n\n        config.createSearchChoice = (term, data) => {\n            if (this.options.allowNewWords) {\n                if (\n                    data.filter((el) => el.text.localeCompare(term) === 0).length === 0\n                ) {\n                    return { id: term, text: term };\n                }\n            } else {\n                return null;\n            }\n        };\n\n        if (this.options.wordsJson?.length) {\n            try {\n                words = JSON.parse(this.options.wordsJson);\n            } catch (SyntaxError) {\n                words = [];\n                log.error(\"SyntaxError: non-JSON data given to pat-autosuggest\");\n            }\n            if (!Array.isArray(words)) {\n                words = words.map((v, k) => {\n                    return { id: k, text: v };\n                });\n            }\n        }\n        if (this.options.words) {\n            words = this.options.words.split(/\\s*,\\s*/);\n            words = words.map((v) => {\n                return { id: v, text: v };\n            });\n        }\n\n        // Per Cornelis, if our max lenght is 1, we want select style. If it is larger, we want tag style\n        // Now this is somewhat fishy because so far, we always configured tag style by setting config.tags = words.\n        // Even if words was [], we would get a tag stylee select\n        // That was then properly working with ajax if configured.\n\n        if (this.options.maxSelectionSize === 1) {\n            config.data = words;\n            // We allow exactly one value, use dropdown styles. How do we feed in words?\n        } else {\n            // We allow multiple values, use the pill style - called tags in select 2 speech\n            config.tags = words;\n        }\n\n        if (this.options.prefill?.length) {\n            this.el.value = this.options.prefill.split(\",\");\n            config.initSelection = (element, callback) => {\n                let data = [];\n                const values = element.val().split(\",\");\n                for (const value of values) {\n                    data.push({ id: value, text: value });\n                }\n                if (this.options.maxSelectionSize === 1) {\n                    data = data[0];\n                }\n                callback(data);\n            };\n        }\n\n        if (this.options.prefillJson.length) {\n            /* We support two types of JSON data for prefill data:\n             *   {\"john-snow\": \"John Snow\", \"tywin-lannister\": \"Tywin Lannister\"}\n             * or\n             *   [\n             *    {\"id\": \"john-snow\", \"text\": \"John Snow\"},\n             *    {\"id\": \"tywin-lannister\", \"text\":\"Tywin Lannister\"}\n             *   ]\n             */\n            try {\n                const data = JSON.parse(this.options.prefillJson);\n                let ids = [];\n                for (const d in data) {\n                    if (typeof d === \"object\") {\n                        ids.push(d.id);\n                    } else {\n                        ids.push(d);\n                    }\n                }\n                this.el.value = ids;\n                config.initSelection = (element, callback) => {\n                    let _data = [];\n                    for (const d in data) {\n                        if (typeof d === \"object\") {\n                            _data.push({ id: d.id, text: d.text });\n                        } else {\n                            _data.push({ id: d, text: data[d] });\n                        }\n                    }\n                    if (this.options.maxSelectionSize === 1) {\n                        _data = _data[0];\n                    }\n                    callback(_data);\n                };\n            } catch (SyntaxError) {\n                log.error(\"SyntaxError: non-JSON data given to pat-autosuggest\");\n            }\n        }\n\n        if (this.options.ajax?.url) {\n            config = $.extend(\n                true,\n                {\n                    minimumInputLength: this.options.minimumInputLength,\n                    ajax: {\n                        url: this.options.ajax.url,\n                        dataType: this.options.ajax[\"data-type\"],\n                        type: \"GET\",\n                        quietMillis: 400,\n                        data: (term, page) => {\n                            return {\n                                index: this.options.ajax[\"search-index\"],\n                                q: term, // search term\n                                page_limit: 10,\n                                page: page,\n                            };\n                        },\n                        results: (data, page) => {\n                            // parse the results into the format expected by Select2.\n                            // data must be a list of objects with keys \"id\" and \"text\"\n                            return { results: data, page: page };\n                        },\n                    },\n                },\n                config\n            );\n        }\n        return config;\n    },\n\n    destroy($el) {\n        $el.off(\".pat-autosuggest\");\n        $el.select2(\"destroy\");\n    },\n});\n","import Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\n\nlet scheduled_task = null;\n\nexport default Base.extend({\n    name: \"autofocus\",\n    trigger: `\n        input.pat-autofocus,\n        input[autofocus],\n        select.pat-autofocus,\n        select[autofocus],\n        textarea.pat-autofocus,\n        textarea[autofocus],\n        button.pat-autofocus,\n        button[autofocus]\n    `,\n\n    init() {\n        if (window.self !== window.top) {\n            // Do not autofocus in iframes.\n            return;\n        }\n        this.set_focus();\n    },\n\n    set_focus() {\n        if (dom.is_visible(this.el) && this.el.value === \"\") {\n            // Set autofocus only for visible and empty inputs.\n\n            // Clear scheduled tasks if there are any.\n            // Note: Patterns scanning initizlizes patterns \"inside-out\", so\n            //       DOM nodes later in the tree are initizlized first.\n            //       With multiple pattern instantiations and then module-\n            //       globally clearing and re-scheduling tasks we are\n            //       initializing in the end the first pattern which matches\n            //       the conditions.\n            clearTimeout(scheduled_task);\n            scheduled_task = setTimeout(() => {\n                this.el.focus();\n                scheduled_task = null;\n            }, 100);\n        }\n    },\n});\n","/**\n * Patterns breadcrumbs - breadcrumb trails\n *\n * Copyright 2012-2013 Florian Friesdorf\n * Copyright 2012 Simplon B.V. - Wichert Akkerman\n */\n\nimport $ from \"jquery\";\nimport registry from \"../../core/registry\";\n\nvar _ = {\n    name: \"breadcrumbs\",\n    trigger: \"nav.pat-breadcrumbs\",\n    init: function ($el, opts) {\n        if ($el.length > 1) {\n            return $el.map(function () {\n                return _.init($(this), opts);\n            });\n        }\n\n        // wrap elements in a DIV that will be shifted around\n        var $content = $el\n            .children()\n            .wrapAll(\"<div class='pat-breadcrumbs-content'></div>\")\n            .parent();\n\n        // shift ctrl\n        var $ctrl = $(\"<span class='button shift'>shift</span>\").prependTo($el);\n\n        var shifted = false,\n            shifting = false,\n            difference = 0;\n        var shifter = function (toggle) {\n            return function () {\n                var margin;\n                if (toggle) {\n                    margin = shifted ? 0 : difference;\n                    $content.animate({ \"margin-left\": margin }, function () {\n                        $ctrl.toggleClass(\"shift-right shift-left\");\n                        shifted = !shifted;\n                    });\n                } else {\n                    margin = shifted ? difference : 0;\n                    $content.css({ \"margin-left\": margin });\n                }\n            };\n        };\n\n        var maybeshift = function () {\n            // account for other stuff on the same line (100px)\n            difference = $el.innerWidth() - $content.width() - 100;\n\n            if (difference < 0) {\n                // we should be shifting\n                if (!shifting) {\n                    shifting = true;\n                    $el.addClass(\"shifting\");\n                    $ctrl.removeClass(\"shift-right\");\n                    $ctrl.addClass(\"shift-left\");\n                    $ctrl.on(\"click.pat-breadcrumbs\", shifter(true));\n                    $ctrl.click();\n                } else {\n                    // a shifter that keeps state\n                    shifter(false)();\n                }\n            } else {\n                // we should not be shifting\n                if (shifting) {\n                    $content.animate({ \"margin-left\": 0 }, function () {\n                        shifted = false;\n                        shifting = false;\n                        $el.removeClass(\"shifting\");\n                        $ctrl.removeClass(\"shift-left shift-right\");\n                        $ctrl.off(\".pat-breadcrumbs\");\n                    });\n                }\n            }\n        };\n        $(window).on(\"resize.pat-breadcrumbs\", maybeshift);\n\n        var recalculate = function () {\n            // set fixed width on content\n            var width = $content\n                .children()\n                .toArray()\n                .reduce(function (acc, el) {\n                    // outerWidth is buggy http://bugs.jquery.com/ticket/8443 so\n                    // add a magic buffer value of 5.\n                    // XXX: maybe make the buffer configurable.\n                    return acc + $(el).outerWidth(true) + 5;\n                }, 0);\n            $content.width(width);\n            maybeshift();\n        };\n        $el.on(\"pat-breadcrumbs-changed.pat-breadcrumbs\", recalculate);\n        recalculate();\n\n        return $el;\n    },\n    destroy: function ($el) {\n        $el.off(\".pat-breadcrumbs\");\n    },\n};\nregistry.register(_);\n\nexport default _;\n","/**\n * Patterns bumper - Add bumping classes for sticky elements.\n */\n\nimport Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nconst logger = logging.getLogger(\"tabs\");\n\nexport const parser = new Parser(\"bumper\");\nparser.addArgument(\"selector\");\nparser.addArgument(\"bump-add\", \"bumped\");\nparser.addArgument(\"bump-remove\");\nparser.addArgument(\"unbump-add\");\nparser.addArgument(\"unbump-remove\", \"bumped\");\n\nexport default Base.extend({\n    name: \"bumper\",\n    trigger: \".pat-bumper\",\n\n    async init() {\n        // Based on: https://davidwalsh.name/detect-sticky\n\n        if (!utils.checkCSSFeature(\"position\", \"sticky\")) {\n            // IE11\n            logger.warn(\"No position sticky support.\");\n            return;\n        }\n\n        this.options = parser.parse(this.el, this.options);\n\n        this.target_element = this.options.selector\n            ? document.querySelector(this.options.selector)\n            : this.el;\n\n        // wait for next repaint for things to settle.\n        // e.g. CSS applied for injected content.\n        await utils.timeout(1);\n        this._init();\n    },\n\n    _init() {\n        const scroll_container_y = dom.find_scroll_container(\n            this.el.parentElement,\n            \"y\",\n            null\n        );\n        const scroll_container_x = dom.find_scroll_container(\n            this.el.parentElement,\n            \"x\",\n            null\n        );\n\n        const pos = {\n            top: dom.get_css_value(this.el, \"top\", true),\n            right: dom.get_css_value(this.el, \"right\", true),\n            bottom: dom.get_css_value(this.el, \"bottom\", true),\n            left: dom.get_css_value(this.el, \"left\", true),\n        };\n        const intersection_observer_config = {\n            threshold: [1, 0.99, 0.97, 0.96, 0.95, 0.94, 0.93, 0.92, 0.91, 0.9],\n            // add margin as inverted sticky positions.\n            rootMargin: `${-pos.top - 1}px ${-pos.right - 1}px ${-pos.bottom - 1}px ${-pos.left - 1}px`, // prettier-ignore\n        };\n\n        const observer_y = new IntersectionObserver(\n            this._intersection_observer_callback.bind(this),\n            {\n                ...intersection_observer_config,\n                root: scroll_container_y,\n            }\n        );\n        observer_y.observe(this.el);\n\n        if (scroll_container_x !== scroll_container_y) {\n            const observer_x = new IntersectionObserver(\n                this._intersection_observer_callback.bind(this),\n                {\n                    ...intersection_observer_config,\n                    root: scroll_container_x,\n                }\n            );\n            observer_x.observe(this.el);\n        }\n    },\n\n    _intersection_observer_callback(entries) {\n        const el = this.target_element;\n        for (const entry of entries) {\n            if (entry.intersectionRatio < 1) {\n                if (this.options.bump.add) {\n                    el.classList.add(this.options.bump.add);\n                }\n                if (this.options.bump.remove) {\n                    el.classList.remove(this.options.bump.remove);\n                }\n\n                const root = entry.rootBounds;\n                if (!root) {\n                    // No root found - e.g. CSS not fully applied when scroll\n                    // container was searched - as can happen as a corner case\n                    // after injecting content and initializing this pattern in\n                    // the same repaint cycle.\n                    // This is actually prevented by the 1ms timeout in the\n                    // init method.\n                    return;\n                }\n                const bounds = entry.boundingClientRect;\n\n                if (bounds.left <= root.left) {\n                    el.classList.add(\"bumped-left\");\n                } else {\n                    el.classList.remove(\"bumped-left\");\n                }\n                if (bounds.top <= root.top) {\n                    el.classList.add(\"bumped-top\");\n                } else {\n                    el.classList.remove(\"bumped-top\");\n                }\n                if (bounds.right >= root.right) {\n                    el.classList.add(\"bumped-right\");\n                } else {\n                    el.classList.remove(\"bumped-right\");\n                }\n                if (bounds.bottom >= root.bottom) {\n                    el.classList.add(\"bumped-bottom\");\n                } else {\n                    el.classList.remove(\"bumped-bottom\");\n                }\n            } else {\n                if (this.options.unbump.add) {\n                    el.classList.add(this.options.unbump.add);\n                }\n                if (this.options.unbump.remove) {\n                    el.classList.remove(this.options.unbump.remove);\n                }\n                el.classList.remove(\"bumped-left\");\n                el.classList.remove(\"bumped-top\");\n                el.classList.remove(\"bumped-right\");\n                el.classList.remove(\"bumped-bottom\");\n            }\n        }\n    },\n});\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport events from \"../../core/events\";\nimport inject from \"../inject/inject\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\n// Initialize close-panel functionality.\nimport \"../close-panel/close-panel\";\n\nexport const parser = new Parser(\"modal\");\nparser.addArgument(\"class\");\nparser.addArgument(\"closing\", [\"close-button\"], [\"close-button\", \"outside\"], true);\nparser.addArgument(\"close-text\", \"Close\");\nparser.addArgument(\"panel-header-content\", \":first:not(.header)\");\nparser.addArgument(\"source\", null); // If not given, the href should specify the source via a url fragment.\nparser.addArgument(\"target\", \"#pat-modal\");\n\nexport default Base.extend({\n    name: \"modal\",\n    jquery_plugin: true,\n    // div's are turned into modals\n    // links, forms and subforms inject modals\n    trigger: \"div.pat-modal, a.pat-modal, form.pat-modal, .pat-modal.pat-subform\",\n\n    init($el, opts, trigger) {\n        if (window.__patternslib_import_styles) {\n            import(\"./_modal.scss\");\n        }\n\n        this.options = parser.parse(this.$el, opts);\n        if (trigger && trigger.type === \"injection\") {\n            $.extend(this.options, parser.parse($(trigger.element), {}, false, false));\n        }\n        if (this.$el.is(\"div\")) {\n            this._init_div1();\n        } else {\n            this._init_inject1();\n        }\n    },\n\n    _init_inject1() {\n        // This will get remote content via pat-inject, add the pat-modal class\n        // to the result and pat-inject's pattern scanning will then call\n        // ``_init_div1``.\n\n        const opts = {\n            ...(this.options.source && { source: this.options.source }),\n            target: this.options.target,\n            class:\n                \"pat-modal\" + (this.options[\"class\"] ? \" \" + this.options[\"class\"] : \"\"),\n        };\n        if (this.options.url) {\n            opts.url = this.options.url;\n        }\n        if (this.options.trigger) {\n            opts.trigger = this.options.trigger;\n        }\n\n        // if $el is already inside a modal, do not detach #pat-modal,\n        // because this would unnecessarily close the modal itself\n        if (!this.$el.closest(\"#pat-modal\")) {\n            $(\"#pat-modal\").detach();\n        }\n        this.$el.on(\"pat-inject-missingSource pat-inject-missingTarget\", () => {\n            $(\"#pat-modal\").detach();\n        });\n\n        inject.init(this.$el, opts);\n    },\n\n    _init_div1() {\n        // This is always called and will inject the modal in the page.\n\n        const header = document.createElement(\"div\");\n        header.setAttribute(\"class\", \"header\");\n\n        if (this.options.closing.indexOf(\"close-button\") !== -1) {\n            header.innerHTML = `<button type=\"button\" class=\"close-panel\">${this.options.closeText}</button>`;\n            registry.scan(header, [\"close-panel\"]); // initialize close-panel\n        }\n\n        // We cannot handle text nodes here\n        let $children;\n        if (this.options.panelHeaderContent === \"none\") {\n            $children = this.$el.children();\n        } else {\n            $children = this.$el.children(\n                \":last, :not(\" + this.options.panelHeaderContent + \")\"\n            );\n        }\n\n        if ($children.length) {\n            $children.wrapAll(\"<div class='panel-content' />\");\n        } else {\n            this.$el.append(\"<div class='panel-content' />\");\n        }\n        this.$el.children(\".panel-content\").before(header);\n        this.$el.children(this.options.panelHeaderContent).prependTo(header);\n\n        // Restore focus in case the active element was a child of $el and\n        // the focus was lost during the wrapping.\n        // Only if we have an activeElement, as IE10/11 can have undefined as activeElement\n        if (document.activeElement) {\n            document.activeElement.focus();\n        }\n\n        this._init_handlers();\n        this.resize();\n        this.setPosition();\n\n        $(\"body\").addClass(\"modal-active\");\n        this.el.dispatchEvent(\n            new Event(\"pat-modal-ready\", { bubbles: true, cancelable: true })\n        );\n    },\n\n    _init_handlers() {\n        events.add_event_listener(this.el, \"close-panel\", \"pat-modal--close-panel\", () =>\n            this.destroy()\n        );\n\n        $(document).on(\"keyup.pat-modal\", this._onKeyUp.bind(this));\n        if (this.options.closing.indexOf(\"outside\") !== -1) {\n            $(document).on(\"click.pat-modal\", this._onPossibleOutsideClick.bind(this));\n        }\n        $(window).on(\n            \"resize.pat-modal-position\",\n            utils.debounce(this.resize.bind(this), 400)\n        );\n        $(document).on(\n            \"pat-inject-content-loaded.pat-modal-position\",\n            \"#pat-modal\",\n            utils.debounce(this.resize.bind(this), 400)\n        );\n        $(document).on(\n            \"patterns-injected.pat-modal-position\",\n            \"#pat-modal,div.pat-modal\",\n            utils.debounce(this.resize.bind(this), 400)\n        );\n        $(document).on(\n            \"pat-update.pat-modal-position\",\n            \"#pat-modal,div.pat-modal\",\n            utils.debounce(this.resize.bind(this), 50)\n        );\n    },\n\n    _onPossibleOutsideClick(ev) {\n        if (this.$el.has(ev.target)) {\n            this.destroy();\n        }\n    },\n\n    _onKeyUp(ev) {\n        if (ev.which === 27) {\n            this.destroy();\n        }\n    },\n\n    getTallestChild() {\n        let $tallest_child;\n        for (const child of $(\"*\", this.$el)) {\n            const $child = $(child);\n            if (typeof $tallest_child === \"undefined\") {\n                $tallest_child = $child;\n            } else if ($child.outerHeight(true) > $tallest_child.outerHeight(true)) {\n                $tallest_child = $child;\n            }\n        }\n        return $tallest_child;\n    },\n\n    setPosition() {\n        this.$el.css(\"top\", ($(window).innerHeight() - this.$el.height()) / 2);\n    },\n\n    resize() {\n        // reset the height before setting a new one\n        this.$el.removeClass(\"max-height\").css(\"height\", \"\");\n\n        const panel_content_elem = this.$el.find(\".panel-content\");\n        const header_elem = this.$el.find(\".header\");\n        const modal_height =\n            panel_content_elem.outerHeight(true) + header_elem.outerHeight(true);\n        if (this.$el.height() < modal_height) {\n            this.$el.addClass(\"max-height\").css({ height: modal_height + \"px\" });\n            this.setPosition();\n        }\n    },\n\n    async destroy() {\n        await utils.timeout(1); // wait a tick for event handlers (e.g. form submit) have a chance to kick in first.\n        $(document).off(\".pat-modal\");\n        this.$el.remove();\n        $(\"body\").removeClass(\"modal-active\");\n        $(\"body\").removeClass(\"modal-panel\");\n    },\n});\n","import Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\nimport logging from \"../../core/logging\";\nimport Modal from \"../modal/modal\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\nimport store from \"../../core/store\";\n\nconst log = logging.getLogger(\"calendar\");\nexport const parser = new Parser(\"calendar\");\n\nparser.addArgument(\"calendar-controls\", null); // Calendar controls must have \"id\" attr set\nparser.addArgument(\"category-controls\", null);\nparser.addArgument(\"column-day\", \"dddd M/d\");\nparser.addArgument(\"column-month\", \"ddd\");\nparser.addArgument(\"column-week\", \"ddd M/d\");\nparser.addArgument(\"initial-date\", null);\nparser.addArgument(\"initial-view\", \"month\", [\n    // Simple names\n    \"month\",\n    \"week\",\n    \"day\",\n    \"list\",\n    // FC 5 names\n    \"dayGridMonth\",\n    \"dayGridWeek\",\n    \"dayGridDay\",\n    \"timeGridWeek\",\n    \"timeGridDay\",\n    \"listDay\",\n    \"listWeek\",\n    \"listMonth\",\n    \"listYear\",\n    \"listWeek\",\n    // FC 3 names\n    \"basicWeek\",\n    \"basicDay\",\n    \"agendaWeek\",\n    \"agendaDay\",\n]);\nparser.addArgument(\"drag-and-drop\", true, [true, false]);\nparser.addArgument(\"drop-external-events\", true, [true, false]);\nparser.addArgument(\"external-event-selector\", \"\");\nparser.addArgument(\"first-day\", null);\nparser.addArgument(\"first-hour\", \"6\");\nparser.addArgument(\"height\", \"auto\");\nparser.addArgument(\"ignore-url\", false);\nparser.addArgument(\"lang\", null); // If not set, use \"en\" (See below)\nparser.addArgument(\"store\", \"none\", [\"none\", \"session\", \"local\"]);\nparser.addArgument(\"time-format\", \"24h\", [\"24h\", \"12h\"]);\nparser.addArgument(\"timezone\", null);\nparser.addArgument(\"title-day\", \"dddd, MMM d, YYYY\");\nparser.addArgument(\"title-month\", \"MMMM YYYY\");\nparser.addArgument(\"title-week\", \"MMM D YYYY\");\nparser.addArgument(\"event-color\", \"blue\");\n\nparser.addArgument(\"url\", null);\nparser.addArgument(\"event-sources\", [], undefined, true);\n//parser.addArgument(\"add-url\", null);\n\n// pat-inject support for individual events\nparser.addArgument(\"pat-inject-source\", null);\nparser.addArgument(\"pat-inject-target\", null);\n\n// pat-modal support for individual events\nparser.addArgument(\"pat-modal-class\", null);\n\n// pat-tooltip support for individual events\nparser.addArgument(\"pat-tooltip-source\", null, [\"ajax\", null]);\n\n// pat-switch support for individual events\nparser.addArgument(\"pat-switch-selector\", null);\nparser.addArgument(\"pat-switch-remove\", null);\nparser.addArgument(\"pat-switch-add\", null);\n\nparser.addAlias(\"default-date\", \"initial-date\");\nparser.addAlias(\"default-view\", \"initial-view\");\n\nexport default Base.extend({\n    name: \"calendar\",\n    trigger: \".pat-calendar\",\n    classMap: {\n        month: \".view-month\",\n        agendaWeek: \".view-week\",\n        agendaDay: \".view-day\",\n    },\n    viewMap: {\n        month: \"dayGridMonth\",\n        week: \"timeGridWeek\",\n        day: \"timeGridDay\",\n        list: \"listMonth\",\n        basicWeek: \"dayGridWeek\",\n        basicDay: \"dayGridDay\",\n        agendaWeek: \"timeGridWeek\",\n        agendaDay: \"timeGridDay\",\n    },\n    dayNames: [\"su\", \"mo\", \"tu\", \"we\", \"th\", \"fr\", \"sa\"],\n    active_categories: null,\n    parser: parser,\n\n    async init() {\n        this.options = store.updateOptions(this.el, parser.parse(this.el, this.options));\n\n        const Calendar = (await import(\"@fullcalendar/core\")).Calendar;\n        const fcDayGrid = (await import(\"@fullcalendar/daygrid\")).default;\n        const fcInteraction = (await import(\"@fullcalendar/interaction\")).default;\n        const fcList = (await import(\"@fullcalendar/list\")).default;\n        const fcLuxon = (await import(\"@fullcalendar/luxon2\")).default;\n        const fcTimeGrid = (await import(\"@fullcalendar/timegrid\")).default;\n\n        // Save some UI elements for reuse.\n        const calendar_controls = this.options.calendarControls\n            ? document.querySelector(this.options.calendarControls)\n            : this.el;\n        this.el_jump_next = calendar_controls.querySelector(\".jump-next\");\n        this.el_jump_prev = calendar_controls.querySelector(\".jump-prev\");\n        this.el_jump_today = calendar_controls.querySelector(\".jump-today\");\n        this.el_view_month = calendar_controls.querySelector(\".view-month\");\n        this.el_view_week = calendar_controls.querySelector(\".view-week\");\n        this.el_view_day = calendar_controls.querySelector(\".view-day\");\n        this.el_view_list_year = calendar_controls.querySelector(\".view-listYear\");\n        this.el_view_list_month = calendar_controls.querySelector(\".view-listMonth\");\n        this.el_view_list_week = calendar_controls.querySelector(\".view-listWeek\");\n        this.el_view_list_day = calendar_controls.querySelector(\".view-listDay\");\n        this.el_timezone = calendar_controls.querySelector(\"select[name='timezone']\");\n        this.el_title =\n            this.el.querySelector(\".cal-title\") ||\n            calendar_controls.querySelector(\".cal-title\");\n\n        const storage_prefix = `${this.name}-${window.location.pathname}`;\n        this.storage =\n            this.options.store === \"none\"\n                ? null\n                : store[this.options.store](storage_prefix);\n\n        const query_string = new URLSearchParams(window.location.search);\n\n        const config = {};\n        config.headerToolbar = false;\n        config.initialDate =\n            query_string.get(\"date\") ||\n            this.storage?.get?.(\"date\") ||\n            this.options.initial.date;\n        config.initialView =\n            query_string.get(\"view\") ||\n            this.storage?.get?.(\"view\") ||\n            this.options.initial.view;\n        config.initialView = this.viewMap[config.initialView] || config.initialView;\n        config.editable = this.options.editable || false;\n        config.plugins = [fcDayGrid, fcInteraction, fcList, fcLuxon, fcTimeGrid];\n        config.eventColor = this.options.eventColor;\n\n        let lang = this.options.lang || dom.acquire_attribute(this.el, \"lang\") || \"en\";\n        // we don't support any country-specific language variants, always use first 2 letters\n        lang = lang.substr(0, 2).toLowerCase();\n        if (lang !== \"en\") {\n            const locale = await import(`@fullcalendar/core/locales/${lang}.js`);\n            config.locale = locale.default;\n            log.debug(`Loaded locale for ${lang}`);\n        }\n        if (this.options.first.day !== null) {\n            config.firstDay = this.options.first.day;\n            if (this.dayNames.indexOf(this.options.first.day) >= 0) {\n                // Set firstDay as string\n                config.firstDay = this.dayNames.indexOf(this.options.first.day);\n            }\n        }\n\n        let timezone = this.el_timezone?.value || this.options.timezone || null;\n        if (timezone) {\n            config.timeZone = timezone;\n        }\n\n        if (this.options.timeFormat == \"12h\") {\n            // 12h format\n            config.eventTimeFormat = {\n                hour12: true,\n                meridiem: \"narrow\",\n                hour: \"numeric\",\n            };\n        } else {\n            // 24h format\n            config.eventTimeFormat = {\n                hour12: false,\n                meridiem: \"false\",\n                hour: \"numeric\",\n            };\n        }\n\n        const sources = [...(this.options.event.sources || [])];\n        if (this.options.url && !sources.includes(this.options.url)) {\n            // add, but do not re-add same source twice.\n            sources.push(this.options.url);\n        }\n        config.eventSources = [];\n        for (const [idx, url] of sources.entries()) {\n            const src = this.create_event_source(idx, url);\n            config.eventSources.push(src);\n        }\n\n        // Restore category controls from local storage before showing events.\n        this._restoreCategoryControls();\n        this._registerCategoryControls();\n        this.reset_active_categories();\n        config.eventDidMount = (args) => this.init_event(args);\n\n        // Need to create a sub-element of ``pat-calendar`` to allow custom\n        // controls within pat-calendar to not be overwritten.\n        const cal_el = document.createElement(\"div\");\n        cal_el.setAttribute(\"class\", \"pat-calendar__fc\");\n        this.el.appendChild(cal_el);\n\n        if (this.options.addUrl) {\n            config.dateClick = this.addNewEvent.bind(this);\n            // Create a element for modals/injections\n            this.mod_el = document.createElement(\"section\");\n            this.mod_el.setAttribute(\"class\", \"pat-calendar__modal\");\n            this.el.appendChild(this.mod_el);\n        }\n\n        let calendar = (this.calendar = new Calendar(cal_el, config));\n        calendar.render();\n\n        calendar.on(\"datesSet\", this._viewChanged.bind(this));\n        calendar.on(\"dateClick\", this._viewChanged.bind(this));\n\n        if (this.el_title) {\n            this.el_title.innerHTML = calendar.view.title;\n        }\n\n        this._registerCalendarControls();\n        this.setActiveClasses();\n    },\n\n    create_event_source(idx, url) {\n        return {\n            id: `event-source--${idx + 1}`,\n            events: (info, success, failure) =>\n                this._fetch_events(url, info, success, failure),\n            className: `event-source--${idx + 1}`,\n        };\n    },\n\n    event_mapper(event) {\n        // Maps backend results to the fullcalendar event schema.\n        // Default implementation confirms to plone.restapi conventions.\n        const ret = {\n            id: event.UID,\n            title: event.title,\n            start: new Date(event.start),\n            end: new Date(event.end),\n            allDay: event.whole_day,\n            url: event.url || event[\"@id\"],\n\n            backgroundColor: event.color,\n            borderColor: event.color,\n            classNames: event.class ? event.class.split(\" \") : [],\n\n            // non fullcalendar standard fields\n            description: event.description,\n            text: event.text,\n            location: event.location,\n            open_end: event.open_end,\n            recurrence: event.recurrence,\n            attendees: event.attendees,\n            contact_name: event.contact_name,\n            contact_phone: event.contact_phone,\n            contact_email: event.contact_email,\n            event_url: event.event_url,\n        };\n        for (const prop in ret) {\n            if (!ret[prop]) {\n                delete ret[prop];\n            }\n        }\n        return ret;\n    },\n\n    update_event(event, data) {\n        // Updated an existing event with new event properties.\n        event.setDates(data.start, data.end);\n        event.setAllDay(data.allDay);\n        event.setProp(\"id\", data.id);\n        event.setProp(\"title\", data.title);\n        event.setProp(\"url\", data.url);\n\n        event.setProp(\"backgroundColor\", data.color);\n        event.setProp(\"borderColor\", data.color);\n\n        event.setExtendedProp(\"description\", data.description);\n        event.setExtendedProp(\"text\", data.text);\n        event.setExtendedProp(\"location\", data.location);\n        event.setExtendedProp(\"open_end\", data.open_end);\n        event.setExtendedProp(\"recurrence\", data.recurrence);\n        event.setExtendedProp(\"attendees\", data.attendees);\n        event.setExtendedProp(\"contact_name\", data.contact_name);\n        event.setExtendedProp(\"contact_phone\", data.contact_phone);\n        event.setExtendedProp(\"contact_email\", data.contact_email);\n        event.setExtendedProp(\"event_url\", data.event_url);\n    },\n\n    async _fetch_events(url, info, success, failure) {\n        let results = [];\n        while (url) {\n            url = url\n                .replace(\"${start_str}\", info.startStr.split(\"T\")[0])\n                .replace(\"${end_str}\", info.endStr.split(\"T\")[0]);\n\n            let response;\n            try {\n                response = await fetch(url, {\n                    method: \"GET\",\n                    mode: \"cors\",\n                    headers: {\n                        \"Accept\": \"application/json\",\n                        \"Content-Type\": \"application/json\",\n                    },\n                });\n            } catch (e) {\n                failure(e);\n                return;\n            }\n            let result = await response.json();\n            let results_ = result.items?.map(this.event_mapper) || [];\n            results = results.concat(results_);\n\n            // resolve all ``next`` batching urls\n            url = result.batching?.next || null;\n        }\n\n        success(results);\n    },\n\n    init_event(args) {\n        this.filter_event(args.event);\n\n        let do_scan = false;\n\n        // pat-inject support\n        const source = this.options.pat[\"inject-source\"];\n        const target = this.options.pat[\"inject-target\"];\n        if (args.event.url && (source || target)) {\n            // Only set pat-inject if event has a url\n            args.el.classList.add(\"pat-inject\");\n            args.el.setAttribute(\n                \"data-pat-inject\",\n                `target: ${target || \"body\"}; source: ${source || \"body\"}`\n            );\n            do_scan = true;\n        }\n\n        // pat-modal support\n        if (args.event.url && this.options.pat[\"modal-class\"]) {\n            // Only set pat-modal if event has a url\n            args.el.classList.add(\"pat-modal\");\n            args.el.setAttribute(\n                \"data-pat-modal\",\n                `class: ${this.options.pat[\"modal-class\"]}`\n            );\n            do_scan = true;\n        }\n\n        // pat-tooltip support\n        if (args.event.url && this.options.pat[\"tooltip-source\"] === \"ajax\") {\n            // Only set pat-tooltip if event has a url\n            args.el.classList.add(\"pat-tooltip\");\n            args.el.setAttribute(\"data-pat-tooltip\", \"source: ajax\");\n            do_scan = true;\n        }\n\n        // pat-switch support\n        const switch_sel = this.options.pat[\"switch-selector\"];\n        if (switch_sel) {\n            const switch_add = this.options.pat[\"switch-add\"];\n            const switch_rm = this.options.pat[\"switch-remove\"];\n\n            args.el.classList.add(\"pat-switch\");\n            args.el.setAttribute(\n                \"data-pat-switch\",\n                `selector: ${switch_sel}${switch_add ? \"; add: \" + switch_add : \"\"}${\n                    switch_rm ? \"; remove: \" + switch_rm : \"\"\n                }`\n            );\n            do_scan = true;\n        }\n\n        if (do_scan) {\n            registry.scan(args.el);\n        }\n    },\n\n    filter_event(event) {\n        let show = true;\n        if (this.active_categories !== null) {\n            // intersection\n            show =\n                this.active_categories.filter((it) => event.classNames.includes(it))\n                    .length > 0;\n        }\n        if (show) {\n            event.setProp(\"display\", \"auto\");\n        } else {\n            event.setProp(\"display\", \"none\");\n        }\n    },\n\n    reset_active_categories() {\n        const ctrls = this.get_category_controls();\n        this.active_categories = null;\n        if (ctrls.length) {\n            this.active_categories = ctrls.filter((el) => el.checked).map((el) => el.id);\n        }\n        this.storage && this.storage.set(\"active_categories\", this.active_categories);\n    },\n\n    get_category_controls() {\n        const ctrl_containers = this.options.categoryControls\n            ? document.querySelectorAll(this.options.categoryControls)\n            : [this.el];\n        const ctrls = [];\n        for (const it of ctrl_containers) {\n            const inp = it.querySelectorAll(\"input[type=checkbox]\");\n            ctrls.push(...inp);\n        }\n        return [...new Set(ctrls)]; // do not return the same inputs multiple times\n    },\n\n    _registerCategoryControls() {\n        /* The \"category controls\" are checkboxes that cause different\n         * types of events to be shown or hidden.\n         */\n        let timer;\n        for (const ctrl of this.get_category_controls()) {\n            ctrl.addEventListener(\"change\", () => {\n                clearTimeout(timer); // Cancel scheduled filter runs\n                timer = setTimeout(() => {\n                    this.reset_active_categories();\n                    this.calendar.getEvents().map(this.filter_event.bind(this));\n                }, 50);\n            });\n        }\n    },\n\n    _restoreCategoryControls() {\n        /* Restore values of the category controls as stored in store.\n         * NOTE: run BEFORE _registerCalendarControls\n         */\n        const ctrls = this.get_category_controls();\n        const active_categories =\n            (this.storage && this.storage.get(\"active_categories\")) || null;\n\n        if (!ctrls.length || active_categories === null) {\n            // No category controls or never set, use default un/checked status.\n            return;\n        }\n\n        for (const ctrl of ctrls) {\n            if (ctrl.hidden) {\n                // Do not set non-user-interactable inputs.\n                // They are programmatically set.\n                continue;\n            }\n            if (active_categories.includes(ctrl.id)) {\n                ctrl.checked = true;\n            } else {\n                ctrl.checked = false;\n            }\n            ctrl.dispatchEvent(new Event(\"change\", { bubbles: true, cancelable: true }));\n        }\n    },\n\n    _registerCalendarControls() {\n        this.el_jump_next?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.next();\n        });\n\n        this.el_jump_prev?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.prev();\n        });\n\n        this.el_jump_today?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.today();\n        });\n\n        this.el_view_month?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"dayGridMonth\");\n        });\n\n        this.el_view_week?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"timeGridWeek\");\n        });\n\n        this.el_view_day?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"timeGridDay\");\n        });\n\n        this.el_view_list_year?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"listYear\");\n        });\n\n        this.el_view_list_month?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"listMonth\");\n        });\n\n        this.el_view_list_week?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"listWeek\");\n        });\n\n        this.el_view_list_day?.addEventListener(\"click\", (event) => {\n            event.preventDefault();\n            this.calendar.changeView(\"listDay\");\n        });\n\n        this.el_timezone?.addEventListener(\"change\", (event) => {\n            event.preventDefault();\n            this.calendar.setOption(\"timeZone\", event.target.value);\n        });\n    },\n\n    setActiveClasses() {\n        // Set active classes of UI elements.\n\n        this.el_jump_today?.classList.remove(\"active\");\n        this.el_view_month?.classList.remove(\"active\");\n        this.el_view_week?.classList.remove(\"active\");\n        this.el_view_day?.classList.remove(\"active\");\n        this.el_view_list_year?.classList.remove(\"active\");\n        this.el_view_list_month?.classList.remove(\"active\");\n        this.el_view_list_week?.classList.remove(\"active\");\n        this.el_view_list_day?.classList.remove(\"active\");\n\n        const cdate = this.calendar.currentData.currentDate;\n        const today = new Date();\n        if (\n            cdate.getYear() === today.getYear() &&\n            cdate.getMonth() === today.getMonth() &&\n            cdate.getDate() === today.getDate()\n        ) {\n            this.el_jump_today?.classList.add(\"active\");\n        }\n\n        switch (this.calendar.view.type) {\n            case \"dayGridMonth\":\n                this.el_view_month?.classList.add(\"active\");\n                break;\n            case \"timeGridWeek\":\n                this.el_view_week?.classList.add(\"active\");\n                break;\n            case \"timeGridDay\":\n                this.el_view_day?.classList.add(\"active\");\n                break;\n            case \"listYear\":\n                this.el_view_list_year?.classList.add(\"active\");\n                break;\n            case \"listMonth\":\n                this.el_view_list_month?.classList.add(\"active\");\n                break;\n            case \"listWeek\":\n                this.el_view_list_week?.classList.add(\"active\");\n                break;\n            case \"listDay\":\n                this.el_view_list_day?.classList.add(\"active\");\n                break;\n        }\n    },\n\n    _viewChanged(data) {\n        // Set title\n        if (this.el_title) {\n            this.el_title.innerHTML = data.view.title;\n        }\n        // store current date and view\n        const date = data.view.currentStart.toISOString();\n        const view = data.view.type;\n        this.storage && this.storage.set(\"date\", date);\n        this.storage && this.storage.set(\"view\", view);\n\n        const query = new URLSearchParams(window.location.search);\n        query.set(\"date\", date);\n        query.set(\"view\", view);\n        history.replaceState(null, null, \"?\" + query.toString());\n\n        this.setActiveClasses();\n    },\n\n    async addNewEvent(info) {\n        let addUrl = this.options.addUrl;\n        if (!addUrl) {\n            return;\n        }\n\n        let start, end, allDay;\n        if (this.calendar.view.type === \"timeGridMonth\") {\n            start = info.date;\n            end = info.date;\n            allDay = true;\n        } else {\n            start = info.date;\n            end = new Date(start.getTime() + 1 * 60 * 60 * 1000); // same as start, 1h offset\n            allDay = false;\n        }\n        addUrl = addUrl\n            .replace(\"${start_str}\", start)\n            .replace(\"${end_str}\", end)\n            .replace(\"${all_day}\", allDay ? \"1\" : \"0\");\n\n        const event = this.calendar.addEvent(\n            {\n                title: \"New Event\",\n                start: start,\n                end: end,\n            },\n            true\n        );\n\n        await new Modal(this.mod_el, {\n            url: addUrl,\n            trigger: \"autoload\",\n        });\n\n        //const mod_el = document.querySelector(\"#pat-modal form\");\n        //mod_el.addEventListener(\"submit\", (e) => {\n        document.addEventListener(\"submit\", async (e) => {\n            const form = e.target;\n            const form_data = new FormData(form);\n            try {\n                const response = await fetch(form.action, {\n                    method: form.method,\n                    headers: {\n                        \"Content-Type\": \"application/json\",\n                    },\n                    body: form_data,\n                });\n                let data = await response.json();\n                data = this.event_mapper(data);\n                this.update_event(event, data);\n            } catch (error) {\n                log.error(error);\n                event.remove();\n            }\n        });\n    },\n});\n","/**\n * Patterns carousel\n *\n * Copyright 2017 Syslab.com GmbH Alexander Pilz\n */\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\n\nconst log = logging.getLogger(\"pat.carousel\");\n\nexport const parser = new Parser(\"carousel\");\nparser.addArgument(\"auto-play\", false);\nparser.addArgument(\"auto-play-speed\", 1000);\nparser.addArgument(\"speed\", 500);\nparser.addArgument(\"height\", \"fixed\");\nparser.addArgument(\"arrows\", \"show\");\nparser.addArgument(\"slides-to-show\", 1);\nparser.addArgument(\"slides-to-scroll\", 1);\nparser.addArgument(\"dots\", \"show\");\nparser.addArgument(\"append-dots\", \"\");\nparser.addArgument(\"infinite\", false);\n\nexport default Base.extend({\n    name: \"carousel\",\n    trigger: \".pat-carousel\",\n\n    async init() {\n        if (window.__patternslib_import_styles) {\n            import(\"slick-carousel/slick/slick.scss\");\n        }\n        await import(\"slick-carousel\");\n        const ImagesLoaded = (await import(\"imagesloaded\")).default;\n\n        this.options = parser.parse(this.el, this.options);\n        this.settings = {\n            autoplay: this.options.auto.play,\n            autoplaySpeed: this.options.auto[\"play-speed\"],\n            speed: this.options.speed,\n            adaptiveHeight: this.options.height === \"adaptive\",\n            arrows: this.options.arrows === \"show\",\n            slidesToShow: this.options.slides[\"to-show\"],\n            slidesToScroll: this.options.slides[\"to-scroll\"],\n            dots: this.options.dots === \"show\",\n            infinite: this.options.infinite,\n        };\n        if (this.options.appendDots) {\n            this.settings.appendDots = this.options.appendDots;\n        }\n\n        ImagesLoaded(this.el, () => this.setup());\n    },\n\n    setup() {\n        const $carousel = $(this.el).slick(this.settings);\n        let $panel_links = $();\n\n        $carousel\n            .children()\n            .each((index, obj) => {\n                if (!obj.id) {\n                    return;\n                }\n                var $links = $(\"a[href=#\" + obj.id + \"]\");\n                // TODO: fix this.\n                // eslint-disable-next-line no-undef\n                if (index === control.currentPage) {\n                    $links.addClass(\"current\");\n                } else {\n                    $links.removeClass(\"current\");\n                }\n                $links.on(\n                    \"click.pat-carousel\",\n                    null,\n                    // TODO: fix this.\n                    // eslint-disable-next-line no-undef\n                    { control: control, index: index },\n                    this.onPanelLinkClick.bind(this)\n                );\n                $panel_links = $panel_links.add($links);\n            })\n            .end()\n            .on(\n                \"slide_complete.pat-carousel\",\n                null,\n                $panel_links,\n                this.onSlideComplete.bind(this)\n            );\n    },\n\n    _loadPanelImages(slider, page) {\n        let $img;\n        log.info(\"Loading lazy images on panel \" + page);\n        slider.$items\n            .eq(page)\n            .find(\"img\")\n            .addBack()\n            .filter(\"[data-src]\")\n            .each((idx, img) => {\n                $img = $(img);\n                this.src = $img.attr(\"data-src\");\n                $img.removeAttr(\"data-src\");\n            });\n    },\n\n    onPanelLinkClick: function (event) {\n        event.data.control.gotoPage(event.data.index, false);\n        event.preventDefault();\n    },\n\n    onInitialized: function (event, slider) {\n        this._loadPanelImages(slider, slider.options.startPanel);\n        this._loadPanelImages(slider, slider.options.startPanel + 1);\n        this._loadPanelImages(slider, 0);\n        this._loadPanelImages(slider, slider.pages + 1);\n    },\n\n    onSlideInit: function (event, slider) {\n        this._loadPanelImages(slider, slider.targetPage);\n    },\n\n    onSlideComplete: function (event, slider) {\n        var $panel_links = event.data;\n        $panel_links.removeClass(\"current\");\n        if (slider.$targetPage[0].id)\n            $panel_links\n                .filter(\"[href=#\" + slider.$targetPage[0].id + \"]\")\n                .addClass(\"current\");\n        this._loadPanelImages(slider, slider.targetPage + 1);\n    },\n});\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport utils from \"../../core/utils\";\nimport \"../../core/jquery-ext\";\n\nexport const parser = new Parser(\"checklist\");\nparser.addArgument(\"select\", \".select-all\");\nparser.addArgument(\"deselect\", \".deselect-all\");\n\nexport default Base.extend({\n    name: \"checklist\",\n    trigger: \".pat-checklist\",\n    jquery_plugin: true,\n    all_selects: [],\n    all_deselects: [],\n    all_checkboxes: [],\n    all_radios: [],\n\n    init() {\n        this.options = parser.parse(this.el, this.options, false);\n        this.$el.on(\"patterns-injected\", this._init.bind(this));\n        this._init();\n    },\n\n    _init() {\n        this.all_checkboxes = this.el.querySelectorAll(\"input[type=checkbox]\");\n        this.all_radios = this.el.querySelectorAll(\"input[type=radio]\");\n\n        this.all_selects = dom.find_scoped(this.el, this.options.select);\n        for (const btn of this.all_selects) {\n            btn.addEventListener(\"click\", this.select_all.bind(this));\n        }\n\n        this.all_deselects = dom.find_scoped(this.el, this.options.deselect);\n        for (const btn of this.all_deselects) {\n            btn.addEventListener(\"click\", this.deselect_all.bind(this));\n        }\n\n        // update select/deselect button status\n        this.el.addEventListener(\"change\", this._handler_change.bind(this));\n        this.change_buttons();\n        this.change_checked();\n    },\n\n    _handler_change() {\n        utils.debounce(() => this.change_buttons(), 50)();\n        utils.debounce(() => this.change_checked(), 50)();\n    },\n\n    destroy() {\n        for (const it of this.all_selects) {\n            it.removeEventListener(\"click\", this.select_all);\n        }\n        for (const it of this.all_deselects) {\n            it.removeEventListener(\"click\", this.deselect_all);\n        }\n        this.el.removeEventListener(\"change\", this._handler_change);\n        this.$el.off(\"patterns_injected\");\n    },\n\n    find_siblings(el, sel) {\n        // Looks for the closest elements within the `el` tree that match the\n        // `sel` selector\n        let res;\n        let parent = el.parentNode;\n        while (parent) {\n            res = parent.querySelectorAll(sel);\n            if (res.length || parent === this.el) {\n                // return if results were found or we reached the pattern top\n                return res;\n            }\n            parent = parent.parentNode;\n        }\n    },\n\n    find_checkboxes(ref_el, sel) {\n        let chkbxs = [];\n        if (this.options.select.indexOf(\"#\") === 0) {\n            chkbxs = this.el.querySelectorAll(sel);\n        } else {\n            chkbxs = this.find_siblings(ref_el, sel);\n        }\n        return chkbxs;\n    },\n\n    change_buttons() {\n        let chkbxs;\n        for (const btn of this.all_selects) {\n            chkbxs = this.find_checkboxes(btn, \"input[type=checkbox]\");\n            btn.disabled = [...chkbxs]\n                .map((el) => el.matches(\":checked\"))\n                .every((it) => it === true);\n        }\n        for (const btn of this.all_deselects) {\n            chkbxs = this.find_checkboxes(btn, \"input[type=checkbox]\");\n            btn.disabled = [...chkbxs]\n                .map((el) => el.matches(\":checked\"))\n                .every((it) => it === false);\n        }\n    },\n\n    select_all(e) {\n        e.preventDefault();\n        const chkbxs = this.find_checkboxes(\n            e.target,\n            \"input[type=checkbox]:not(:checked)\"\n        );\n        for (const box of chkbxs) {\n            box.checked = true;\n            box.dispatchEvent(new Event(\"change\", { bubbles: true, cancelable: true }));\n        }\n    },\n\n    deselect_all(e) {\n        e.preventDefault();\n        const chkbxs = this.find_checkboxes(e.target, \"input[type=checkbox]:checked\");\n        for (const box of chkbxs) {\n            box.checked = false;\n            box.dispatchEvent(new Event(\"change\", { bubbles: true, cancelable: true }));\n        }\n    },\n\n    change_checked() {\n        for (const it of [...this.all_checkboxes].concat([...this.all_radios])) {\n            for (const label of it.labels) {\n                label.classList.remove(\"unchecked\");\n                label.classList.remove(\"checked\");\n                label.classList.add(it.checked ? \"checked\" : \"unchecked\");\n            }\n        }\n\n        for (const fieldset of dom.querySelectorAllAndMe(this.el, \"fieldset\")) {\n            if (\n                fieldset.querySelectorAll(\n                    \"input[type=checkbox]:checked, input[type=radio]:checked\"\n                ).length\n            ) {\n                fieldset.classList.remove(\"unchecked\");\n                fieldset.classList.add(\"checked\");\n            } else {\n                fieldset.classList.remove(\"checked\");\n                fieldset.classList.add(\"unchecked\");\n            }\n        }\n    },\n});\n","/* Clone pattern */\nimport $ from \"jquery\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport dom from \"../../core/dom\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat-clone\");\nconst TEXT_NODE = 3;\n\nexport const parser = new Parser(\"clone\");\nparser.addArgument(\"max\");\nparser.addArgument(\"template\", \":first\");\nparser.addArgument(\"trigger-element\", \".add-clone\");\nparser.addArgument(\"remove-element\", \".remove-clone\");\nparser.addArgument(\"remove-behaviour\", \"confirm\", [\"confirm\", \"none\"]);\nparser.addArgument(\n    \"remove-confirmation\",\n    \"Are you sure you want to remove this element?\"\n);\nparser.addArgument(\"clone-element\", \".clone\");\nparser.addAlias(\"remove-behavior\", \"remove-behaviour\");\n\nexport default Base.extend({\n    name: \"clone\",\n    trigger: \".pat-clone\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n        if (this.options.template.lastIndexOf(\":\", 0) === 0) {\n            this.template = $(this.options.template, this.el)[0];\n        } else {\n            this.template = document.querySelector(this.options.template);\n        }\n\n        this.bind_trigger(document.body);\n\n        const clones = this.el.querySelectorAll(this.options.cloneElement);\n        this.num_clones = clones.length;\n        for (const clone of clones) {\n            this.bind_remove(clone);\n        }\n    },\n\n    clone() {\n        if (this.num_clones >= this.options.max) {\n            alert(\"Sorry, only \" + this.options.max + \" elements allowed.\");\n            return;\n        }\n        this.num_clones += 1;\n\n        let $clone =\n            this.template.nodeName === \"TEMPLATE\"\n                ? $([...this.template.content.children]).clone()\n                : $(this.template).safeClone();\n\n        const ids = ($clone.attr(\"id\") || \"\").split(\" \").filter((it) => it);\n        $clone.removeAttr(\"id\").removeClass(\"disable-patterns\");\n        $.each(\n            ids,\n            function (idx, id) {\n                // Re-add all ids that have the substring #{1} in them, while\n                // also replacing that substring with the number of clones.\n                if (id.indexOf(\"#{1}\") !== -1) {\n                    $clone.attr(\n                        \"id\",\n                        $clone.attr(\"id\")\n                            ? $clone.attr(\"id\") + \" \"\n                            : \"\" + id.replace(\"#{1}\", this.num_clones)\n                    );\n                }\n            }.bind(this)\n        );\n\n        $clone.appendTo(this.$el);\n        $clone\n            .children()\n            .addBack()\n            .contents()\n            .addBack()\n            .filter(this.incrementValues.bind(this));\n\n        this.bind_trigger($clone);\n        this.bind_remove($clone);\n\n        $clone.prop(\"hidden\", false);\n        registry.scan($clone);\n\n        $clone.trigger(\"pat-update\", {\n            pattern: \"clone\",\n            action: \"clone\",\n            $el: $clone,\n        });\n        if (this.num_clones >= this.options.max) {\n            for (const el_ of this.clone_triggers) {\n                dom.hide(el_);\n            }\n        }\n    },\n\n    incrementValues(idx, el) {\n        const $el = $(el);\n        $el.children().addBack().contents().filter(this.incrementValues.bind(this));\n        const callback = function (idx, attr) {\n            if (attr.name === \"type\" || !$el.attr(attr.name)) {\n                return;\n            }\n            try {\n                $el.attr(\n                    attr.name,\n                    $el.attr(attr.name).replace(\"#{1}\", this.num_clones)\n                );\n            } catch (e) {\n                log.warn(e);\n            }\n        };\n        if (el.nodeType !== TEXT_NODE) {\n            $.each(el.attributes, callback.bind(this));\n        } else if (el.data.length) {\n            el.data = el.data.replace(\"#{1}\", this.num_clones);\n        }\n    },\n\n    bind_trigger(triggers) {\n        // Bind clone trigger\n        for (const node of utils.ensureArray(triggers)) {\n            for (const trigger of dom.querySelectorAllAndMe(\n                node,\n                this.options.triggerElement\n            )) {\n                trigger.addEventListener(\"click\", () => this.clone());\n            }\n        }\n    },\n\n    bind_remove(clone) {\n        for (const node of utils.ensureArray(clone)) {\n            for (const remove_button of dom.querySelectorAllAndMe(\n                node,\n                this.options.remove.element\n            )) {\n                remove_button.addEventListener(\"click\", () => {\n                    if (this.options.remove.behaviour === \"confirm\") {\n                        if (window.confirm(this.options.remove.confirmation) === true) {\n                            this.remove(clone);\n                        }\n                    } else {\n                        this.remove(clone);\n                    }\n                });\n            }\n        }\n    },\n\n    remove(clone) {\n        for (const node of utils.ensureArray(clone)) {\n            node.remove();\n            this.$el.trigger(\"pat-update\", {\n                pattern: \"clone\",\n                action: \"remove\",\n                $el: $(node), // used by pat-sortable only.\n            });\n        }\n        this.num_clones -= 1;\n        if (this.num_clones < this.options.max) {\n            for (const el_ of this.clone_triggers) {\n                dom.show(el_);\n            }\n        }\n    },\n});\n","/**\n * Patterns collapsible - Collapsible content\n *\n * Copyright 2012-2013 Florian Friesdorf\n * Copyright 2012-2013 Simplon B.V. - Wichert Akkerman\n * Copyright 2012 Markus Maier\n * Copyright 2013 Peter Lamut\n * Copyright 2012 Jonas Hoersch\n */\n\nimport $ from \"jquery\";\nimport \"../../core/jquery-ext\";\nimport inject from \"../inject/inject\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport store from \"../../core/store\";\nimport Base from \"../../core/base\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.collapsible\");\n\nexport const parser = new Parser(\"collapsible\");\nparser.addArgument(\"load-content\");\nparser.addArgument(\"store\", \"none\", [\"none\", \"session\", \"local\"]);\nparser.addArgument(\"transition\", \"slide\", [\n    \"none\",\n    \"css\",\n    \"fade\",\n    \"slide\",\n    \"slide-horizontal\",\n]);\nparser.addArgument(\"effect-duration\", \"fast\");\nparser.addArgument(\"effect-easing\", \"swing\");\nparser.addArgument(\"closed\", false);\nparser.addArgument(\"trigger\", \"::first\");\nparser.addArgument(\"close-trigger\");\nparser.addArgument(\"open-trigger\");\n// pat-scroll support\nparser.addArgument(\"scroll-selector\");\nparser.addArgument(\"scroll-offset\", 0);\n\nconst debounce_scroll_timer = { timer: null };\n\nexport default Base.extend({\n    name: \"collapsible\",\n    trigger: \".pat-collapsible\",\n    jquery_plugin: true,\n    parser: parser,\n\n    transitions: {\n        \"none\": { closed: \"hide\", open: \"show\" },\n        \"fade\": { closed: \"fadeOut\", open: \"fadeIn\" },\n        \"slide\": { closed: \"slideUp\", open: \"slideDown\" },\n        \"slide-horizontal\": { closed: \"slideOut\", open: \"slideIn\" },\n    },\n\n    init: function ($el, opts) {\n        var $content, state, storage;\n        this.options = store.updateOptions($el[0], parser.parse($el, opts));\n\n        if (this.options.trigger === \"::first\") {\n            this.$trigger = $el.children(\":first\");\n            $content = $el.children(\":gt(0)\");\n        } else {\n            this.$trigger = $(this.options.trigger);\n            $content = $el.children();\n        }\n        if (this.$trigger.length === 0) {\n            log.error(\"Collapsible has no trigger.\", $el[0]);\n            return;\n        }\n\n        this.$panel = $el.children(\".panel-content\");\n        if (this.$panel.length === 0) {\n            if ($content.length) {\n                this.$panel = $content.wrapAll(\"<div class='panel-content' />\").parent();\n            } else {\n                this.$panel = $(\"<div class='panel-content' />\").insertAfter(\n                    this.$trigger\n                );\n            }\n        }\n\n        state = this.options.closed || $el.hasClass(\"closed\") ? \"closed\" : \"open\";\n        if (this.options.store !== \"none\") {\n            storage = (this.options.store === \"local\" ? store.local : store.session)(\n                this.name\n            );\n            state = storage.get($el.attr(\"id\")) || state;\n        }\n\n        if (state === \"closed\") {\n            this.$trigger.removeClass(\"collapsible-open\").addClass(\"collapsible-closed\");\n            $el.removeClass(\"open\").addClass(\"closed\");\n            this.$panel.hide();\n        } else {\n            if (this.options.loadContent)\n                this._loadContent($el, this.options.loadContent, this.$panel);\n            this.$trigger.removeClass(\"collapsible-closed\").addClass(\"collapsible-open\");\n            $el.removeClass(\"closed\").addClass(\"open\");\n            this.$panel.show();\n        }\n\n        this.$trigger\n            .off(\".pat-collapsible\")\n            .on(\"click.pat-collapsible\", null, $el, this._onClick.bind(this))\n            .on(\"keypress.pat-collapsible\", null, $el, this._onKeyPress.bind(this));\n\n        if (this.options.closeTrigger) {\n            $(document).on(\"click\", this.options.closeTrigger, this.close.bind(this));\n        }\n        if (this.options.openTrigger) {\n            $(document).on(\"click\", this.options.openTrigger, this.open.bind(this));\n        }\n\n        this.debounce_scroll = utils.debounce(\n            () => this._scroll(),\n            10,\n            debounce_scroll_timer\n        ); // scroll debouncer for later use.\n\n        return $el;\n    },\n\n    open: function () {\n        if (!this.$el.hasClass(\"open\")) this.toggle();\n        return this.$el;\n    },\n\n    close: function () {\n        if (!this.$el.hasClass(\"closed\")) this.toggle();\n        return this.$el;\n    },\n\n    _onClick: function (event) {\n        this.toggle(event.data);\n    },\n\n    _onKeyPress: function (event) {\n        var keycode = event.keyCode ? event.keyCode : event.which;\n        if (keycode === 13) this.toggle();\n    },\n\n    _loadContent: function ($el, url, $target) {\n        var components = url.split(\"#\"),\n            base_url = components[0],\n            id = components[1] ? \"#\" + components[1] : \"body\",\n            opts = [\n                {\n                    url: base_url,\n                    source: id,\n                    $target: $target,\n                    dataType: \"html\",\n                },\n            ];\n        inject.execute(opts, $el);\n    },\n\n    // jQuery method to force loading of content.\n    loadContent: function ($el) {\n        return $el.each(\n            function (idx, el) {\n                if (this.options.loadContent)\n                    this._loadContent($(el), this.options.loadContent, this.$panel);\n            }.bind(this)\n        );\n    },\n\n    toggle: function () {\n        var new_state = this.$el.hasClass(\"closed\") ? \"open\" : \"closed\";\n        if (this.options.store !== \"none\") {\n            var storage = (this.options.store === \"local\" ? store.local : store.session)(\n                this.name\n            );\n            storage.set(this.$el.attr(\"id\"), new_state);\n        }\n        if (new_state === \"open\") {\n            this.$el.trigger(\"patterns-collapsible-open\");\n            this._transit(this.$el, \"closed\", \"open\");\n            this.debounce_scroll();\n        } else {\n            this.$el.trigger(\"patterns-collapsible-close\");\n            this._transit(this.$el, \"open\", \"closed\");\n        }\n        return this.$el; // allow chaining\n    },\n\n    async _scroll() {\n        const scroll_selector = this.options.scroll?.selector;\n        if (scroll_selector) {\n            const pat_scroll = (await import(\"../scroll/scroll\")).default;\n            const scroll = new pat_scroll(this.el, {\n                trigger: \"manual\",\n                selector: scroll_selector,\n                offset: this.options.scroll?.offset,\n            });\n            await scroll.smoothScroll();\n        }\n    },\n\n    _transit: async function ($el, from_cls, to_cls) {\n        if (to_cls === \"open\" && this.options.loadContent) {\n            this._loadContent($el, this.options.loadContent, this.$panel);\n        }\n        var duration =\n            this.options.transition === \"css\" || this.options.transition === \"none\"\n                ? null\n                : this.options.effect.duration;\n        if (!duration) {\n            this.$trigger\n                .removeClass(\"collapsible-\" + from_cls)\n                .addClass(\"collapsible-\" + to_cls);\n            $el.removeClass(from_cls).addClass(to_cls).trigger(\"pat-update\", {\n                pattern: \"collapsible\",\n                transition: \"complete\",\n            });\n        } else {\n            var t = this.transitions[this.options.transition];\n            $el.addClass(\"in-progress\").trigger(\"pat-update\", {\n                pattern: \"collapsible\",\n                transition: \"start\",\n            });\n            this.$trigger.addClass(\"collapsible-in-progress\");\n            await this.$panel[t[to_cls]](\n                duration,\n                this.options.effect.easing,\n                function () {\n                    this.$trigger\n                        .removeClass(\"collapsible-\" + from_cls)\n                        .removeClass(\"collapsible-in-progress\")\n                        .addClass(\"collapsible-\" + to_cls);\n                    $el.removeClass(from_cls)\n                        .removeClass(\"in-progress\")\n                        .addClass(to_cls)\n                        .trigger(\"pat-update\", {\n                            pattern: \"collapsible\",\n                            transition: \"complete\",\n                        });\n                }.bind(this)\n            ).promise();\n        }\n    },\n});\n","/**\n * Patterns pat-polyfill-colour - Polyfill for colour inputs.\n *\n * Copyright 2014 Marko Durkovic\n * Copyright 2014 Simplon B.V. - Wichert Akkerman\n */\nimport registry from \"../../core/registry\";\n\nvar _ = {\n    name: \"polyfill-color\",\n    trigger: \"input.pat-colour-picker,input.pat-color-picker\",\n    async init($el) {\n        await import(\"spectrum-colorpicker\");\n        if (window.__patternslib_import_styles) {\n            import(\"./_colour-picker.scss\");\n        }\n        return $el.spectrum({ preferredFormat: \"hex\" });\n    },\n};\n\nregistry.register(_);\nexport default _;\n","/* pat-datetime-picker  - Polyfill for input type=datetime-local */\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\nimport dom from \"../../core/dom\";\n\nexport const parser = new Parser(\"datetime-picker\");\nparser.addArgument(\"format\", \"YYYY-MM-DD\");\nparser.addArgument(\"week-numbers\", [], [\"show\", \"hide\"]);\nparser.addArgument(\"i18n\"); // URL pointing to JSON resource with i18n values\nparser.addArgument(\"today\", \"Today\");\nparser.addArgument(\"clear\", \"Clear\");\nparser.addArgument(\"first-day\", 0);\n\nexport default Base.extend({\n    name: \"datetime-picker\",\n    trigger: \".pat-datetime-picker\",\n    parser: parser,\n    el_date: null,\n    el_time: null,\n\n    async init() {\n        const el = this.el;\n        this.options = parser.parse(this.el, this.options);\n\n        if (utils.checkInputSupport(\"datetime-local\", \"invalid date\")) {\n            return;\n        }\n\n        if (window.__patternslib_import_styles) {\n            import(\"./_datetime-picker.scss\");\n        }\n        const DatePicker = (await import(\"../date-picker/date-picker\")).default;\n\n        const value = this.el.value.split(\"T\");\n        const date_value = value[0] || \"\";\n        const time_value = value[1] || \"\";\n\n        const el_wrapper = document.createElement(\"div\");\n        el_wrapper.setAttribute(\"class\", \"pat-datetime-picker__wrapper\");\n\n        dom.hide(el);\n\n        // let the buttons be of type button otherwise they are submit buttons\n        const html_btn_now = `\n            <button type=\"button\" class=\"_btn _now\" title=\"${this.options.today}\">\n                <span class=\"_icon\"/>\n                <span class=\"_text\">${this.options.today}</span>\n            </button>`;\n        const html_btn_clear = `\n            <button type=\"button\" class=\"_btn _clear\" title=\"${this.options.clear}\">\n                <span class=\"_icon\"/>\n                <span class=\"_text\">${this.options.clear}</span>\n            </button>`;\n\n        el_wrapper.innerHTML = `\n            <input type=\"date\" placeholder=\"YYYY-MM-DD\" value=\"${date_value}\" />\n            <input type=\"time\" placeholder=\"hh:mm\" value=\"${time_value}\" />\n            ${this.options.today ? html_btn_now : \"\"}\n            ${this.options.clear ? html_btn_clear : \"\"}\n        `;\n\n        this.el_time = el_wrapper.querySelector(\"input[type=time]\");\n        this.el_time.addEventListener(\"change\", () => this.update());\n\n        this.el_date = el_wrapper.querySelector(\"input[type=date]\");\n        this.el_date.addEventListener(\"change\", () => {\n            if (!this.el_time.value) {\n                // Set time on date change, if time was empty.\n                this.el_time.value = this.isotime();\n            }\n            this.update();\n        });\n\n        const date_options = {\n            behavior: \"native\",\n            format: this.options.format,\n            weekNumbers: this.options.weekNumbers,\n            firstDay: this.options.firstDay,\n        };\n        await DatePicker.init(this.el_date, date_options);\n\n        if (this.options.today) {\n            const btn_now = el_wrapper.querySelector(\"._btn._now\");\n            btn_now.addEventListener(\"click\", (e) => {\n                e.preventDefault();\n                this.el_date.value = this.isodate();\n                this.el_time.value = this.isotime();\n                this.update();\n            });\n        }\n\n        if (this.options.clear) {\n            const btn_clear = el_wrapper.querySelector(\"._btn._clear\");\n            btn_clear.addEventListener(\"click\", (e) => {\n                e.preventDefault();\n                this.el_date.value = \"\";\n                this.el_time.value = \"\";\n                this.update();\n            });\n        }\n\n        // TODO: timezone\n        el.parentNode.insertBefore(el_wrapper, el);\n    },\n\n    update() {\n        if (this.el_date.value && this.el_time.value) {\n            this.el.value = `${this.el_date.value}T${this.el_time.value}`;\n        } else {\n            this.el.value = \"\";\n        }\n        this.el.dispatchEvent(new Event(\"change\", { bubbles: true, cancelable: true }));\n    },\n\n    isodate() {\n        const now = new Date();\n        return now.toISOString().substr(0, 10);\n    },\n\n    isotime() {\n        const now = new Date();\n        return now.toTimeString().substr(0, 5);\n    },\n});\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport utils from \"../../core/utils\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\n\nconst log = logging.getLogger(\"depends\");\n\nexport const parser = new Parser(\"depends\");\nparser.addArgument(\"condition\");\nparser.addArgument(\"action\", \"show\", [\"show\", \"enable\", \"both\"]);\nparser.addArgument(\"transition\", \"none\", [\"none\", \"css\", \"fade\", \"slide\"]);\nparser.addArgument(\"effect-duration\", \"fast\");\nparser.addArgument(\"effect-easing\", \"swing\");\n\nexport default Base.extend({\n    name: \"depends\",\n    trigger: \".pat-depends\",\n    jquery_plugin: true,\n\n    async init($el, opts) {\n        const DependsHandler = (await import(\"../../lib/dependshandler\")).default; // prettier-ignore\n\n        const dependent = this.$el[0];\n        const options = parser.parse(this.$el, opts);\n        this.$modal = this.$el.parents(\".pat-modal\");\n\n        let handler;\n        try {\n            handler = new DependsHandler(this.$el, options.condition);\n        } catch (e) {\n            log.error(\"Invalid condition: \" + e.message, dependent);\n            return;\n        }\n\n        let state = handler.evaluate();\n        switch (options.action) {\n            case \"show\":\n                utils.hideOrShow($el, state, options, this.name);\n                this.updateModal();\n                break;\n            case \"enable\":\n                if (state) this.enable();\n                else this.disable();\n                break;\n            case \"both\":\n                if (state) {\n                    utils.hideOrShow($el, state, options, this.name);\n                    this.updateModal();\n                    this.enable();\n                } else {\n                    utils.hideOrShow($el, state, options, this.name);\n                    this.updateModal();\n                    this.disable();\n                }\n                break;\n        }\n\n        const data = {\n            handler: handler,\n            options: options,\n            dependent: dependent,\n        };\n\n        for (let input of handler.getAllInputs()) {\n            if (input.form) {\n                let $form = $(input.form);\n                let dependents = $form.data(\"patDepends.dependents\");\n                if (!dependents) {\n                    dependents = [data];\n                    $form.on(\"reset.pat-depends\", () => this.onReset);\n                } else if (dependents.indexOf(data) === -1) dependents.push(data);\n                $form.data(\"patDepends.dependents\", dependents);\n            }\n            $(input).on(\"change.pat-depends\", null, data, this.onChange.bind(this));\n            $(input).on(\"keyup.pat-depends\", null, data, this.onChange.bind(this));\n        }\n    },\n\n    async onReset(event) {\n        const dependents = $(event.target).data(\"patDepends.dependents\");\n        await utils.timeout(50);\n        for (let dependent of dependents) {\n            event.data = dependent;\n            this.onChange(event);\n        }\n    },\n\n    updateModal() {\n        // If we're in a modal, make sure that it gets resized.\n        if (this.$modal.length) {\n            $(document).trigger(\"pat-update\", { pattern: \"depends\" });\n        }\n    },\n\n    enable() {\n        if (this.$el.is(\":input\")) {\n            this.$el[0].disabled = null;\n        } else if (this.$el.is(\"a\")) {\n            this.$el.off(\"click.patternDepends\");\n        }\n        if (this.$el.hasClass(\"pat-autosuggest\")) {\n            this.$el.findInclusive(\"input.pat-autosuggest\").trigger(\"pat-update\", {\n                pattern: \"depends\",\n                enabled: true,\n            });\n        }\n        this.$el.removeClass(\"disabled\");\n    },\n\n    disable() {\n        if (this.$el.is(\":input\")) {\n            this.$el[0].disabled = \"disabled\";\n        } else if (this.$el.is(\"a\")) {\n            this.$el.on(\"click.patternDepends\", (e) => e.preventDefault());\n        }\n        if (this.$el.hasClass(\"pat-autosuggest\")) {\n            this.$el.findInclusive(\"input.pat-autosuggest\").trigger(\"pat-update\", {\n                pattern: \"depends\",\n                enabled: false,\n            });\n        }\n        this.$el.addClass(\"disabled\");\n    },\n\n    onChange(event) {\n        const handler = event.data.handler;\n        const options = event.data.options;\n        const dependent = event.data.dependent;\n        const $depdendent = $(dependent);\n        const state = handler.evaluate();\n\n        switch (options.action) {\n            case \"show\":\n                utils.hideOrShow($depdendent, state, options, this.name);\n                this.updateModal();\n                break;\n            case \"enable\":\n                if (state) {\n                    this.enable();\n                } else {\n                    this.disable();\n                }\n                break;\n            case \"both\":\n                utils.hideOrShow($depdendent, state, options, this.name);\n                this.updateModal();\n                if (state) {\n                    this.enable();\n                } else {\n                    this.disable();\n                }\n                break;\n        }\n    },\n});\n","/**\n * equaliser - Equalise height of elements in a row\n *\n * Copyright 2013 Simplon B.V. - Wichert Akkerman\n */\nimport $ from \"jquery\";\nimport registry from \"../../core/registry\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nexport const parser = new Parser(\"equaliser\");\nparser.addArgument(\"transition\", \"none\", [\"none\", \"grow\"]);\nparser.addArgument(\"effect-duration\", \"fast\");\nparser.addArgument(\"effect-easing\", \"swing\");\n\nvar equaliser = {\n    name: \"equaliser\",\n    trigger: \".pat-equaliser, .pat-equalizer\",\n\n    async init($el, opts) {\n        const ImagesLoaded = (await import(\"imagesloaded\")).default;\n\n        return $el.each(function () {\n            var $container = $(this),\n                options = parser.parse($container, opts);\n            $container.data(\"pat-equaliser\", options);\n            $(window).on(\n                \"resize.pat-equaliser\",\n                null,\n                this,\n                utils.debounce(equaliser._onEvent, 100)\n            );\n            ImagesLoaded(\n                this,\n                $.proxy(function () {\n                    equaliser._update(this);\n                }, this)\n            );\n            const callback = utils.debounce(equaliser._update.bind(this), 100);\n            const observer = new MutationObserver(callback);\n            const config = {\n                childList: true,\n                subtree: true,\n                characterData: true,\n                attributes: true,\n            };\n            observer.observe(document.body, config);\n        });\n    },\n\n    _update: function (container) {\n        var $container = $(container),\n            options = $container.data(\"pat-equaliser\"),\n            $children = $container.children(),\n            max_height = 0;\n\n        for (var i = 0; i < $children.length; i++) {\n            var $child = $children.eq(i),\n                css = $child.css(\"height\"),\n                height;\n            $child.css(\"height\", \"\").removeClass(\"equalised\");\n            height = $child.height();\n            if (height > max_height) max_height = height;\n            if (css) $child.css(\"height\", css);\n        }\n\n        var new_css = { height: max_height + \"px\" };\n\n        switch (options && options.transition) {\n            case \"none\":\n                $children.css(new_css).addClass(\"equalised\");\n                break;\n            case \"grow\":\n                $children.animate(\n                    new_css,\n                    options.effect.duration,\n                    options.effect.easing,\n                    function () {\n                        $(this).addClass(\"equalised\");\n                    }\n                );\n                break;\n        }\n        $container.trigger(\"pat-update\", { pattern: \"equaliser\" });\n    },\n\n    _onEvent: function (event) {\n        if (typeof event.data !== \"undefined\") {\n            equaliser._update(event.data);\n        }\n    },\n};\n\nregistry.register(equaliser);\nexport default equaliser;\n","import $ from \"jquery\";\nimport inject from \"../inject/inject\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\n\nexport const parser = new Parser(\"expandable\");\nparser.addArgument(\"load-content\");\n\nvar _ = {\n    name: \"expandable\",\n    trigger: \"ul.pat-expandable\",\n    jquery_plugin: true,\n    init: function ($el) {\n        // make sure inject folders have a ul\n        $el.find(\".folder[data-pat-expandable]:not(:has(ul))\").append(\"<ul />\");\n\n        // find all folders that contain a ul\n        var $folders = $el.find(\"li.folder:has(ul)\");\n\n        // inject span.toggle as first child of each folder\n        $folders.prepend(\"<span class='toggle'></span>\");\n\n        // all folders are implicitly closed\n        $folders.filter(\":not(.open,.closed)\").addClass(\"closed\");\n\n        // trigger open event for open folders\n        $folders.filter(\".open\").trigger(\"patterns-folder-open\");\n\n        // wire spans as control elements\n        var $ctrls = $el.find(\"span.toggle\");\n        $ctrls.each(function () {\n            var $ctrl = $(this),\n                $folder = $ctrl.parent();\n            $ctrl.on(\"click.pat-expandable\", function () {\n                $folder\n                    .toggleClass(\"open closed\")\n                    .filter(\".open[data-pat-expandable]\")\n                    .patExpandable(\"loadContent\");\n            });\n        });\n        return $el;\n    },\n    loadContent: function ($el) {\n        return $el.each(function () {\n            var $el = $(this),\n                url = parser.parse($el).loadContent,\n                components = url.split(\"#\"),\n                base_url = components[0],\n                id = components[1] ? \"#\" + components[1] : \"body\",\n                opts = [\n                    {\n                        url: base_url,\n                        source: id,\n                        $target: $el.find(\"ul\"),\n                        dataType: \"html\",\n                    },\n                ];\n            inject.execute(opts, $el);\n        });\n    },\n};\nregistry.register(_);\nexport default _;\n","/**\n * @license\n * Patterns @VERSION@ focus - Manage focus class on fieldsets\n *\n * Copyright 2012 Simplon B.V.\n */\n\nimport $ from \"jquery\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\nvar focus = {\n    name: \"focus\",\n\n    onNewContent: function () {\n        if ($(document.activeElement).is(\":input\"))\n            focus._doFocus(document.activeElement);\n    },\n\n    transform: function ($root) {\n        $root.find(\":input[placeholder]\").each(function (ix, el) {\n            var $relatives = utils.findRelatives(el);\n            if (el.placeholder) $relatives.attr(\"data-placeholder\", el.placeholder);\n        });\n        $root.find(\":input\").each(focus.onChange);\n    },\n\n    onFocus: function () {\n        focus._doFocus(this);\n    },\n\n    _updateHasValue: function (el) {\n        var $relatives = utils.findRelatives(el);\n        var hv = utils.hasValue(el);\n\n        if (hv) {\n            $relatives.addClass(\"has-value\").attr(\"data-value\", el.value);\n        } else {\n            $relatives\n                .filter(function (ix, e) {\n                    const inputs = $(\":input\", e);\n                    for (var i = 0; i < inputs.length; i++)\n                        if (utils.hasValue(inputs[i])) return false;\n                    return true;\n                })\n                .removeClass(\"has-value\")\n                .attr(\"data-value\", null);\n        }\n    },\n\n    _doFocus: function (el) {\n        var $relatives = utils.findRelatives(el);\n        $relatives.addClass(\"focus\");\n        this._updateHasValue($relatives);\n    },\n\n    onBlur: function () {\n        var $relatives = utils.findRelatives(this);\n\n        $(document).one(\"mouseup keyup\", function () {\n            $relatives.filter(\":not(:has(:input:focus))\").removeClass(\"focus\");\n        });\n    },\n\n    onChange: function () {\n        focus._updateHasValue(this);\n    },\n};\n\n$(document)\n    .on(\"focus.patterns\", \":input\", focus.onFocus)\n    .on(\"blur.patterns\", \":input\", focus.onBlur)\n    .on(\"newContent\", focus.onNewContent)\n    .on(\"change.pat-focus keyup.pat-focus\", \":input\", focus.onChange)\n    .on(\"input.pat-focus\", \":input[type=range]\", utils.debounce(focus.onChange, 50));\n\nregistry.register(focus);\nexport default focus;\n","import $ from \"jquery\";\nimport logging from \"../../core/logging\";\nimport registry from \"../../core/registry\";\nimport modal from \"../modal/modal\";\nimport input_change_events from \"../../lib/input-change-events\";\n\nvar log = logging.getLogger(\"form-state\");\n\nvar _ = {\n    name: \"form-state\",\n    trigger: \"form.pat-form-state\",\n    init: function ($form) {\n        if ($form.length > 1)\n            return $form.each(function () {\n                _.init($(this));\n            });\n\n        input_change_events.setup($form, _.name);\n\n        // XXX: hide reset buttons until we have proper handling for them\n        $form.find(\"[type=reset]\").hide();\n\n        _.setReset.call($form);\n\n        // remember initial state of the form and after\n        // successfull submission\n        $form.data(\"pat-ajax.state\", $form.serializeArray());\n        $form.on(\"pat-ajax-success\", _.saveState);\n\n        return $form;\n    },\n    saveState: function () {\n        var $form = $(this);\n        $form.data(\"pat-ajax.previous-state\", $form.data(\"pat-ajax.state\"));\n        $form.data(\"pat-ajax.state\", $form.serializeArray());\n        $form.trigger(\"pat-form-state-saved\");\n    },\n    setModified: function () {\n        var $form = $(this);\n\n        $form.find(\"[type=reset]\").prop(\"disabled\", false);\n        $form.find(\"[type=submit]\").prop(\"disabled\", false);\n\n        $form\n            .addClass(\"modified\")\n            .off(\".pat-form-state\")\n            .one(\"reset.pat-form-state\", _.setReset)\n            .one(\"pat-ajax-error.pat-form-state\", _.setError)\n            .one(\"pat-ajax-success.pat-form-state\", _.setSaved);\n        log.debug(\"modified\");\n    },\n    setReset: function () {\n        var $form = $(this);\n\n        // hide only if form has changeable inputs\n        if (\n            $form\n                .find(\n                    ':input[type!=\"hidden\"][type!=\"submit\"]' +\n                        '[type!=\"reset\"][type!=button]'\n                )\n                .not(\"button\").length\n        ) {\n            $form.find(\"[type=reset]\").prop(\"disabled\", true);\n            $form.find(\"[type=submit]\").prop(\"disabled\", true);\n        }\n\n        $form\n            .removeClass(\"modified\")\n            .off(\".pat-form-state\")\n            .one(\"input-change.pat-form-state\", _.setModified);\n        log.debug(\"reset\");\n    },\n    setError: function (event) {\n        var msg = [event.jqxhr.status, event.jqxhr.statusText].join(\" \");\n        modal.init(\n            $(\n                \"<div class='pat-modal small'>\" +\n                    \"<h3>Error</h3>\" +\n                    \"<div class='wizard-box'>\" +\n                    \"<div class='panel-body'>\" +\n                    \"<p>A server error has occured.</p>\" +\n                    \"<p>The error message is: <strong>\" +\n                    msg +\n                    \"</strong>.</p>\" +\n                    \"</div>\" +\n                    \"<div class='buttons panel-footer'>\" +\n                    \"<button class='close-panel'>Ok</button>\" +\n                    \"</div>\" +\n                    \"</div>\" +\n                    \"</div>\"\n            ).appendTo($(\"body\"))\n        );\n    },\n    setSaved: function (event) {\n        if (event.target !== this) return;\n\n        var $form = $(this);\n        _.setReset.call($form);\n\n        var time = new Date(),\n            timestr =\n                time.getHours() + \":\" + time.getMinutes() + \":\" + time.getSeconds();\n        $form.find(\"time.last-saved\").remove();\n        $form.prepend(\n            \"<time class='last-saved' datetime='\" + timestr + \"'>\" + timestr + \"</time>\"\n        );\n\n        $form.addClass(\"saved\");\n    },\n};\nregistry.register(_);\n\nexport default _;\n","// Patterns forward - Forward click events\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport utils from \"../../core/utils\";\n\nexport const parser = new Parser(\"forward\");\nparser.addArgument(\"selector\");\nparser.addArgument(\"trigger\", \"click\", [\"click\", \"auto\"]);\nparser.addArgument(\"delay\");\n\nexport default Base.extend({\n    name: \"forward\",\n    trigger: \".pat-forward\",\n    skip: false,\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n        if (!this.options.selector) {\n            return;\n        }\n        if (this.options.delay) {\n            this.options.delay = utils.parseTime(this.options.delay);\n        }\n\n        this.el.addEventListener(\"click\", this.on_click.bind(this));\n        if (this.options.trigger === \"auto\") {\n            this.el.click();\n        }\n    },\n\n    async on_click(event) {\n        if (this.skip) {\n            this.skip = false;\n            return;\n        }\n        event.preventDefault();\n        if (this.options.delay) {\n            await utils.timeout(this.options.delay);\n        }\n        let targets;\n        if (this.options.selector === \"self\") {\n            this.skip = true;\n            targets = [this.el];\n        } else {\n            targets = document.querySelectorAll(this.options.selector);\n        }\n        for (const el of targets) {\n            el.click();\n        }\n    },\n});\n\n// Notes:\n//\n// We're using `ELEMENT.click()` instead of\n// `ELEMENT.dispatchEvent(new Event(\"click\"))`.\n// The latter doesn't get recognized by jQuery and does not invoke the default\n// action on an <a href> element.\n//\n","import Base from \"../../core/base\";\n\nexport default Base.extend({\n    name: \"fullscreen-close\",\n    trigger: \".close-fullscreen\",\n    async init() {\n        const Screenfull = (await import(\"screenfull\")).default;\n\n        this.$el[0].addEventListener(\"click\", function () {\n            // no prevent-default nor stop propagation to let\n            // the button also do other stuff.\n            Screenfull.exit();\n        });\n    },\n});\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport logging from \"../../core/logging\";\n\n// Lazy loading modules.\nlet Screenfull;\n\nconst log = logging.getLogger(\"fullscreen\");\n\nexport const parser = new Parser(\"fullscreen\");\nparser.addArgument(\"selector\", null); // Selector for the fullscreen element.\nparser.addArgument(\"close-button\", \"none\", [\"none\", \"show\"]); // Inject a fullscreen button.\n\n/*\nclass Fullscreen extends Base {\n    __constructor__()\n}\n*/\n\nexport default Base.extend({\n    name: \"fullscreen\",\n    trigger: \".pat-fullscreen\",\n\n    async init($el, opts) {\n        Screenfull = (await import(\"screenfull\")).default;\n\n        this.options = parser.parse(this.$el, opts);\n        //const el = this.$el[0];\n        //el.addEventListener('click', function (e) {  // TODO: doesn't work in karma for href links\n        this.$el.on(\"click\", this.fullscreen_handler.bind(this));\n    },\n\n    fullscreen_handler(event) {\n        event.preventDefault();\n        const el = this.$el[0];\n        // querying the fullscreen element fs_el and inside the event\n        // handler instead of outside allows for dynamic injecting\n        // fullscreen elements even after pattern initialization.\n        let fs_el_sel = this.options.selector\n            ? this.options.selector\n            : el.getAttribute(\"href\");\n        fs_el_sel = fs_el_sel ? fs_el_sel : \"body\";\n        const fs_el = document.querySelector(fs_el_sel);\n        if (fs_el) {\n            // setting page to fullscreen\n            Screenfull.request(fs_el);\n            if (this.options.closeButton === \"show\") {\n                this.setup_exit_button(fs_el);\n            }\n        } else {\n            log.error(\"No fullscreen element found.\");\n        }\n    },\n\n    setup_exit_button(fs_el) {\n        // setting up the exit button\n        let exit_el = null;\n        if (this.options.closeButton === \"show\") {\n            exit_el = document.createElement(\"button\");\n            exit_el.className = \"pat-fullscreen-close-fullscreen\";\n            exit_el.title = \"Exit fullscreen\";\n            exit_el.appendChild(document.createTextNode(\"Exit fullscreen\"));\n            exit_el.addEventListener(\"click\", (e) => {\n                e.preventDefault();\n                Screenfull.exit();\n            });\n        }\n        fs_el.appendChild(exit_el);\n        Screenfull.on(\"change\", () => {\n            // Removing exit button.\n            // The button is also removed when pressing the <ESC> button.\n            if (!Screenfull.isFullscreen) {\n                fs_el.removeChild(exit_el);\n            }\n        });\n    },\n});\n","// pat-gallery - A gallery pattern.\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.gallery\");\n\nexport const parser = new Parser(\"gallery\");\nparser.addArgument(\"item-selector\", \"a\"); // selector for anchor element, which is added to the gallery.\nparser.addArgument(\"loop\", true);\nparser.addArgument(\"scale-method\", \"fit\", [\"fit\", \"fitNoUpscale\", \"zoom\"]);\nparser.addArgument(\"delay\", 30000);\nparser.addArgument(\"effect-duration\", 250);\n\nlet PhotoSwipe;\nlet PhotoSwipeUI;\n\nexport default Base.extend({\n    name: \"gallery\",\n    trigger: \".pat-gallery\",\n    orig_body_overflow: \"auto\",\n\n    images: [],\n\n    async init() {\n        if (window.__patternslib_import_styles) {\n            import(\"photoswipe/dist/photoswipe.css\");\n            import(\"photoswipe/dist/default-skin/default-skin.css\");\n        }\n        PhotoSwipe = (await import(\"photoswipe\")).default;\n        PhotoSwipeUI = (await import(\"photoswipe/dist/photoswipe-ui-default\")).default; // prettier-ignore\n\n        this.options = parser.parse(this.el, this.options);\n\n        this.template = await this.get_template();\n\n        const gallery_observer = new MutationObserver(\n            this.initialize_trigger.bind(this)\n        );\n        gallery_observer.observe(this.el, {\n            subtree: true,\n            childList: true,\n        });\n\n        this.initialize_trigger();\n    },\n\n    async get_template() {\n        // Check for already defined templates.\n        let template = document.querySelector(\n            \".pat-gallery__template-wrapper, #photoswipe-template\"\n        );\n        // Otherwise, use default template.\n        if (!template) {\n            const raw_template = (await import(\"./template.html\")).default;\n            template = document.createElement(\"div\");\n            template.setAttribute(\"class\", \"pat-gallery__template-wrapper\");\n            template.setAttribute(\"hidden\", \"\");\n            template.innerHTML = raw_template;\n            document.body.appendChild(template);\n        }\n        return template;\n    },\n\n    initialize_trigger() {\n        const image_wrapper_els = dom.querySelectorAllAndMe(\n            this.el,\n            this.options.itemSelector\n        );\n        this.images = [...image_wrapper_els].map((it) => {\n            events.add_event_listener(\n                it,\n                \"click\",\n                \"pat-gallery--image_handler\",\n                this.initialize_gallery.bind(this)\n            );\n\n            const src =\n                it.getAttribute(\"href\") ||\n                it.getAttribute(\"src\") ||\n                it.querySelector(\"img\")?.getAttribute(\"src\");\n            const title =\n                it.getAttribute(\"title\") ||\n                it.querySelector(\"img\")?.getAttribute(\"title\");\n\n            return {\n                w: 0,\n                h: 0,\n                src: src,\n                title: title,\n            };\n        });\n    },\n\n    initialize_gallery(e) {\n        const trigger_el = e.currentTarget;\n\n        this.template.removeAttribute(\"hidden\");\n\n        const pswp_el = dom.querySelectorAllAndMe(this.template, \".pswp\")?.[0];\n        if (!pswp_el) {\n            log.warn(\"No photoswipe template found.\");\n        }\n\n        // Now - when all is set - prevent default action.\n        e.preventDefault();\n\n        const index =\n            this.images\n                .map((it) => it.src)\n                .indexOf(\n                    trigger_el.getAttribute(\"href\") || trigger_el.getAttribute(\"src\")\n                ) || 0;\n\n        const options = {\n            // Get the index of the clicked gallery item in the list of images.\n            index: index,\n            scaleMode: this.options.scaleMethod,\n            loop: this.options.loop,\n            slideshowDelay: this.options.delay,\n            hideAnimationDuration: this.options.effectDuration,\n            showAnimationDuration: this.options.effectDuration,\n            pinchToClose: false,\n            closeOnScroll: false,\n            // Fix reload on gallery close which was induced by a history back call.\n            history: false,\n        };\n\n        const gallery = new PhotoSwipe(pswp_el, PhotoSwipeUI, this.images, options);\n\n        const gallery_reinit_sizes_debouncer = utils.debounce(() => {\n            gallery.updateSize(true); // reinit Items\n        }, 50);\n\n        gallery.listen(\"gettingData\", function (index, item) {\n            // Workaround for the fact that we don't know the image sizes.\n            // https://github.com/dimsemenov/PhotoSwipe/issues/796\n            if (item.w < 1 || item.h < 1) {\n                // unknown size\n                const img = new Image();\n                img.onload = (_e) => {\n                    const img_el = _e.target;\n                    // will get size after load\n                    item.w = img_el.width; // set image width\n                    item.h = img_el.height; // set image height\n                    item.needsUpdate = true;\n                    gallery_reinit_sizes_debouncer(); // debounce to not land in a re-init loop.\n                };\n                img.src = item.src; // let's download image\n            }\n        });\n\n        gallery.listen(\"initialZoomInEnd\", () => {\n            // don't show body scrollbars when overlay is open\n            this.orig_body_overflow = dom.get_css_value(document.body, \"overflow\");\n            document.body.style.overflow = \"hidden\";\n        });\n\n        gallery.listen(\"destroy\", () => {\n            // show original overlay value on body after closing\n            document.body.style.overflow = this.orig_body_overflow;\n            this.template.setAttribute(\"hidden\", \"\");\n        });\n\n        gallery.init();\n    },\n});\n","import $ from \"jquery\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\n\nconst log = logging.getLogger(\"pat.image-crop\");\n\nexport const parser = new Parser(\"image-crop\");\nparser.addArgument(\"preview-id\", \"\");\nparser.addArgument(\"preview-height\", 0);\nparser.addArgument(\"preview-width\", 0);\nparser.addArgument(\"aspect-ratio\", 1);\nparser.addArgument(\"form-id\", \"\");\nparser.addArgument(\"initial-sel\", \"0 0 0 0\");\nparser.addArgument(\"min-size\", \"0 0\");\nparser.addArgument(\"max-size\", \"0 0\");\nparser.addArgument(\"input-prefix\", \"\");\n\nvar _ = {\n    name: \"image-crop\",\n    trigger: \"img.pat-image-crop\",\n    bounds: [0, 0],\n    inputNames: [\"x1\", \"y1\", \"x2\", \"y2\", \"w\", \"h\"],\n\n    async init($el, options) {\n        await import(\"jquery-jcrop\");\n\n        // initialize the elements\n        return $el.each(function () {\n            var $this = $(this),\n                opts = parser.parse($this, options),\n                data = {};\n\n            // Initialize the preview parameters\n            if (opts.preview.id.length === 0) data.preview = false;\n            else {\n                data.preview = {};\n                data.preview.element = $(opts.preview.id);\n                if (data.preview.element.length === 0) {\n                    log.error(\"Invalid preview element ID supplied: \" + opts.preview.id);\n                    return;\n                }\n                if (opts.previewWidth > 0 && opts.preview.height > 0) {\n                    data.preview.width = opts.preview.width;\n                    data.preview.height = opts.preview.height;\n                } else {\n                    data.preview.width = data.preview.element.parent().width();\n                    data.preview.height = data.preview.element.parent().height();\n                }\n            }\n\n            // Set the form ID\n            if (opts.formId.length === 0) {\n                // no form ID supplied. Look for the closest parent form element\n                data.form = $this.closest(\"form\");\n                if (data.form.length === 0) {\n                    log.error(\"No form specified or found\");\n                    return;\n                }\n            } else {\n                data.form = $(opts.formId);\n                if (data.form.length === 0) {\n                    log.error(\"Invalid form ID supplied: \" + opts.formId);\n                }\n            }\n\n            // Setup form inputs\n            data.prefix = opts.inputPrefix;\n            data.inputs = {};\n            for (var i = 0; i < _.inputNames.length; i++)\n                data.inputs[_.inputNames[i]] = _._setupInput(\n                    data.form,\n                    data.prefix,\n                    _.inputNames[i]\n                );\n\n            //\n            // Initial coordinates\n            //\n            var ic = _._parseOpt(opts.initialSel);\n            if (ic.length !== 4) log.warn(\"Invalid coordinates for initial selection\");\n            else if (ic[2] - ic[0] > 0 && ic[3] - ic[1] > 0) data.initialCoords = ic;\n\n            data.aspectRatio = opts.aspectRatio;\n            data.minSize = _._parseOpt(opts.minSize);\n            data.maxSize = _._parseOpt(opts.maxSize);\n\n            var handler = function (c) {\n                _.onSelect(c, data);\n            };\n\n            $this.Jcrop(\n                {\n                    onChange: handler,\n                    onSelect: handler,\n                    onRelease: handler,\n                    aspectRatio: data.aspectRatio,\n                    setSelect: data.initialCoords,\n                    minSize: data.minSize,\n                    maxSize: data.maxSize,\n                },\n                function () {\n                    data.api = this;\n                    _.onSelect(this.tellSelect(), data);\n                }\n            );\n        });\n    },\n\n    _setupInput: function ($form, prefix, name) {\n        var input = $form.find(\"input[name=\" + prefix + name + \"]\");\n        if (input.length === 0)\n            input = $('<input type=\"hidden\" name=\"' + prefix + name + '\" />').appendTo(\n                $form\n            );\n        return input;\n    },\n\n    _parseOpt: function (val) {\n        var ret = val\n            .replace(/\\s{2,}/g, \" \")\n            .trim()\n            .split(\" \");\n        for (var i = 0; i < ret.length; i++) ret[i] = parseInt(ret[i], 10);\n        return ret;\n    },\n\n    onSelect: function (c, data) {\n        if (data.preview) _.updatePreview(c, data);\n        _.updateInputs(c, data);\n    },\n\n    updatePreview: function (c, data) {\n        if (!data.api) return;\n        if (parseInt(c.w, 10) > 0) {\n            var rx = data.preview.width / c.w,\n                ry = data.preview.height / c.h,\n                bounds = data.api.getBounds();\n\n            data.preview.element.css({\n                width: Math.round(rx * bounds[0]) + \"px\",\n                height: Math.round(ry * bounds[1]) + \"px\",\n                marginLeft: \"-\" + Math.round(rx * c.x) + \"px\",\n                marginTop: \"-\" + Math.round(ry * c.y) + \"px\",\n            });\n        }\n    },\n\n    updateInputs: function (c, data) {\n        if (c && c.w && parseInt(c.w, 10) > 0) {\n            data.inputs.x1.attr(\"value\", c.x);\n            data.inputs.y1.attr(\"value\", c.y);\n            data.inputs.x2.attr(\"value\", c.x2);\n            data.inputs.y2.attr(\"value\", c.y2);\n            data.inputs.w.attr(\"value\", c.w);\n            data.inputs.h.attr(\"value\", c.h);\n        }\n    },\n};\n\nregistry.register(_);\nexport default _;\n","import $ from \"jquery\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\nimport dom from \"../../core/dom\";\n\nvar legend = {\n    name: \"legend\",\n    trigger: \"legend\",\n\n    _convertToIframes: function ($root) {\n        $root.findInclusive(\"object[type='text/html']\").each(function () {\n            var $object = $(this),\n                $iframe = $(\"<iframe allowtransparency='true'/>\");\n\n            $iframe\n                .attr(\"id\", $object.attr(\"id\"))\n                .attr(\"class\", $object.attr(\"class\"))\n                .attr(\"src\", $object.attr(\"data\"))\n                .attr(\"frameborder\", \"0\")\n                .attr(\"style\", \"background-color:transparent\");\n            $object.replaceWith($iframe);\n        });\n    },\n\n    transform: function ($root) {\n        const root = utils.jqToNode($root);\n        const all = dom.querySelectorAllAndMe(root, \"legend:not(.disable-patterns)\");\n        for (const el of all) {\n            $(el).replaceWith(\"<p class='legend'>\" + $(el).html() + \"</p>\");\n        }\n    },\n};\nregistry.register(legend);\nexport default legend;\n","/**\n * Patternslib pattern for Masonry\n * Copyright 2015 Syslab.com GmBH\n */\nimport $ from \"jquery\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport Base from \"../../core/base\";\nimport utils from \"../../core/utils\";\n\n// Lazy loading modules.\nlet Masonry;\n\nconst log = logging.getLogger(\"pat.masonry\");\n\nexport const parser = new Parser(\"masonry\");\n// parser.addArgument(\"stagger\", \"\");\nparser.addArgument(\"column-width\");\nparser.addArgument(\"container-style\", '{ \"position\": \"relative\" }');\nparser.addArgument(\"gutter\");\nparser.addArgument(\"is-fit-width\", false);\nparser.addArgument(\"is-horizontal-order\", false); // preserve horizontal order.\nparser.addArgument(\"is-origin-left\", true);\nparser.addArgument(\"is-origin-top\", true);\nparser.addArgument(\"is-percent-position\", false); // set item positions in percent values. items will not transition on resize.\nparser.addArgument(\"is-resize\", true); // adjust sizes and position on resize.\nparser.addArgument(\"item-selector\", \".item\");\nparser.addArgument(\"stamp\", \"\");\nparser.addArgument(\"transition-duration\", \"0.4s\");\n\n// is-* are masonry v3 options, here we add v4 style names.\n// we keep the is-* as there is special support with options parsing.\nparser.addAlias(\"fit-width\", \"is-fit-width\");\nparser.addAlias(\"origin-left\", \"is-origin-left\");\nparser.addAlias(\"origin-top\", \"is-origin-top\");\nparser.addAlias(\"horizontal-order\", \"is-horizontal-order\");\nparser.addAlias(\"percent-position\", \"is-percent-position\");\nparser.addAlias(\"resize\", \"is-resize\");\n\nexport default Base.extend({\n    name: \"masonry\",\n    trigger: \".pat-masonry\",\n\n    async init($el, opts) {\n        Masonry = (await import(\"masonry-layout\")).default;\n        const ImagesLoaded = (await import(\"imagesloaded\")).default;\n\n        this.options = parser.parse(this.$el, opts);\n        // Initialize\n        this.initMasonry();\n\n        const imgLoad = await ImagesLoaded(this.$el);\n        imgLoad.on(\n            \"progress\",\n            function () {\n                if (!this.msnry) {\n                    this.initMasonry();\n                }\n                this.quicklayout();\n            }.bind(this)\n        );\n        imgLoad.on(\n            \"always\",\n            function () {\n                if (!this.msnry) {\n                    this.initMasonry();\n                }\n                this.layout();\n            }.bind(this)\n        );\n\n        // Update if something gets injected inside the pat-masonry\n        this.$el\n            .on(\n                \"patterns-injected.pat-masonry\",\n                utils.debounce(this.update.bind(this), 100)\n            )\n            .on(\"pat-update\", utils.debounce(this.quicklayout.bind(this), 200));\n\n        var callback = utils.debounce(this.quicklayout.bind(this), 400);\n        var observer = new MutationObserver(callback);\n        /* Explicitly not including style. We assume style is set dynamically only by scripts and we do all our controlled changes through classes.\n           That way we avoid masonry to react on its own style calculation */\n        var config = {\n            childList: true,\n            subtree: true,\n            characterData: false,\n            attributeOldValue: true,\n            attributes: true,\n            attributeFilter: [\"class\"],\n        };\n        observer.observe(document.body, config);\n    },\n\n    async initMasonry() {\n        var containerStyle;\n        try {\n            containerStyle = JSON.parse(this.options.containerStyle);\n        } catch (e) {\n            containerStyle = { position: \"relative\" };\n            log.warn(\n                \"Invalid value passed in as containerStyle. Needs to \" +\n                    \"be valid JSON so that it can be converted to an object for Masonry.\"\n            );\n        }\n        this.msnry = new Masonry(this.$el[0], {\n            columnWidth: this.getTypeCastedValue(this.options.columnWidth),\n            containerStyle: containerStyle,\n            fitWidth: this.options.is[\"fit-width\"],\n            gutter: this.getTypeCastedValue(this.options.gutter),\n            horizontalOrder: this.options.is[\"horizontal-order\"],\n            initLayout: false,\n            itemSelector: this.options.itemSelector,\n            originLeft: this.options.is[\"origin-left\"],\n            originTop: this.options.is[\"origin-top\"],\n            percentPosition: this.options.is[\"percent-position\"],\n            resize: this.options.is[\"resize\"],\n            stamp: this.options.stamp,\n            transitionDuration: this.options.transitionDuration,\n        });\n    },\n\n    update: function () {\n        this.msnry.remove();\n        this.initMasonry();\n        this.layout();\n    },\n\n    quicklayout: function () {\n        if (!this.msnry) {\n            // Not initialized yet\n            return;\n        }\n        // call masonry layout on the children before calling it on this element\n        this.$el.find(\".pat-masonry\").each(function (idx, child) {\n            $(child).patMasonry(\"quicklayout\");\n        });\n        this.msnry.layout();\n    },\n\n    layout: function () {\n        this.$el.removeClass(\"masonry-ready\");\n        this.msnry.on(\n            \"layoutComplete\",\n            function () {\n                this.$el.addClass(\"masonry-ready\");\n            }.bind(this)\n        );\n        this.msnry.layout();\n        this.quicklayout();\n    },\n\n    getTypeCastedValue: function (original) {\n        var val = Number(original);\n        return isNaN(val) ? original || 0 : val;\n    },\n});\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\n\nexport const parser = new Parser(\"fullscreen\");\nparser.addArgument(\"nav-item-selector\", \"li\"); // CSS Selector for navigation items.\n\nexport default Base.extend({\n    name: \"menu\",\n    trigger: \".pat-menu\",\n\n    timer: null,\n\n    init: function ($el, opts) {\n        this.options = parser.parse(this.$el, opts);\n        var self = this;\n        $el.find(this.options.navItemSelector).each(function () {\n            var $it = $(this);\n            $it.addClass(\"closed\")\n                .on(\"mouseover\", self.mouseOverHandler.bind(self))\n                .on(\"mouseout\", self.mouseOutHandler.bind(self));\n            if ($it.children(self.options.navItemSelector).length > 0) {\n                $it.addClass(\"hasChildren\");\n            }\n        });\n    },\n\n    openMenu: function (it) {\n        if (this.timer) {\n            clearTimeout(this.timer);\n            this.timer = null;\n        }\n        it = $(it);\n        if (!it.hasClass(\"open\")) {\n            it.siblings(\".open\").each(\n                function () {\n                    this.closeMenu(this.$el);\n                }.bind(this)\n            );\n            it.addClass(\"open\").removeClass(\"closed\");\n        }\n    },\n\n    closeMenu: function (it) {\n        $(it).find(\".open\").addBack().removeClass(\"open\").addClass(\"closed\");\n    },\n\n    mouseOverHandler: function (ev) {\n        this.openMenu(ev.target);\n    },\n\n    mouseOutHandler: function (ev) {\n        if (this.timer) {\n            clearTimeout(this.timer);\n            this.timer = null;\n        }\n        this.timer = setTimeout(\n            function () {\n                this.closeMenu(ev.target);\n            }.bind(this),\n            1000\n        );\n    },\n});\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport logging from \"../../core/logging\";\nimport events from \"../../core/events\";\n\nconst log = logging.getLogger(\"navigation\");\n\nexport const parser = new Parser(\"navigation\");\nparser.addArgument(\"item-wrapper\", \"li\");\nparser.addArgument(\"in-path-class\", \"navigation-in-path\");\nparser.addArgument(\"current-class\", \"current\");\n\nexport default Base.extend({\n    name: \"navigation\",\n    trigger: \".pat-navigation\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n\n        this.init_listeners();\n        this.init_markings();\n    },\n\n    /**\n     * Initialize listeners for the navigation.\n     */\n    init_listeners() {\n        const current = this.options.currentClass;\n\n        events.add_event_listener(\n            this.el,\n            \"click\",\n            \"pat_navigation_click_handler\",\n            (ev) => {\n                if (ev.target.matches(\"a:not(.pat-inject)\")) {\n                    // Remove all set current classes\n                    this.clear_items();\n                    // Mark the current item\n                    this.mark_current(ev.target);\n                }\n            }\n        );\n\n        // Mark the navigation items after pat-inject triggered within this navigation menu.\n        this.$el.on(\"patterns-inject-triggered\", \"a\", (ev) => {\n            // Remove all set current classes\n            this.clear_items();\n            // Mark the current item\n            this.mark_current(ev.target);\n        });\n\n        // Mark the navigation items after pat-inject injected into this navigation menu.\n        this.$el.on(\"patterns-injected-scanned\", () => {\n            this.init_markings();\n        });\n\n        // Automatically and recursively load the ``.current`` item.\n        if (this.el.classList.contains(\"navigation-load-current\")) {\n            // Check for current elements injected here.\n            this.$el.on(\"patterns-injected-scanned\", (ev) => {\n                const target = ev.target;\n                if (target.matches(`a.${current}`)) target.click();\n                else if (target.matches(`.${current}`)) target.querySelector(\"a\")?.click(); // prettier-ignore\n            });\n            this.el.querySelector(`a.${current}, .${current} a`)?.click();\n        }\n    },\n\n    /**\n     * Initial run to mark the current item and its parents.\n     */\n    init_markings() {\n        if (this.el.querySelector(`.${this.options.currentClass}`)) {\n            log.debug(\"Mark navigation items based on existing current class\");\n            this.mark_current();\n        } else {\n            log.debug(\"Mark navigation items based on URL pattern.\");\n            this.mark_items_url();\n        }\n    },\n\n    /**\n     * Get a matching parent or stop at stop_el.\n     *\n     * @param {Node} item - The item to start with.\n     * @param {String} selector - The CSS selector to search parent elements for.\n     * @param {Node} stop_el - The element to stop at.\n     *\n     * @returns {Node} - The matching parent or null.\n     */\n    get_parent(item, selector, stop_el) {\n        let matching_parent = item.parentNode;\n        while (matching_parent) {\n            if (matching_parent === stop_el || matching_parent === document) {\n                return null;\n            }\n            if (matching_parent.matches(selector)) {\n                return matching_parent;\n            }\n            matching_parent = matching_parent.parentNode;\n        }\n    },\n\n    /**\n     * Mark an item and it's wrapper as current.\n     *\n     * @param {Node} [current_el] - The item to mark as current.\n     *                              If not given, the element's tree will be searched for an existing current item.\n     *                              This is to also mark the wrapper and it's path appropriately.\n     */\n    mark_current(current_el) {\n        const current_els = current_el\n            ? [current_el]\n            : this.el.querySelectorAll(`.current > a, a.current`);\n\n        for (const item of current_els) {\n            item.classList.add(this.options.currentClass);\n            const wrapper = item.closest(this.options.itemWrapper);\n            wrapper?.classList.add(this.options.currentClass);\n            this.mark_in_path(wrapper || item);\n            log.debug(\"Statically set current item marked as current\", item);\n        }\n    },\n\n    /**\n     * Mark all parent navigation elements as in path.\n     *\n     * @param {Node} start_el - The element to start with.\n     *\n     */\n    mark_in_path(start_el) {\n        let path_el = this.get_parent(start_el, this.options.itemWrapper, this.el);\n        while (path_el) {\n            if (!path_el.matches(`.${this.options.currentClass}`)) {\n                path_el.classList.add(this.options.inPathClass);\n                for (const it of [...path_el.children].filter((it) => it.matches(\"a\"))) {\n                    it.classList.add(this.options.inPathClass);\n                }\n                log.debug(\"Marked item as in-path\", path_el);\n            }\n            path_el = this.get_parent(path_el, this.options.itemWrapper, this.el);\n        }\n    },\n\n    /**\n     * Mark all navigation items that are in the path of the current url.\n     *\n     * @param {String} [url] - The url to check against.\n     *                         If not given, the current url will be used.\n     */\n    mark_items_url(url) {\n        const current_url = url || this.base_url();\n        const current_url_prepared = this.prepare_url(current_url);\n\n        const portal_url = this.prepare_url(document.body.dataset?.portalUrl);\n        const nav_items = this.el.querySelectorAll(\"a\");\n\n        for (const nav_item of nav_items) {\n            // Get the nav item's url and rebase it against the current url to\n            // make absolute or relative URLs FQDN URLs.\n            const nav_url = this.prepare_url(\n                new URL(nav_item.getAttribute(\"href\", \"\"), current_url)?.href\n            );\n\n            const wrapper = nav_item.closest(this.options.itemWrapper);\n\n            if (nav_url === current_url_prepared) {\n                nav_item.classList.add(this.options.currentClass);\n                wrapper?.classList.add(this.options.currentClass);\n                this.mark_in_path(nav_item);\n            } else if (\n                // Compare the current navigation item url with a slash at the\n                // end - if it is \"inPath\" it must have a slash in it.\n                current_url_prepared.indexOf(`${nav_url}/`) === 0 &&\n                // Do not set inPath for the \"Home\" url, as this would always\n                // be in the path.\n                nav_url !== portal_url\n            ) {\n                nav_item.classList.add(this.options.inPathClass);\n                wrapper?.classList.add(this.options.inPathClass);\n            } else {\n                // Not even in path.\n                continue;\n            }\n        }\n    },\n\n    /**\n     * Clear all navigation items from the inPath and current classes\n     */\n    clear_items() {\n        const items = this.el.querySelectorAll(\n            `.${this.options.inPathClass}, .${this.options.currentClass}`\n        );\n        for (const item of items) {\n            item.classList.remove(this.options.inPathClass);\n            item.classList.remove(this.options.currentClass);\n        }\n    },\n\n    /**\n     * Prepare a URL for comparison.\n     * Plone-specific \"/view\" and \"@@\" will be removed as well as a trailing slash.\n     *\n     * @param {String} url - The url to prepare.\n     *\n     * @returns {String} - The prepared url.\n     */\n    prepare_url(url) {\n        return url?.replace(\"/view\", \"\").replaceAll(\"@@\", \"\").replace(/\\/$/, \"\");\n    },\n\n    /**\n     * Get the URL of the current page.\n     * If a ``canonical`` meta tag is found, return this.\n     * Otherwise return the window.location URL.\n     * Already prepare the URL for comparison.\n     *\n     * @returns {String} - The current URL.\n     */\n    base_url() {\n        return this.prepare_url(\n            document.querySelector('head link[rel=\"canonical\"]')?.href ||\n                window.location.href\n        );\n    },\n});\n","// Patterns notification - Display (self-healing) notifications.\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\nimport inject from \"../inject/inject\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\n// Initialize close-panel functionality.\nimport \"../close-panel/close-panel\";\n\nconst log = logging.getLogger(\"notification\");\n//log.setLevel(logging.Level.DEBUG);\n\nexport const parser = new Parser(\"notification\");\nparser.addArgument(\"type\", \"static\", [\"static\", \"banner\"]);\nparser.addArgument(\"healing\", \"5s\");\nparser.addArgument(\"controls\", \"icons\", [\"icons\", \"buttons\", \"none\"]);\nparser.addArgument(\"class\");\nparser.addArgument(\"close-text\", \"Close\");\n\nexport default Base.extend({\n    name: \"notification\",\n    trigger: \".pat-notification\",\n    count: 0,\n\n    init($el, opts) {\n        if (this.el.matches(\"a, form\")) {\n            this._init_inject($el, opts);\n        } else {\n            this._init_notification($el, opts);\n        }\n    },\n\n    _init_notification($el, opts) {\n        this.count++;\n\n        const el = $el[0];\n        const options = parser.parse($el, opts);\n        const closetext = options.closeText;\n\n        const wrapper = document.createElement(\"div\");\n        wrapper.setAttribute(\"id\", `pat-notification-${this.count}`);\n        wrapper.setAttribute(\"class\", \"pat-notification-panel\");\n        dom.wrap(el, wrapper);\n\n        events.add_event_listener(\n            wrapper,\n            \"mouseenter\",\n            \"notification__mouseenter\",\n            this.onMouseEnter.bind(this)\n        );\n        events.add_event_listener(\n            wrapper,\n            \"mouseleave\",\n            \"notification__mouseleave\",\n            this.onMouseLeave.bind(this)\n        );\n\n        if (options[\"class\"]) {\n            wrapper.classList.add(options[\"class\"]);\n        }\n\n        if (!Array.isArray(options.controls)) {\n            options.controls = [options.controls];\n        }\n\n        // add close icon if requested\n        if (options.controls.indexOf(\"icons\") >= 0) {\n            wrapper.append(\n                dom.create_from_string(\n                    `<button type=\"button\" class=\"close-panel\">${closetext}</button>`\n                )\n            );\n        }\n\n        // add close button if requested\n        if (options.controls.indexOf(\"buttons\") >= 0) {\n            wrapper.append(\n                dom.create_from_string(\n                    `<div class=\"button-bar\">\n                    <button type=\"button\" class=\"close-panel\">${closetext}</button>\n                </div>`\n                )\n            );\n        }\n\n        if (wrapper.querySelector(\".close-panel\")) {\n            events.add_event_listener(\n                wrapper,\n                \"close-panel\",\n                \"pat-notification--close-panel\",\n                this.onClick.bind(this)\n            );\n            registry.scan(wrapper, [\"close-panel\"]);\n        } else {\n            events.add_event_listener(\n                wrapper,\n                \"click\",\n                \"notification__click\",\n                this.onClick.bind(this)\n            );\n        }\n\n        if (options.type === \"banner\") {\n            let container = document.querySelector(\"#pat-notification-banners\");\n            if (!container) {\n                container = document.createElement(\"div\");\n                container.setAttribute(\"id\", \"pat-notification-banners\");\n                container.setAttribute(\"class\", \"pat-notification-container\");\n                document.body.append(container);\n            }\n            container.append(wrapper);\n        }\n\n        let healing = options.healing;\n        if (healing !== \"persistent\") {\n            healing = utils.parseTime(healing);\n        }\n\n        log.debug(`Healing value is: ${healing}`);\n        dom.set_data(wrapper, \"healing\", healing);\n\n        $el.animate({ opacity: 1 }, \"fast\", () => {\n            this.init_remove_timer(wrapper);\n        });\n    },\n\n    _init_inject($el) {\n        $el[0].addEventListener(\"pat-inject-success\", (e) => {\n            const $trigger = $(e.target);\n            const cfg = parser.parse($trigger, { type: \"banner\" });\n\n            const $temp = $(\"#pat-notification-temp\")\n                .contents()\n                .wrapAll(\"<div/>\")\n                .parent()\n                .addClass(\"pat-notification\");\n\n            if ($trigger.is(\"a\")) {\n                $trigger.after($temp);\n            } else {\n                $temp.prependTo($trigger);\n            }\n            this._init_notification($temp, cfg);\n\n            // XXX: Do this later as inject tries to access its target afterwards.\n            // This should be fixed in injection.\n            setTimeout(() => {\n                $(\"#pat-notification-temp\").remove();\n            }, 0);\n        });\n        inject.init($el, {\n            target: \"#pat-notification-temp\",\n        });\n    },\n\n    init_remove_timer(panel) {\n        const healing = dom.get_data(panel, \"healing\");\n        if (healing !== \"persistent\") {\n            clearTimeout(dom.get_data(panel, \"timer\"));\n            dom.set_data(\n                panel,\n                \"timer\",\n                setTimeout(() => {\n                    log.debug(\"Timeout reached.\");\n                    this.remove(panel);\n                }, healing)\n            );\n        }\n    },\n\n    onMouseEnter(e) {\n        dom.set_data(e.target, \"persistent\", true);\n    },\n\n    onMouseLeave(e) {\n        const panel = e.target;\n        dom.set_data(panel, \"persistent\", false);\n        this.init_remove_timer(panel);\n    },\n\n    onClick(e) {\n        const panel = e.target.closest(\".pat-notification-panel\");\n        dom.set_data(panel, \"persistent\", false);\n        this.remove(panel);\n    },\n\n    remove(panel) {\n        if (\n            dom.get_data(panel, \"persistent\") === true ||\n            dom.get_data(panel, \"removing\") === true\n        ) {\n            return;\n        }\n        const $panel = $(panel);\n\n        dom.set_data(panel, \"removing\", true);\n\n        $panel.stop(true).animate(\n            { opacity: 0 },\n            {\n                step() {\n                    if (dom.get_data(panel, \"persistent\") === true) {\n                        // remove the timer and show notification\n                        clearTimeout(dom.get_data(panel, \"timer\"));\n                        $panel.stop(true).animate({ opacity: 1 });\n                        dom.set_data(panel, \"removing\", false);\n                        return false;\n                    }\n                },\n\n                complete() {\n                    $panel.off(\".pat-notification\");\n                    $panel.slideUp(\"slow\", () => {\n                        $panel.remove();\n                    });\n                },\n            }\n        );\n    },\n});\n","import Base from \"../../core/base\";\nimport events from \"../../core/events\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\n\nconst logger = logging.getLogger(\"push\");\n\nexport const parser = new Parser(\"push\");\nparser.addArgument(\"url\", null);\nparser.addArgument(\"push-id\", null);\nparser.addArgument(\"mode\", \"replace\", [\"replace\", \"append\", \"desktop-notification\"]);\n\nconst rfp_key = \"pat-push__desktop-notification__request_for_permission\";\n\nexport default Base.extend({\n    name: \"push\",\n    trigger: \".pat-push\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n\n        if (\n            this.options.mode === \"desktop-notification\" &&\n            !(Notification.permission in [\"denied\", \"granted\"])\n        ) {\n            // Try to get a notification permission on any click.\n            events.add_event_listener(\n                document,\n                \"click\",\n                rfp_key,\n                this.desktop_notification__request_permission.bind(this)\n            );\n        }\n\n        document.body.addEventListener(\"push\", (e) => {\n            logger.debug(\"received push marker\");\n            const data = e?.detail?.body;\n            if (data === this.options.pushId) {\n                if (this.options.mode === \"desktop-notification\") {\n                    this.desktop_notification();\n                } else if (this.el.tagName === \"FORM\") {\n                    this.el.submit();\n                } else {\n                    this.perform_inject();\n                }\n            }\n        });\n    },\n\n    async perform_inject() {\n        let data = null;\n\n        try {\n            const response = await fetch(this.options.url);\n            data = await response.text();\n        } catch (e) {\n            logger.error(\n                `Could not fetch from ${this.options.url} on push-id ${this.options.pushId}.`\n            );\n        }\n\n        if (data === null) {\n            return;\n        }\n\n        if (this.options.mode === \"append\") {\n            this.el.insertAdjacentHTML(\"beforeend\", data);\n        } else {\n            this.el.innerHTML = data;\n        }\n        registry.scan(this.el);\n    },\n\n    async desktop_notification__request_permission() {\n        // Wait a bit to make the dialog more prominent...\n        await utils.timeout(1000);\n\n        // Notifications need to be granted.\n        // Note: Current browsers don't allow an automatic request for\n        //       permission but need an interaction to allow it.\n        //       The following code won't work out of the box in such cases.\n        if (!(Notification.permission in [\"denied\", \"granted\"])) {\n            Notification.requestPermission((permission) => {\n                // Unregister the event handler, which should only be necessary once.\n                events.remove_event_listener(document, rfp_key);\n\n                // Whatever the user answers, we make sure Chrome stores the information\n                if (!(\"permission\" in Notification)) {\n                    Notification.permission = permission;\n                }\n            });\n        }\n    },\n\n    async desktop_notification() {\n        // Let's check if the browser supports notifications\n        if (!(\"Notification\" in window)) {\n            logger.error(\"This browser does not support notifications.\");\n            return;\n        }\n\n        // Let's check if the user is okay to get some notification\n        if (Notification.permission !== \"granted\") {\n            return;\n        }\n\n        let data = [];\n        try {\n            const response = await fetch(this.options.url);\n            data = await response.json();\n        } catch (e) {\n            logger.error(\n                `Could not fetch from ${this.options.url} on push-id ${this.options.pushId}.`\n            );\n        }\n\n        if (!data?.length) {\n            return;\n        }\n\n        for (const message of data) {\n            const notification = new Notification(message.title, message);\n            if (message.data?.url) {\n                // If ``message.data`` contains an URL, open it.\n                // If not, the browser will simply get the focus when\n                // clicking on the desktop notification.\n                notification.addEventListener(\"click\", () => {\n                    window.open(message.data.url, \"_self\");\n\n                    // Opening a URL in a new tab from JavaScript is\n                    // equivalent to opening a popup window which is\n                    // blocked by default.\n                    // Therefore, we open the URL in the same tab and\n                    // rely on other mechanisms that the user's work\n                    // isn't lost (auto-save, form unload protection.)\n\n                    // Don't focus the originating tab.\n                    //e.preventDefault();\n                    // Open in new window.\n                    //const new_window = window.open(message.data.url, \"_blank\");\n                    //try {\n                    //    new_window.focus();\n                    //} catch (e) {\n                    //    // Opening of new window (aka \"popup\") might\n                    //    // have been blocked.\n                    //    window.focus();\n                    //}\n                });\n            }\n        }\n    },\n});\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport events from \"../../core/events\";\n\nexport const parser = new Parser(\"scroll-box\");\nparser.addArgument(\"timeout-stop\", 600); // Timeout to detect when stopping scrolling.\n\nexport default Base.extend({\n    name: \"scroll-box\",\n    trigger: \".pat-scroll-box\",\n\n    scroll_listener: null,\n    last_known_scroll_position: 0,\n    timeout_id__scroll_stop: null,\n\n    init() {\n        const el = this.el;\n        this.options = parser.parse(el);\n        this.scroll_listener = el === document.body ? window : el;\n\n        // If scolling is not possible, exit.\n        if (\n            !this.scroll_listener === window &&\n            ([\"auto\", \"scroll\"].indexOf(getComputedStyle(el).overflow) === -1 ||\n                [\"auto\", \"scroll\"].indexOf(getComputedStyle(el).overflowY) === -1)\n        ) {\n            return;\n        }\n\n        let ticking = false;\n        events.add_event_listener(\n            this.scroll_listener,\n            \"scroll\",\n            \"pat-scroll-box--scroll_listener\",\n            () => {\n                if (!ticking) {\n                    window.requestAnimationFrame(() => {\n                        this.set_scroll_classes();\n\n                        // Detect case when user stops scrolling.\n                        window.clearTimeout(this.timeout_id__scroll_stop);\n                        this.timeout_id__scroll_stop = window.setTimeout(() => {\n                            // When user stopped scrolling, set/clear scroll classes.\n                            this.clear_scrolling_classes();\n                        }, this.options.timeoutStop);\n\n                        ticking = false;\n                    });\n                    ticking = true;\n                }\n            }\n        );\n\n        // Set initial state\n        this.set_scroll_classes();\n    },\n\n    set_scroll_classes() {\n        const scroll_pos = this.get_scroll_y();\n        const el = this.el;\n\n        const to_add = [];\n\n        if (scroll_pos < this.last_known_scroll_position) {\n            to_add.push(\"scroll-up\");\n            to_add.push(\"scrolling-up\");\n        } else if (this.last_known_scroll_position < scroll_pos) {\n            to_add.push(\"scroll-down\");\n            to_add.push(\"scrolling-down\");\n        }\n\n        if (scroll_pos <= 0) {\n            to_add.push(\"scroll-position-top\");\n        } else if (\n            this.scroll_listener === window &&\n            window.innerHeight + scroll_pos >= el.scrollHeight\n        ) {\n            to_add.push(\"scroll-position-bottom\");\n        } else if (\n            this.scroll_listener !== window &&\n            el.clientHeight + scroll_pos >= el.scrollHeight\n        ) {\n            to_add.push(\"scroll-position-bottom\");\n        }\n\n        // Keep DOM manipulation calls together to let the browser optimize reflow/repaint.\n        // See: https://areknawo.com/dom-performance-case-study/\n\n        el.classList.remove(\n            \"scroll-up\",\n            \"scroll-down\",\n            \"scrolling-up\",\n            \"scrolling-down\",\n            \"scroll-position-top\",\n            \"scroll-position-bottom\"\n        );\n        el.classList.add(...to_add);\n\n        this.last_known_scroll_position = scroll_pos;\n    },\n\n    clear_scrolling_classes() {\n        // Remove ``scrolling-up`` and ``scrolling-down``\n        // but keep ``scroll-up`` and ``scroll-down``.\n        this.el.classList.remove(\"scrolling-up\", \"scrolling-down\");\n    },\n\n    get_scroll_y() {\n        if (this.scroll_listener === window) {\n            // scrolling the window\n            return window.scrollY !== undefined ? window.scrollY : window.pageYOffset; // pageYOffset for IE\n        }\n        // scrolling a DOM element\n        return this.scroll_listener.scrollTop;\n    },\n});\n","/* Patterns selectbox - Expose select option for (un)checking. */\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport dom from \"../../core/dom\";\n\nconst KEY_RESET = \"__patternslib__pat_selectbox__reset\";\n\nexport default Base.extend({\n    name: \"selectbox\",\n    trigger: \".pat-select\",\n    all_selects: [],\n\n    init() {\n        const el = this.el;\n\n        if (el.form && !el[KEY_RESET]) {\n            $(el.form).on(\"reset.pat-selectbox\", () => this.form_reset());\n            el[KEY_RESET] = true;\n        }\n\n        this.all_selects = dom.querySelectorAllAndMe(el, \"select:not([multiple])\");\n        for (const sel of this.all_selects) {\n            // create parent span if not direct child of a label\n            if (!sel.parentNode.matches(\"label\")) {\n                dom.wrap(sel, document.createElement(\"span\"));\n            }\n            this.change_select(sel);\n            $(sel).on(\"change.pat-selectbox\", () => this.change_select(sel));\n        }\n    },\n\n    destroy($el) {\n        return $el.off(\".pat-selectbox\");\n    },\n\n    form_reset() {\n        // This event is triggered before the form is reset, and we need\n        // the post-reset state to update our pattern. Use a small delay\n        // to fix this.\n        setTimeout(() => {\n            for (const sel of this.all_selects) {\n                this.change_select(sel);\n            }\n        }, 50);\n    },\n\n    change_select(el) {\n        el.parentNode.setAttribute(\"data-option\", el.querySelector(\"option:checked\")?.text || ''); // prettier-ignore\n        el.parentNode.setAttribute(\"data-option-value\", el.value);\n    },\n});\n","/**\n * Patterns URL - URL parsing utilities\n *\n * Copyright 2013 Simplon B.V.\n */\n\nfunction UrlArgumentParser() {\n    this._cache = null;\n    if (window.addEventListener) window.addEventListener(\"popstate\", this._reset);\n}\n\nUrlArgumentParser.prototype = {\n    space_pattern: /\\+/g,\n    keyvalue_pattern: /^(.+?)(?:=(.*))/,\n\n    _reset: function UrlArgumentParser_reset() {\n        this._cache = null;\n    },\n\n    _decodeQS: function UrlArgumentParser_decodeQS(bit) {\n        return decodeURIComponent(bit.replace(this.space_pattern, \" \"));\n    },\n\n    _parse: function UrlArgumentParser_parse(qs) {\n        var query = /\\?(.+)/.exec(qs),\n            params = {};\n\n        if (query === null) return params;\n\n        var parameters = query[1].split(\"&\"),\n            i,\n            parts,\n            key,\n            value;\n\n        for (i = 0; i < parameters.length; i++) {\n            if ((parts = this.keyvalue_pattern.exec(parameters[i])) === null) {\n                key = this._decodeQS(parameters[i]);\n                value = null;\n            } else {\n                key = this._decodeQS(parts[1]);\n                value = this._decodeQS(parts[2]);\n            }\n\n            if (params[key] === undefined) params[key] = [];\n            params[key].push(value);\n        }\n\n        return params;\n    },\n\n    get: function UrlArgumentParser_get() {\n        if (this._cache === null) this._cache = this._parse(window.location.search);\n        return this._cache;\n    },\n};\n\nvar url_parser = new UrlArgumentParser();\n\nexport default {\n    UrlArgumentParser: UrlArgumentParser,\n    parameters: url_parser.get.bind(url_parser),\n};\n","/**\n * Patterns remove - send event when objects are removed from the DOM\n *\n * Copyright 2012 Simplon B.V. - Wichert Akkerman\n */\nimport $ from \"jquery\";\n\nvar real_cleanData = $.cleanData;\n\n$.cleanData = function remove_cleanData(elems) {\n    var i, el;\n    for (i = 0; (el = elems[i]) !== undefined; i++) $(el).triggerHandler(\"destroy\");\n    real_cleanData.call(this, arguments);\n};\n","/**\n * Patterns slides - Automatic and customised slideshows.\n *\n * Copyright 2013 Simplon B.V. - Wichert Akkerman\n */\nimport $ from \"jquery\";\nimport registry from \"../../core/registry\";\nimport utils from \"../../core/utils\";\nimport url from \"../../core/url\";\nimport \"../../core/remove\";\n\nvar slides = {\n    name: \"slides\",\n    trigger: \".pat-slides\",\n\n    setup: function () {\n        $(document).on(\"patterns-injected\", utils.debounce(slides._reset, 100));\n    },\n\n    async init($el) {\n        if (!this.el.querySelector(\".slide\")) {\n            // no slides, nothing to do.\n            return;\n        }\n        await import(\"slides/src/slides\"); // loads ``Presentation`` globally.\n\n        var parameters = url.parameters();\n        if (parameters.slides !== undefined) {\n            var requested_ids = slides._collapse_ids(parameters.slides);\n            if (requested_ids) slides._remove_slides($el, requested_ids);\n        }\n        $el.each(function () {\n            var presentation = new window.Presentation(this),\n                $container = $(this);\n            $container\n                .data(\"pat-slide\", presentation)\n                .on(\"SlideDisplay\", slides._onSlideDisplay)\n                .on(\"SlideHide\", slides._onSlideHide);\n        });\n        return slides._hook($el);\n    },\n\n    _onSlideDisplay: function (event) {\n        var slide = event.originalEvent.detail.slide.element,\n            $videos = $(\"video\", slide);\n\n        $videos.each(function () {\n            if (this.paused) {\n                this.currentTime = 0;\n                this.play();\n            }\n        });\n    },\n\n    _onSlideHide: function (event) {\n        var slide = event.originalEvent.detail.slide.element,\n            $videos = $(\"video\", slide);\n\n        $videos.each(function () {\n            if (!this.paused) this.pause();\n        });\n    },\n\n    _collapse_ids: function (params) {\n        var ids = [];\n        params.forEach(function (param) {\n            if (param)\n                ids = ids.concat(\n                    param.split(\",\").filter(function (id) {\n                        return !!id;\n                    })\n                );\n        });\n        return ids;\n    },\n\n    _remove_slides: function ($shows, ids) {\n        var has_bad_id = function (idx, el) {\n            return ids.indexOf(el.id) === -1;\n        };\n\n        for (var i = 0; i < $shows.length; i++) {\n            var $show = $shows.eq(i),\n                $bad_slides = $show.find(\".slide[id]\").filter(has_bad_id);\n            $bad_slides.remove();\n        }\n    },\n\n    _hook: function ($el) {\n        return $el\n            .off(\"destroy.pat-slide\")\n            .on(\"destroy.pat-slide\", utils.debounce(slides._reset, 100));\n    },\n\n    _reset: function () {\n        var $container = $(this).closest(\".pat-slides\"),\n            presentation = $container.data(\"pat-slide\");\n        if (presentation) presentation.scan();\n        slides._hook($(this.trigger));\n    },\n};\n\nslides.setup();\nregistry.register(slides);\nexport default slides;\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\n\nexport const parser = new Parser(\"sortable\");\nparser.addArgument(\"selector\", \"li\");\nparser.addArgument(\"drag-class\", \"dragged\"); // Class to apply to item that is being dragged.\nparser.addArgument(\"drop\"); // Callback function for when item is dropped (null)\n\n// BBB for the mockup sortable pattern.\nparser.addAlias(\"dragClass\", \"drag-class\");\n\nexport default Base.extend({\n    name: \"sortable\",\n    trigger: \".pat-sortable\",\n\n    init: function () {\n        this.$form = this.$el.closest(\"form\");\n        this.options = parser.parse(this.$el, false);\n        this.recordPositions().addHandles().initScrolling();\n        this.$el.on(\"pat-update\", this.onPatternUpdate.bind(this));\n    },\n\n    onPatternUpdate: function (ev, data) {\n        /* Handler which gets called when pat-update is triggered within\n         * the .pat-sortable element.\n         */\n        if (data?.pattern == \"clone\") {\n            this.recordPositions();\n            data.$el.on(\"dragstart\", this.onDragStart.bind(this));\n            data.$el.on(\"dragend\", this.onDragEnd.bind(this));\n        }\n        return true;\n    },\n\n    recordPositions: function () {\n        // use only direct descendants to support nested lists\n        this.$sortables = this.$el.children().filter(this.options.selector);\n        this.$sortables.each(function (idx) {\n            $(this).data(\"patterns.sortable\", { position: idx });\n        });\n        return this;\n    },\n\n    addHandles: function () {\n        /* Add handles and make them draggable for HTML5 and IE8/9\n         * it has to be an \"a\" tag (or img) to make it draggable in IE8/9\n         */\n        var $sortables_without_handles = this.$sortables.filter(function () {\n            return $(this).find(\".sortable-handle\").length === 0;\n        });\n        var $handles = $('<a href=\"#\" class=\"sortable-handle\">⇕</a>').appendTo(\n            $sortables_without_handles\n        );\n        if (\"draggable\" in document.createElement(\"span\")) {\n            $handles.attr(\"draggable\", true);\n        } else {\n            $handles.on(\"selectstart\", function (ev) {\n                ev.preventDefault();\n            });\n        }\n        $handles.on(\"dragstart\", this.onDragStart.bind(this));\n        $handles.on(\"dragend\", this.onDragEnd.bind(this));\n        return this;\n    },\n\n    initScrolling: function () {\n        // invisible scroll activation areas\n        var scrollup = $('<div id=\"pat-scroll-up\">&nbsp;</div>'),\n            scrolldn = $('<div id=\"pat-scroll-dn\">&nbsp;</div>'),\n            scroll = $().add(scrollup).add(scrolldn);\n        scrollup.css({ top: 0 });\n        scrolldn.css({ bottom: 0 });\n        scroll.css({\n            position: \"fixed\",\n            zIndex: 999999,\n            height: 32,\n            left: 0,\n            right: 0,\n        });\n        scroll.on(\"dragover\", function (ev) {\n            ev.preventDefault();\n            if ($(\"html,body\").is(\":animated\")) {\n                return;\n            }\n            var newpos =\n                $(window).scrollTop() +\n                ($(this).attr(\"id\") === \"pat-scroll-up\" ? -32 : 32);\n            $(\"html,body\").animate({ scrollTop: newpos }, 50, \"linear\");\n        });\n        return this;\n    },\n\n    onDragEnd: function (ev) {\n        var $dragged = $(ev.target).parent();\n        $dragged.removeClass(this.options.dragClass);\n        this.$sortables.off(\".pat-sortable\");\n        this.$el.off(\".pat-sortable\");\n        $(\"#pat-scroll-up, #pat-scroll-dn\").detach();\n        var change = this.submitChangedAmount(\n            $(ev.target).closest(this.options.selector)\n        );\n        // Call the optionally passed-in callback function\n        if (this.options.drop) {\n            this.options.drop($dragged, change);\n        }\n        // Inform other patterns about sorting changes\n        $dragged.trigger(\"pat-update\", {\n            pattern: \"sortable\",\n            action: \"dragend\",\n            $el: $dragged,\n        });\n    },\n\n    submitChangedAmount: function ($dragged) {\n        /* If we are in a form, then submit the form with the right amount\n         * that the sortable element was moved up or down.\n         */\n        var $amount_input = this.$form.find(\".sortable-amount\");\n        if ($amount_input.length === 0) {\n            return;\n        }\n        var old_position = $dragged.data(\"patterns.sortable\").position;\n        this.recordPositions();\n        var new_position = $dragged.data(\"patterns.sortable\").position;\n        var change = Math.abs(new_position - old_position);\n        var direction = (new_position > old_position && \"down\") || \"up\";\n        if (this.$form.length > 0) {\n            $amount_input.val(change);\n            if (direction == \"up\") {\n                $dragged.find(\".sortable-button-up\").click();\n            } else {\n                $dragged.find(\".sortable-button-down\").click();\n            }\n        }\n        return change;\n    },\n\n    onDragStart: function (ev) {\n        var $handle = $(ev.target),\n            $dragged = $handle.parent(),\n            that = this;\n        if (typeof ev.originalEvent !== \"undefined\") {\n            // Firefox seems to need this set to any value\n            ev.originalEvent.dataTransfer.setData(\"Text\", \"\");\n            ev.originalEvent.dataTransfer.effectAllowed = [\"move\"];\n            if (\"setDragImage\" in ev.originalEvent.dataTransfer) {\n                ev.originalEvent.dataTransfer.setDragImage($dragged[0], 0, 0);\n            }\n        }\n        $dragged.addClass(this.options.dragClass);\n\n        // Scroll the list if near the borders\n        this.$el.on(\n            \"dragover.pat-sortable\",\n            function (ev) {\n                ev.preventDefault();\n                if (this.$el.is(\":animated\")) return;\n\n                var pos = ev.originalEvent.clientY + $(\"body\").scrollTop();\n                if (pos - this.$el.safeOffset().top < 32)\n                    this.$el.animate(\n                        { scrollTop: this.$el.scrollTop() - 32 },\n                        50,\n                        \"linear\"\n                    );\n                else if (this.$el.safeOffset().top + this.$el.height() - pos < 32)\n                    this.$el.animate(\n                        { scrollTop: this.$el.scrollTop() + 32 },\n                        50,\n                        \"linear\"\n                    );\n            }.bind(this)\n        );\n\n        this.$sortables.on(\n            \"dragover.pat-sortable\",\n            function (ev) {\n                // list elements are only drop targets when one element of the\n                // list is being dragged. avoids dragging between lists.\n                var $dropTarget = $(ev.target).closest(that.options.selector),\n                    midlineY =\n                        $dropTarget.safeOffset().top -\n                        $(document).scrollTop() +\n                        $dropTarget.height() / 2;\n\n                if ($dropTarget.is($dragged)) {\n                    return;\n                }\n                $dropTarget.removeClass(\"drop-target-above drop-target-below\");\n                if (ev.originalEvent.clientY > midlineY)\n                    $dropTarget.addClass(\"drop-target-below\");\n                else $dropTarget.addClass(\"drop-target-above\");\n                ev.preventDefault();\n            }.bind(this)\n        );\n\n        this.$sortables.on(\n            \"dragleave.pat-sortable\",\n            function () {\n                this.$sortables.removeClass(\"drop-target-above drop-target-below\");\n            }.bind(this)\n        );\n\n        this.$sortables.on(\"drop.pat-sortable\", function (ev) {\n            var $dropTarget = $(ev.target).closest(that.options.selector);\n            if ($dropTarget.is($dragged)) {\n                return;\n            }\n            if ($dropTarget.hasClass(\"drop-target-below\")) {\n                $dropTarget.after($dragged);\n            } else {\n                $dropTarget.before($dragged);\n            }\n            $dropTarget.removeClass(\"drop-target-above drop-target-below\");\n            ev.preventDefault();\n        });\n    },\n});\n","/**\n * Stacks pattern\n *\n * Copyright 2013 Simplon B.V. - Wichert Akkerman\n */\nimport $ from \"jquery\";\nimport Parser from \"../../core/parser\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"stacks\");\n\nexport const parser = new Parser(\"stacks\");\nparser.addArgument(\"selector\", \"> *[id]\");\nparser.addArgument(\"transition\", \"none\", [\"none\", \"css\", \"fade\", \"slide\"]);\nparser.addArgument(\"effect-duration\", \"fast\");\nparser.addArgument(\"effect-easing\", \"swing\");\n\nexport default Base.extend({\n    name: \"stacks\",\n    trigger: \".pat-stacks\",\n    document: document,\n\n    init: function ($el, opts) {\n        this.options = parser.parse(this.$el, opts);\n        this._setupStack();\n        $(this.document).on(\"click\", \"a\", this._onClick.bind(this));\n        return $el;\n    },\n\n    _setupStack: function () {\n        var selected = this._currentFragment(),\n            $sheets = this.$el.find(this.options.selector),\n            $visible = [],\n            $invisible;\n        if ($sheets.length < 2) {\n            log.warn(\"Stacks pattern: must have more than one sheet.\", this.$el[0]);\n            return;\n        }\n        if (selected) {\n            try {\n                $visible = $sheets.filter(\"#\" + selected);\n            } catch (e) {\n                selected = undefined;\n            }\n        }\n        if (!$visible.length) {\n            $visible = $sheets.first();\n            selected = $visible[0].id;\n        }\n        $invisible = $sheets.not($visible);\n        utils.hideOrShow($visible, true, { transition: \"none\" }, this.name);\n        utils.hideOrShow($invisible, false, { transition: \"none\" }, this.name);\n        this._updateAnchors(selected);\n    },\n\n    _base_URL: function () {\n        return this.document.URL.split(\"#\")[0];\n    },\n\n    _currentFragment: function () {\n        var parts = this.document.URL.split(\"#\");\n        if (parts.length === 1) {\n            return null;\n        }\n        return parts[parts.length - 1];\n    },\n\n    _onClick: function (e) {\n        var base_url = this._base_URL(),\n            href_parts = e.currentTarget.href.split(\"#\");\n        // Check if this is an in-document link and has a fragment\n        if (base_url !== href_parts[0] || !href_parts[1]) {\n            return;\n        }\n        if (!this.$el.has(\"#\" + href_parts[1]).length) {\n            return;\n        }\n        e.preventDefault();\n        this._updateAnchors(href_parts[1]);\n        this._switch(href_parts[1]);\n        $(e.target).trigger(\"pat-update\", {\n            pattern: \"stacks\",\n            originalEvent: e,\n        });\n    },\n\n    _updateAnchors: function (selected) {\n        var $sheets = this.$el.find(this.options.selector),\n            base_url = this._base_URL();\n        $sheets.each(function (idx, sheet) {\n            // This may appear odd, but: when querying a browser uses the\n            // original href of an anchor as it appeared in the document\n            // source, but when you access the href property you always get\n            // the fully qualified version.\n            var $anchors = $(\n                'a[href=\"' + base_url + \"#\" + sheet.id + '\"],a[href=\"#' + sheet.id + '\"]'\n            );\n            if (sheet.id === selected) {\n                $anchors.addClass(\"current\");\n            } else {\n                $anchors.removeClass(\"current\");\n            }\n        });\n    },\n\n    _switch: function (sheet_id) {\n        var $sheet = this.$el.find(\"#\" + sheet_id);\n        if (!$sheet.length || $sheet.hasClass(\"visible\")) {\n            return;\n        }\n        var $invisible = this.$el.find(this.options.selector).not($sheet);\n        utils.hideOrShow($invisible, false, this.options, this.name);\n        utils.hideOrShow($sheet, true, this.options, this.name);\n    },\n});\n","/**\n * Patterns subform - scoped submission of form content\n *\n * Copyright 2013 Marko Durkovic\n */\nimport $ from \"jquery\";\nimport ajax from \"../ajax/ajax\";\nimport Base from \"../../core/base\";\nimport inject from \"../inject/inject\";\nimport logging from \"../../core/logging\";\n\nconst log = logging.getLogger(\"subform\");\n\nexport default Base.extend({\n    name: \"subform\",\n    trigger: \".pat-subform\",\n\n    init($el) {\n        $el.submit(this.submit.bind(this));\n        $el.find(\"input\").on(\"keyup keypress keydown\", this.keyboard_handler.bind(this));\n        $el.find(\"button[type=submit]\").on(\"click\", this.submitClicked.bind(this));\n    },\n\n    destroy($el) {\n        $el.off(\"submit\");\n    },\n\n    scopedSubmit($el) {\n        var $form = $el.parents(\"form\"),\n            $exclude = $form.find(\":input\").filter(function () {\n                return !$(this).is($el.find(\"*\"));\n            });\n        // make other controls \"unsuccessful\"\n        log.debug(\"Hiding unwanted elements from submission.\");\n        var names = $exclude.map(function () {\n            var name = $(this).attr(\"name\");\n            return name ? name : 0;\n        });\n        $exclude.each(function () {\n            $(this).attr(\"name\", \"\");\n        });\n        if ($el.is(\".pat-inject\") || $el.is(\".pat-modal\")) {\n            inject.submitSubform($el);\n        } else {\n            // use the native handler, since there could be event handlers\n            // redirecting to inject/ajax.\n            $form[0].submit();\n        }\n        // reenable everything\n        log.debug(\"Restoring previous state.\");\n        $exclude.each(function (i) {\n            if (names[i]) {\n                $(this).attr(\"name\", names[i]);\n            }\n        });\n    },\n\n    submit(ev) {\n        ev.stopPropagation();\n        var $this = $(ev.target),\n            $button = $this.find(\"button[type=submit][formaction]\").first();\n        if ($button.length) {\n            $button.trigger(\"click\");\n        } else {\n            this.scopedSubmit($this);\n        }\n    },\n\n    keyboard_handler(ev) {\n        // If the user presses the enter key and\n        // we have an autosubmit form trigger the subform submission\n        if (ev.keyCode != 13) {\n            return;\n        }\n        var $subform = $(ev.target).parents(\".pat-subform\");\n        if (!$subform.is(\".pat-autosubmit\")) {\n            return;\n        }\n        return $subform.submit();\n    },\n\n    submitClicked(ev) {\n        ev.preventDefault();\n        ev.stopPropagation();\n        ajax.onClickSubmit(ev); // make sure the submitting button is sent with the form\n\n        var $button = $(ev.target),\n            $sub = $button.parents(\".pat-subform\").first(),\n            formaction = $button.attr(\"formaction\");\n\n        if (formaction) {\n            // override the default action and restore afterwards\n            if ($sub.is(\".pat-inject\")) {\n                var previousValue = $sub.data(\"pat-inject\");\n                $sub.data(\"pat-inject\", inject.extractConfig($sub, { url: formaction }));\n                this.scopedSubmit($sub);\n                $sub.data(\"pat-inject\", previousValue);\n            } else if ($sub.is(\".pat-modal\")) {\n                $sub.data(\"pat-inject\", [\n                    $.extend($sub.data(\"pat-inject\")[0], {\n                        url: formaction,\n                    }),\n                ]);\n                this.scopedSubmit($sub);\n            } else {\n                $sub.parents(\"form\").attr(\"action\", formaction);\n                this.scopedSubmit($sub);\n            }\n        } else {\n            this.scopedSubmit($sub);\n        }\n    },\n});\n","// Patterns switch - toggle classes on click\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport events from \"../../core/events\";\nimport logging from \"../../core/logging\";\nimport store from \"../../core/store\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.switch\");\n\nexport const parser = new Parser(\"switch\");\nparser.addArgument(\"selector\");\nparser.addArgument(\"remove\");\nparser.addArgument(\"add\");\nparser.addArgument(\"store\", \"none\", [\"none\", \"session\", \"local\"]);\n\nexport default Base.extend({\n    name: \"switch\",\n    trigger: \".pat-switch\",\n\n    init() {\n        this.options = this._validateOptions(parser.parse(this.el, this.options, true));\n\n        events.add_event_listener(this.el, \"click\", \"pat-switch--on-click\", (e) => {\n            if (e.tagName === \"A\") {\n                e.preventDefault();\n            }\n            this._go();\n        });\n\n        for (const option of this.options) {\n            if (option.store !== \"none\") {\n                option._storage = (\n                    option.store === \"local\" ? store.local : store.session\n                )(\"switch\");\n                const state = option._storage.get(option.selector);\n                if (state && state.remove === option.remove && state.add === option.add)\n                    this._update(option.selector, state.remove, state.add);\n            }\n        }\n    },\n\n    destroy() {\n        events.remove_event_listener(this.el, \"pat-switch--on-click\");\n    },\n\n    execute() {\n        // jQuery API to toggle a switch\n        this._go();\n    },\n\n    _go() {\n        for (const option of this.options) {\n            this._update(option.selector, option.remove, option.add);\n            if (option._storage)\n                option._storage.set(option.selector, {\n                    remove: option.remove,\n                    add: option.add,\n                });\n        }\n        $(this.el).trigger(\"resize\"); // See: https://github.com/Patternslib/Patterns/pull/539\n    },\n\n    _validateOptions: function (options) {\n        var correct = [];\n\n        let logged_error = false;\n        for (var i = 0; i < options.length; i++) {\n            var option = options[i];\n            if (option.selector && (option.remove || option.add)) {\n                correct.push(option);\n            } else {\n                log.error(\n                    \"Switch pattern requires selector and one of add or remove.\",\n                    this.el\n                );\n                logged_error = true;\n            }\n        }\n\n        if (!correct.length && !logged_error) {\n            log.error(\"Switch without options cannot be initialized.\", this.el);\n        }\n\n        return correct;\n    },\n\n    _update: function (selector, remove, add) {\n        const targets = document.querySelectorAll(selector);\n        for (const target of targets) {\n            if (remove) {\n                utils.removeWildcardClass(target, remove);\n            }\n\n            if (add) {\n                target.classList.add(add);\n            }\n\n            $(target).trigger(\"pat-update\", { pattern: \"switch\" });\n        }\n    },\n});\n","import Base from \"../../core/base\";\nimport utils from \"../../core/utils\";\n\nexport default Base.extend({\n    name: \"syntax-highlight\",\n    trigger: \".pat-syntax-highlight\",\n\n    async init() {\n        const Prettify = (await import(\"google-code-prettify/src/prettify\")).default; // prettier-ignore\n        this.$el.addClass(\"prettyprint\");\n        utils.debounce(Prettify.prettyPrint, 50)();\n    },\n});\n","import $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\nimport dom from \"../../core/dom\";\n\nconst logger = logging.getLogger(\"tabs\");\nexport const DEBOUNCE_TIMEOUT = 10;\n\n//logger.setLevel(logging.Level.DEBUG);\n\nexport default Base.extend({\n    name: \"tabs\",\n    trigger: \".pat-tabs\",\n    jquery_plugin: true,\n    allowed_update_patterns: [\n        \"stacks\",\n        \"switch\",\n        \"auto-scale\",\n        \"grid\",\n        \"equaliser\",\n        \"masonry\",\n        \"zoom\",\n    ],\n\n    init() {\n        // debounce_resize to cancel previous runs of adjust_tabs\n        const debounced_resize = utils.debounce(\n            this.adjust_tabs.bind(this),\n            DEBOUNCE_TIMEOUT\n        );\n\n        // ResizeObserver allows for calling the adjust_tabs method after an\n        // animation is done, e.g. a menu is slided in. At the end of the\n        // animation the calculation is done with the final layout.\n        let previous_parent_width = utils.get_bounds(this.el.parentElement).width;\n        this.resize_observer = new ResizeObserver((entry) => {\n            const width = parseInt(entry[0].contentRect.width, 10);\n            // Only run the resize callback for changes in width.\n            // Apply a threshold of 3 pixels to compensate for rounding errors\n            // and not run this adjust_tabs for very small layout changes.\n            if (Math.abs(width - previous_parent_width) > 3) {\n                logger.debug(\"Entering resize observer\");\n                previous_parent_width = width;\n                debounced_resize();\n            }\n        });\n        this.resize_observer.observe(this.el.parentElement); // observe on size changes of parent.\n\n        // Also listen for ``pat-update`` event for cases where no resize but\n        // an immediate display of the element is done.\n        $(\"body\").on(\"pat-update\", (e, data) => {\n            if (this.allowed_update_patterns.includes(data?.pattern)) {\n                logger.debug(\"pat-update received.\");\n                debounced_resize();\n            }\n        });\n\n        debounced_resize();\n    },\n\n    async adjust_tabs() {\n        logger.debug(\"Entering adjust_tabs\");\n        logger.debug(\"Element:\");\n        logger.debug(this.el);\n\n        this.el.classList.remove(\"tabs-ready\");\n        this.el.classList.remove(\"tabs-wrapped\");\n        this._flatten_tabs();\n        this.dimensions = this._get_dimensions();\n        await this._adjust_tabs();\n        this.el.classList.add(\"tabs-ready\");\n    },\n\n    _flatten_tabs() {\n        // Remove the extra-tabs structure and place all tabs directly under .pat-tabs\n        const extra_wrapper = this.el.querySelector(\".extra-tabs\");\n        if (extra_wrapper) {\n            this.el.append(...extra_wrapper.children);\n            extra_wrapper.remove();\n        }\n    },\n\n    _get_dimensions() {\n        const bounds = utils.get_bounds(this.el);\n        const x = bounds.x;\n        const width = bounds.width;\n        const border_left = dom.get_css_value(this.el, \"border-left\", true);\n        const padding_left = dom.get_css_value(this.el, \"padding-left\", true);\n        const border_right = dom.get_css_value(this.el, \"border-right\", true);\n        const padding_right = dom.get_css_value(this.el, \"padding-right\", true);\n        const max_width =\n            width - border_left - padding_left - padding_right - border_right;\n        const max_x = bounds.x + max_width + border_left + padding_left;\n\n        const dimensions = {\n            x: x,\n            max_x: max_x,\n            width: width,\n            max_width: max_width,\n            border_left: border_left,\n            border_right: border_right,\n            padding_left: padding_left,\n            padding_right: padding_right,\n        };\n\n        logger.debug(\"dimensions:\");\n        logger.debug(dimensions);\n\n        return dimensions;\n    },\n\n    async _adjust_tabs() {\n        logger.debug(\"Entering _adjust_tabs\");\n        const children = [...this.el.children].filter(\n            (it) =>\n                dom.is_visible(it) && dom.get_css_value(it, \"position\") !== \"absolute\"\n        ); // remove elements, which do not count against available width.\n\n        const children_no_extra = children.filter(\n            (it) => !it.classList.contains(\"extra-tabs\")\n        );\n\n        if (children_no_extra.length === 0) {\n            // nothing to do.\n            logger.debug(\"no children, exit _adjust_tabs.\");\n            return;\n        }\n\n        // Check if tabs fit into one line by checking their start position not\n        // exceeding the available inner width or if they are not broken to a\n        // new line.\n        // This also takes whitespace between elements into account.\n        let last_x;\n        let tabs_fit = true;\n        // iterate over all children excluding absolutely positioned or invisible elements.\n        for (const it of children) {\n            const bounds = utils.get_bounds(it);\n            const it_x = bounds.x;\n            const it_w = bounds.width + dom.get_css_value(this.el, \"margin-right\", true);\n\n            logger.debug(\"Item:\");\n            logger.debug(it);\n            logger.debug(`\n                item dimensions: x: ${it_x},\n                width: ${it_w},\n                max x: ${it_x + it_w},\n                last_x: ${last_x}\n            `);\n\n            if (\n                (last_x && last_x - 3 > it_x) ||\n                it_x + it_w - 3 > this.dimensions.max_x\n                // -3 pixel to compensate for rounding errors (x, width, margin-right).\n            ) {\n                // this tab exceeds initial available width or\n                // breaks into a new line when width\n                tabs_fit = false;\n                break;\n            }\n\n            // Next position-left must be greater than last position-left plus element width.\n            last_x = it_x + it_w;\n        }\n        if (tabs_fit) {\n            // allright, nothing to do\n            logger.debug(\"tabs fit, exit _adjust_tabs.\");\n            return;\n        }\n\n        logger.debug(\"Breaks into new line.\");\n\n        let extra_tabs = this.el.querySelector(\".extra-tabs\");\n        if (!extra_tabs) {\n            logger.debug(\"Creating .extra-tabs element.\");\n            extra_tabs = document.createElement(\"span\");\n            extra_tabs.classList.add(\"extra-tabs\");\n            this.el.classList.add(\"closed\");\n            this.el.classList.add(\"tabs-wrapped\");\n\n            extra_tabs.addEventListener(\"click\", () => {\n                // Toggle opened/closed class on extra-tabs\n                if (this.el.classList.contains(\"open\")) {\n                    this.el.classList.remove(\"open\");\n                    this.el.classList.add(\"closed\");\n                } else {\n                    this.el.classList.remove(\"closed\");\n                    this.el.classList.add(\"open\");\n                }\n            });\n\n            this.el.append(extra_tabs);\n            await utils.animation_frame(); // Wait for CSS to be applied.\n            this.dimensions = this._get_dimensions(); // Update dimensions after CSS was applied\n        }\n\n        logger.debug(\"Prepend last tab to .extra_tabs.\");\n        // ... but exclude `.extra-tabs` if it is part of children.\n        extra_tabs.prepend(children_no_extra.pop());\n\n        await utils.animation_frame();\n        await this._adjust_tabs();\n    },\n});\n","/**\n * Patterns toggle - toggle class on click\n *\n * Copyright 2012-2014 Simplon B.V. - Wichert Akkerman\n */\nimport $ from \"jquery\";\nimport Base from \"../../core/base\";\nimport logging from \"../../core/logging\";\nimport Parser from \"../../core/parser\";\nimport store from \"../../core/store\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat.toggle\");\n\nexport const parser = new Parser(\"toggle\");\nparser.addArgument(\"selector\");\nparser.addArgument(\"event\");\nparser.addArgument(\"attr\", \"class\");\nparser.addArgument(\"value\");\nparser.addArgument(\"store\", \"none\", [\"none\", \"session\", \"local\"]);\n\nexport function ClassToggler(values) {\n    this.values = values.slice(0);\n    if (this.values.length > 1) this.values.push(values[0]);\n}\n\nClassToggler.prototype = {\n    toggle(el) {\n        const current = this.get(el);\n        const next = this.next(current);\n        this.set(el, next);\n        return next;\n    },\n\n    get(el) {\n        const classes = el.className.split(/\\s+/);\n        for (const value of this.values) {\n            if (classes.indexOf(value) !== -1) {\n                return value;\n            }\n        }\n        return null;\n    },\n\n    set(el, value) {\n        const values = this.values;\n        let classes = el.className.split(/\\s+/);\n        classes = classes.filter((it) => it && values.indexOf(it) === -1);\n        if (value) {\n            classes.push(value);\n        }\n        el.className = classes.join(\" \");\n        $(el).trigger(\"pat-update\", { pattern: \"toggle\" });\n    },\n\n    next(current) {\n        if (this.values.length === 1) {\n            return current ? null : this.values[0];\n        }\n        for (let i = 0; i < this.values.length - 1; i++) {\n            if (this.values[i] === current) {\n                return this.values[i + 1];\n            }\n        }\n        return this.values[0];\n    },\n};\n\nexport function AttributeToggler(attribute) {\n    this.attribute = attribute;\n}\n\nAttributeToggler.prototype = new ClassToggler([]);\nAttributeToggler.prototype.get = function (el) {\n    return !!el[this.attribute];\n};\n\nAttributeToggler.prototype.set = function (el, value) {\n    if (value) el[this.attribute] = value;\n    else el.removeAttribute(this.attribute);\n};\n\nAttributeToggler.prototype.next = function (value) {\n    return !value;\n};\n\nexport default Base.extend({\n    name: \"toggle\",\n    trigger: \".pat-toggle\",\n\n    init() {\n        const options = this._validateOptions(parser.parse(this.$el, true));\n        this.options = options;\n\n        if (!options.length) {\n            return;\n        }\n\n        let event_name;\n        for (const option of options) {\n            if (option.value_storage) {\n                const victims = $(option.selector);\n                if (!victims.length) {\n                    continue;\n                }\n                const state = option.toggler.get(victims[0]);\n                const last_state = option.value_storage.get();\n                if (state !== last_state && last_state !== null) {\n                    for (const victim of victims) {\n                        option.toggler.set(victim, last_state);\n                    }\n                }\n            }\n            if (option.event) {\n                event_name = option.event;\n            } else {\n                event_name = \"click\";\n            }\n        }\n\n        // Clicking a label of a checkbox would submit two click events - once\n        // for the label, the other for the checkbox.\n        // Using debounce, we prevent double-toggle which would result in\n        // toggling having no effect.\n        this.click_debouncer = utils.debounce(() => {\n            this._onClick();\n        }, 1);\n\n        this.$el\n            .off(\".toggle\")\n            .on(`${event_name || \"click\"}.toggle`, () => this.click_debouncer())\n            .on(\"keypress.toggle\", this._onKeyPress.bind(this));\n    },\n\n    _makeToggler(option) {\n        if (option.attr === \"class\") {\n            let values = option.value.split(/\\s+/);\n            values = values.filter((v) => v.length);\n            return new ClassToggler(values);\n        } else {\n            return new AttributeToggler(option.attr);\n        }\n    },\n\n    _validateOptions(options) {\n        const correct = [];\n\n        if (!options.length) {\n            return correct;\n        }\n\n        for (const [idx, option] of options.entries()) {\n            if (!option.selector) {\n                log.error(\"Toggle pattern requires a selector.\");\n                continue;\n            }\n            if (option.attr !== \"class\" && option.value) {\n                log.warn(\"Values are not supported attributes other than class.\");\n                continue;\n            }\n            if (option.attr === \"class\" && !option.value) {\n                log.error(\"Toggle pattern needs values for class attributes.\");\n                continue;\n            }\n            if (idx && option.store !== \"none\") {\n                log.warn(\"store option can only be set on first argument\");\n                option.store = \"none\";\n            }\n            if (option.store !== \"none\") {\n                if (!this.el.id) {\n                    log.warn(\"state persistance requested, but element has no id\");\n                    option.store = \"none\";\n                } else if (!store.supported) {\n                    log.warn(\n                        \"state persistance requested, but browser does not support webstorage\"\n                    );\n                    option.store = \"none\";\n                } else {\n                    const storage = (\n                        option.store === \"local\" ? store.local : store.session\n                    )(this.name);\n                    option.value_storage = new store.ValueStorage(\n                        storage,\n                        `${this.el.id}-${idx}`\n                    );\n                }\n            }\n            option.toggler = this._makeToggler(option);\n            correct.push(option);\n        }\n        return correct;\n    },\n\n    _onClick() {\n        let updated = false;\n\n        for (const option of this.options) {\n            const victims = $(option.selector);\n            if (!victims.length) {\n                continue;\n            }\n            const toggler = option.toggler;\n            const next_state = toggler.toggle(victims[0]);\n            for (let j = 1; j < victims.length; j++) {\n                toggler.set(victims[j], next_state);\n            }\n            if (option.value_storage) {\n                option.value_storage.set(next_state);\n            }\n            updated = true;\n        }\n        if (updated) {\n            // XXX: Is this necessary? pat-update gets called on changed\n            // element above.\n            this.$el.trigger(\"pat-update\", { pattern: \"toggle\" });\n        }\n    },\n\n    _onKeyPress(event) {\n        const keycode = event.keyCode ? event.keyCode : event.which;\n        if (keycode === \"13\") {\n            this.$el.trigger(\"click\");\n        }\n    },\n});\n","// Patterns validate - Form vlidation\nimport \"../../core/polyfills\"; // SubmitEvent.submitter for Safari < 15.4 and jsDOM\nimport Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport dom from \"../../core/dom\";\nimport events from \"../../core/events\";\nimport logging from \"../../core/logging\";\nimport utils from \"../../core/utils\";\n\nconst log = logging.getLogger(\"pat-validation\");\n//log.setLevel(logging.Level.DEBUG);\n\nexport const parser = new Parser(\"validation\");\nparser.addArgument(\"disable-selector\", \"[type=submit], button:not([type=button])\"); // Elements which must be disabled if there are errors\nparser.addArgument(\"message-date\", \"\"); // \"This value must be a valid date\");\nparser.addArgument(\"message-datetime\", \"\"); // \"This value must be a valid date and time\");\nparser.addArgument(\"message-email\", \"\"); // \"This value must be a valid email address\");\nparser.addArgument(\"message-max\", \"\"); // \"This value must be less than or equal to %{count}\");\nparser.addArgument(\"message-min\", \"\"); // \"This value must be greater than or equal to %{count}\"); // prettier-ignore\nparser.addArgument(\"message-number\", \"\"); // \"This value must be a number\");\nparser.addArgument(\"message-required\", \"\"); // \"This field is required\");\nparser.addArgument(\"message-equality\", \"is not equal to %{attribute}.\");\nparser.addArgument(\"not-after\", null);\nparser.addArgument(\"not-before\", null);\nparser.addArgument(\"equality\", null);\nparser.addArgument(\"delay\", 100); // Delay before validation is done to avoid validating while typing.\n\n// Template for the validation message\nparser.addArgument(\n    \"error-template\",\n    '<em class=\"validation warning message\">${this.message}</em>'\n);\n\n// BBB\n// TODO: deprecated. Will be removed with next major version.\nparser.addAlias(\"message-integer\", \"message-number\");\n\nconst KEY_ERROR_EL = \"__patternslib__input__error__el\";\nconst KEY_ERROR_MSG = \"__patternslib__input__error__msg\";\n\nexport default Base.extend({\n    name: \"validation\",\n    trigger: \"form.pat-validation\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n        this.inputs = [\n            ...this.el.querySelectorAll(\"input[name], select[name], textarea[name]\"),\n        ];\n        this.disabled_elements = [\n            ...this.el.querySelectorAll(this.options.disableSelector),\n        ];\n\n        // Set ``novalidate`` attribute to disable the browser's validation\n        // bubbles but not disable the validation API.\n        this.el.setAttribute(\"novalidate\", \"\");\n\n        for (const [cnt, input] of this.inputs.entries()) {\n            // Cancelable debouncer.\n            const debouncer = utils.debounce((e) => {\n                this.check_input({ input: input, event: e });\n                if (this.disabled_elements.some((it) => it.disabled)) {\n                    // If there are already any disabled elements, do a check\n                    // for the whole form.\n                    // This is necessary otherwise the submit button is already\n                    // disabled and no other errors would be shown.\n                    // This is debounced, so it should not disturb too much while typing.\n                    for (const _input of this.inputs.filter((it) => it !== input)) {\n                        this.check_input({ input: _input });\n                    }\n                }\n            }, this.options.delay);\n\n            events.add_event_listener(\n                input,\n                \"input\",\n                `pat-validation--input-${input.name}--${cnt}--validator`,\n                (e) => debouncer(e)\n            );\n            events.add_event_listener(\n                input,\n                \"change\",\n                `pat-validation--change-${input.name}--${cnt}--validator`,\n                (e) => debouncer(e)\n            );\n            events.add_event_listener(\n                input,\n                \"blur\",\n                `pat-validation--blur-${input.name}--${cnt}--validator`,\n                (e) => debouncer(e)\n            );\n        }\n\n        events.add_event_listener(\n            this.el,\n            \"submit\",\n            `pat-validation--submit--validator`,\n            (e) => {\n                // On submit, check all.\n                // Immediate, non-debounced check with submit. Otherwise submit\n                // is not cancelable.\n                for (const input of this.inputs) {\n                    this.check_input({ input: input, event: e });\n                }\n            }\n        );\n    },\n\n    check_input({ input, event, stop = false }) {\n        if (input.disabled) {\n            // No need to check disabled inputs.\n            return;\n        }\n\n        // In any case, clear the custom validity first.\n        this.set_validity({ input: input, msg: \"\" });\n        const validity_state = input.validity;\n\n        if (event?.submitter?.hasAttribute(\"formnovalidate\")) {\n            // Do not submit when a button with ``formnovalidate`` was used.\n            return;\n        }\n\n        log.debug(`\n            validity_state.badInput ${validity_state.badInput}\n            validity_state.customError ${validity_state.customError}\n            validity_state.patternMismatch ${validity_state.patternMismatch}\n            validity_state.rangeOverflow ${validity_state.rangeOverflow}\n            validity_state.rangeUnderflow ${validity_state.rangeUnderflow}\n            validity_state.stepMismatch ${validity_state.stepMismatch}\n            validity_state.tooLong ${validity_state.tooLong}\n            validity_state.tooShort ${validity_state.tooShort}\n            validity_state.typeMismatch ${validity_state.typeMismatch}\n            validity_state.valid ${validity_state.valid}\n            validity_state.valueMissing ${validity_state.valueMissing}\n        `);\n\n        const input_options = parser.parse(input);\n\n        if (validity_state.valid) {\n            // Custom error cases or no invalid state.\n\n            if (\n                input_options.equality &&\n                this.el.querySelector(`[name=${input_options.equality}]`)?.value !==\n                    input.value\n            ) {\n                const message =\n                    input_options.message.equality ||\n                    `The value is not equal to %{attribute}`;\n                this.set_validity({\n                    input: input,\n                    msg: message,\n                    attribute: input_options.equality,\n                });\n            } else if (input_options.not.after || input_options.not.before) {\n                const msg = input_options.message.date || input_options.message.datetime;\n\n                let not_after;\n                let not_after_el;\n                if (input_options.not.after) {\n                    if (utils.is_iso_date_time(input_options.not.after, true)) {\n                        not_after = new Date(input_options.not.after);\n                    } else {\n                        // Handle value as selector\n                        not_after_el = document.querySelector(input_options.not.after);\n                        not_after = not_after_el?.value\n                            ? new Date(not_after_el?.value)\n                            : undefined;\n                    }\n\n                    // Use null if no valid date.\n                    not_after = isNaN(not_after) ? null : not_after;\n                }\n\n                let not_before;\n                let not_before_el;\n                if (input_options.not.before) {\n                    if (utils.is_iso_date_time(input_options.not.before, true)) {\n                        not_before = new Date(input_options.not.before);\n                    } else {\n                        // Handle value as selector\n                        not_before_el = document.querySelector(input_options.not.before);\n                        not_before = not_before_el?.value\n                            ? new Date(not_before_el?.value)\n                            : undefined;\n                    }\n\n                    // Use null if no valid date.\n                    not_before = isNaN(not_before) ? null : not_before;\n                }\n\n                if (\n                    input.value &&\n                    utils.is_iso_date_time(input.value, true) &&\n                    !isNaN(new Date(input.value))\n                ) {\n                    // That's 1 valid date!\n                    const date = new Date(input.value);\n\n                    if (not_after && date > not_after) {\n                        this.set_validity({ input: input, msg: msg });\n                    } else if (not_before && date < not_before) {\n                        this.set_validity({ input: input, msg: msg });\n                    }\n                }\n\n                // always check the other input to clear/set errors\n                !stop && // do not re-check when stop is set to avoid infinite loops\n                    not_after_el &&\n                    this.check_input({ input: not_after_el, stop: true });\n                !stop &&\n                    not_before_el &&\n                    this.check_input({ input: not_before_el, stop: true });\n            }\n\n            if (!validity_state.customError) {\n                // No error to handle. Return.\n                this.remove_error(input, true);\n                return;\n            }\n        } else {\n            // Default error cases with custom messages.\n\n            if (validity_state.valueMissing && input_options.message.required) {\n                this.set_validity({ input: input, msg: input_options.message.required });\n            } else if (validity_state.rangeUnderflow && input_options.message.min) {\n                this.set_validity({\n                    input: input,\n                    msg: input_options.message.min,\n                    min: input.getAttribute(\"min\"),\n                });\n            } else if (validity_state.rangeOverflow && input_options.message.max) {\n                this.set_validity({\n                    input: input,\n                    msg: input_options.message.max,\n                    max: input.getAttribute(\"max\"),\n                });\n            } else if (\n                (validity_state.badInput || validity_state.stepMismatch) &&\n                input.type === \"number\" &&\n                input_options.message.number\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.number });\n            } else if (\n                validity_state.typeMismatch &&\n                input.type === \"email\" &&\n                input_options.message.email\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.email });\n            } else if (\n                validity_state.rangeUnderflow &&\n                input.type === \"date\" &&\n                input_options.message.date\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.date });\n            } else if (\n                validity_state.rangeOverflow &&\n                input.type === \"date\" &&\n                input_options.message.date\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.date });\n            } else if (\n                validity_state.rangeUnderflow &&\n                input.type === \"datetime\" &&\n                input_options.message.datetime\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.datetime });\n            } else if (\n                validity_state.rangeOverflow &&\n                input.type === \"datetime\" &&\n                input_options.message.datetime\n            ) {\n                this.set_validity({ input: input, msg: input_options.message.datetime });\n            }\n        }\n\n        if (event?.type === \"submit\") {\n            // Do not submit in error case and prevent other handlers to take action.\n            event.preventDefault();\n            event.stopPropagation();\n            event.stopImmediatePropagation();\n        }\n        this.set_error_message(input, input_options);\n    },\n\n    set_validity({ input, msg, attribute = null, min = null, max = null }) {\n        // Replace some variables, as like validate.js\n        if (attribute) {\n            msg = msg.replace(/%{attribute}/g, attribute);\n        }\n        if (min) {\n            msg = msg.replace(/%{count}/g, min);\n        }\n        if (max) {\n            msg = msg.replace(/%{count}/g, max);\n        }\n        msg = msg.replace(/%{value}/g, JSON.stringify(input.value));\n\n        input.setCustomValidity(msg);\n        // Store the error message on the input.\n        // Hidden inputs do not participate in validation but we need this\n        // (e.g. styled date input).\n        input[KEY_ERROR_MSG] = msg;\n    },\n\n    remove_error(input, all_of_group = false) {\n        // Remove error message and related referencesfrom input.\n\n        let inputs = [input];\n        if (all_of_group) {\n            // Get all inputs with the same name - e.g. radio buttons, checkboxes.\n            inputs = this.inputs.filter((it) => it.name === input.name);\n        }\n        for (const it of inputs) {\n            const error_node = it[KEY_ERROR_EL];\n            it[KEY_ERROR_EL] = null;\n            error_node?.remove();\n        }\n\n        // disable selector\n        if (this.el.checkValidity()) {\n            for (const it of this.disabled_elements) {\n                if (it.disabled) {\n                    it.removeAttribute(\"disabled\");\n                    it.classList.remove(\"disabled\");\n                }\n            }\n        }\n    },\n\n    set_error_message(input, options) {\n        this.remove_error(input);\n\n        // Do not set a error message for a input group like radio buttons or\n        // checkboxes where one has already been set.\n        const inputs = this.inputs.filter((it) => it.name === input.name);\n        if (inputs.length > 1 && inputs.some((it) => !!it[KEY_ERROR_EL])) {\n            // error message for input group already set.\n            return;\n        }\n\n        // Create the validation error DOM node from the template\n        const validation_message = input.validationMessage || input[KEY_ERROR_MSG];\n        const error_template = dom.template(options.errorTemplate, {\n            message: validation_message,\n        });\n        const error_node = dom.create_from_string(error_template).firstChild;\n\n        let fieldset;\n        if (input.type === \"radio\" || input.type === \"checkbox\") {\n            fieldset = input.closest(\"fieldset.pat-checklist\");\n        }\n        if (fieldset) {\n            fieldset.append(error_node);\n        } else {\n            input.after(error_node);\n        }\n        input[KEY_ERROR_EL] = error_node;\n\n        for (const it of this.disabled_elements) {\n            if (!it.disabled) {\n                it.setAttribute(\"disabled\", \"disabled\");\n                it.classList.add(\"disabled\");\n            }\n        }\n    },\n});\n","import $ from \"jquery\";\nimport registry from \"../../core/registry\";\nimport Parser from \"../../core/parser\";\n\nexport const parser = new Parser(\"zoom\");\nparser.addArgument(\"min\", 0);\nparser.addArgument(\"max\", 2);\n\nvar zoom = {\n    name: \"zoom\",\n    trigger: \".pat-zoom\",\n\n    init: function ($el, opts) {\n        return $el.each(function () {\n            var $block = $(this),\n                options = parser.parse($block, opts);\n\n            let $slider = $(\"<input/>\", {\n                type: \"range\",\n                step: \"any\",\n                value: 1,\n                min: options.min,\n                max: options.max,\n            });\n\n            $slider.insertBefore($block).on(\"change input\", null, $block, zoom.onZoom);\n        });\n    },\n\n    onZoom: function (event) {\n        var $block = event.data;\n        $block.css(\"zoom\", this.value);\n    },\n};\n\nregistry.register(zoom);\nexport default zoom;\n","import Base from \"../../core/base\";\nimport Parser from \"../../core/parser\";\nimport logging from \"../../core/logging\";\n\nconst log = logging.getLogger(\"minimalpattern\");\n\nexport const parser = new Parser(\"minimalpattern\");\nparser.addArgument(\"background-color\", \"green\");\n\nexport default Base.extend({\n    name: \"minimalpattern\",\n    trigger: \".pat-minimalpattern\",\n\n    init() {\n        this.options = parser.parse(this.el, this.options);\n        this.el.addEventListener(\"click\", this.change_color.bind(this));\n        log.info(\"pattern initialized\");\n    },\n\n    change_color(e) {\n        e.preventDefault();\n        this.el.style[\"background-color\"] = this.options.backgroundColor;\n        log.info(\"element clicked\");\n    },\n});\n","/* Patterns bundle configuration.\n * All imports here will go into the compiled bundle.\n */\n\n// Import base\nimport \"./globals\";\nimport registry from \"./core/registry\";\nimport \"modernizr\";\n\n// Import all used patterns for the bundle to be generated\nimport \"./core/push_kit\";\nimport \"./pat/ajax/ajax\";\nimport \"./pat/auto-scale/auto-scale\";\nimport \"./pat/auto-submit/auto-submit\";\nimport \"./pat/auto-suggest/auto-suggest\";\nimport \"./pat/autofocus/autofocus\";\nimport \"./pat/breadcrumbs/breadcrumbs\";\nimport \"./pat/bumper/bumper\";\nimport \"./pat/calendar/calendar\";\nimport \"./pat/carousel/carousel\";\nimport \"./pat/checklist/checklist\";\nimport \"./pat/clone/clone\";\nimport \"./pat/collapsible/collapsible\";\nimport \"./pat/colour-picker/colour-picker\";\nimport \"./pat/date-picker/date-picker\";\nimport \"./pat/datetime-picker/datetime-picker\";\nimport \"./pat/depends/depends\";\nimport \"./pat/display-time/display-time\";\nimport \"./pat/equaliser/equaliser\";\nimport \"./pat/expandable-tree/expandable-tree\";\nimport \"./pat/focus/focus\";\nimport \"./pat/form-state/form-state\";\nimport \"./pat/forward/forward\";\nimport \"./pat/fullscreen/fullscreen-close\";\nimport \"./pat/fullscreen/fullscreen\";\nimport \"./pat/gallery/gallery\";\nimport \"./pat/image-crop/image-crop\";\nimport \"./pat/inject/inject\";\nimport \"./pat/legend/legend\"; // NOTE: Transforms <legend> tags to <p class=\"legend\"> for styling reasons.\nimport \"./pat/markdown/markdown\";\nimport \"./pat/masonry/masonry\";\nimport \"./pat/menu/menu\";\nimport \"./pat/modal/modal\";\nimport \"./pat/navigation/navigation\";\nimport \"./pat/notification/notification\";\nimport \"./pat/push/push\";\nimport \"./pat/scroll-box/scroll-box\";\nimport \"./pat/scroll/scroll\";\nimport \"./pat/selectbox/selectbox\";\nimport \"./pat/slides/slides\";\nimport \"./pat/sortable/sortable\";\nimport \"./pat/stacks/stacks\";\nimport \"./pat/subform/subform\";\nimport \"./pat/switch/switch\";\nimport \"./pat/syntax-highlight/syntax-highlight\";\nimport \"./pat/tabs/tabs\";\nimport \"./pat/toggle/toggle\";\nimport \"./pat/tooltip/tooltip\";\nimport \"./pat/validation/validation\";\nimport \"./pat/zoom/zoom\";\n\n// example pattern\nimport \"./pat/minimalpattern/minimalpattern\";\n\n// External patterns\nimport \"@patternslib/pat-content-mirror\";\nimport \"@patternslib/pat-doclock\";\nimport \"@patternslib/pat-shopping-cart\";\nimport \"@patternslib/pat-sortable-table\";\nimport \"@patternslib/pat-tiptap\";\nimport \"@patternslib/pat-upload\";\n\n// Importing pattern styles in JavaScript\n// Set to ``true`` to include core styles via JavaScript\n//window.__patternslib_import_styles = false;\n\nregistry.init();\n","var map = {\n\t\"./af.js\": [\n\t\t42786,\n\t\t381,\n\t\t2786\n\t],\n\t\"./ar-dz.js\": [\n\t\t14130,\n\t\t381,\n\t\t4130\n\t],\n\t\"./ar-kw.js\": [\n\t\t96135,\n\t\t381,\n\t\t6135\n\t],\n\t\"./ar-ly.js\": [\n\t\t56440,\n\t\t381,\n\t\t6440\n\t],\n\t\"./ar-ma.js\": [\n\t\t47702,\n\t\t381,\n\t\t7702\n\t],\n\t\"./ar-sa.js\": [\n\t\t16040,\n\t\t381,\n\t\t6040\n\t],\n\t\"./ar-tn.js\": [\n\t\t37100,\n\t\t381,\n\t\t7100\n\t],\n\t\"./ar.js\": [\n\t\t30867,\n\t\t381,\n\t\t867\n\t],\n\t\"./az.js\": [\n\t\t31083,\n\t\t381,\n\t\t1083\n\t],\n\t\"./be.js\": [\n\t\t9808,\n\t\t381,\n\t\t9808\n\t],\n\t\"./bg.js\": [\n\t\t68338,\n\t\t381,\n\t\t8338\n\t],\n\t\"./bm.js\": [\n\t\t67438,\n\t\t381,\n\t\t7438\n\t],\n\t\"./bn-bd.js\": [\n\t\t76225,\n\t\t381,\n\t\t6225\n\t],\n\t\"./bn.js\": [\n\t\t8905,\n\t\t381,\n\t\t8905\n\t],\n\t\"./bo.js\": [\n\t\t11560,\n\t\t381,\n\t\t1560\n\t],\n\t\"./br.js\": [\n\t\t1278,\n\t\t381,\n\t\t1278\n\t],\n\t\"./bs.js\": [\n\t\t80622,\n\t\t381,\n\t\t622\n\t],\n\t\"./ca.js\": [\n\t\t2468,\n\t\t381,\n\t\t2468\n\t],\n\t\"./cs.js\": [\n\t\t5822,\n\t\t381,\n\t\t5822\n\t],\n\t\"./cv.js\": [\n\t\t50877,\n\t\t381,\n\t\t877\n\t],\n\t\"./cy.js\": [\n\t\t47373,\n\t\t381,\n\t\t7373\n\t],\n\t\"./da.js\": [\n\t\t24780,\n\t\t381,\n\t\t4780\n\t],\n\t\"./de-at.js\": [\n\t\t60217,\n\t\t381,\n\t\t217\n\t],\n\t\"./de-ch.js\": [\n\t\t60894,\n\t\t381,\n\t\t894\n\t],\n\t\"./de.js\": [\n\t\t59740,\n\t\t381,\n\t\t9740\n\t],\n\t\"./dv.js\": [\n\t\t5300,\n\t\t381,\n\t\t5300\n\t],\n\t\"./el.js\": [\n\t\t50837,\n\t\t381,\n\t\t837\n\t],\n\t\"./en-au.js\": [\n\t\t78348,\n\t\t381,\n\t\t8348\n\t],\n\t\"./en-ca.js\": [\n\t\t77925,\n\t\t381,\n\t\t7925\n\t],\n\t\"./en-gb.js\": [\n\t\t22243,\n\t\t381,\n\t\t2243\n\t],\n\t\"./en-ie.js\": [\n\t\t46436,\n\t\t381,\n\t\t6436\n\t],\n\t\"./en-il.js\": [\n\t\t47207,\n\t\t381,\n\t\t7207\n\t],\n\t\"./en-in.js\": [\n\t\t44175,\n\t\t381,\n\t\t4175\n\t],\n\t\"./en-nz.js\": [\n\t\t76319,\n\t\t381,\n\t\t6319\n\t],\n\t\"./en-sg.js\": [\n\t\t31662,\n\t\t381,\n\t\t1662\n\t],\n\t\"./eo.js\": [\n\t\t92915,\n\t\t381,\n\t\t2915\n\t],\n\t\"./es-do.js\": [\n\t\t55251,\n\t\t381,\n\t\t5251\n\t],\n\t\"./es-mx.js\": [\n\t\t96112,\n\t\t381,\n\t\t6112\n\t],\n\t\"./es-us.js\": [\n\t\t71146,\n\t\t381,\n\t\t1146\n\t],\n\t\"./es.js\": [\n\t\t55655,\n\t\t381,\n\t\t5655\n\t],\n\t\"./et.js\": [\n\t\t5603,\n\t\t381,\n\t\t5603\n\t],\n\t\"./eu.js\": [\n\t\t77763,\n\t\t381,\n\t\t7763\n\t],\n\t\"./fa.js\": [\n\t\t76959,\n\t\t381,\n\t\t6959\n\t],\n\t\"./fi.js\": [\n\t\t11897,\n\t\t381,\n\t\t1897\n\t],\n\t\"./fil.js\": [\n\t\t42549,\n\t\t381,\n\t\t2549\n\t],\n\t\"./fo.js\": [\n\t\t94694,\n\t\t381,\n\t\t4694\n\t],\n\t\"./fr-ca.js\": [\n\t\t63049,\n\t\t381,\n\t\t3049\n\t],\n\t\"./fr-ch.js\": [\n\t\t52330,\n\t\t381,\n\t\t2330\n\t],\n\t\"./fr.js\": [\n\t\t94470,\n\t\t381,\n\t\t4470\n\t],\n\t\"./fy.js\": [\n\t\t5044,\n\t\t381,\n\t\t5044\n\t],\n\t\"./ga.js\": [\n\t\t29295,\n\t\t381,\n\t\t9295\n\t],\n\t\"./gd.js\": [\n\t\t2101,\n\t\t381,\n\t\t2101\n\t],\n\t\"./gl.js\": [\n\t\t38794,\n\t\t381,\n\t\t8794\n\t],\n\t\"./gom-deva.js\": [\n\t\t27884,\n\t\t381,\n\t\t7884\n\t],\n\t\"./gom-latn.js\": [\n\t\t23168,\n\t\t381,\n\t\t3168\n\t],\n\t\"./gu.js\": [\n\t\t95349,\n\t\t381,\n\t\t5349\n\t],\n\t\"./he.js\": [\n\t\t24206,\n\t\t381,\n\t\t4206\n\t],\n\t\"./hi.js\": [\n\t\t30094,\n\t\t381,\n\t\t94\n\t],\n\t\"./hr.js\": [\n\t\t30316,\n\t\t381,\n\t\t316\n\t],\n\t\"./hu.js\": [\n\t\t92844,\n\t\t381,\n\t\t2844\n\t],\n\t\"./hy-am.js\": [\n\t\t11423,\n\t\t381,\n\t\t1423\n\t],\n\t\"./id.js\": [\n\t\t29218,\n\t\t381,\n\t\t9218\n\t],\n\t\"./is.js\": [\n\t\t90135,\n\t\t381,\n\t\t135\n\t],\n\t\"./it-ch.js\": [\n\t\t10150,\n\t\t381,\n\t\t150\n\t],\n\t\"./it.js\": [\n\t\t90626,\n\t\t381,\n\t\t626\n\t],\n\t\"./ja.js\": [\n\t\t39183,\n\t\t381,\n\t\t9183\n\t],\n\t\"./jv.js\": [\n\t\t24286,\n\t\t381,\n\t\t4286\n\t],\n\t\"./ka.js\": [\n\t\t12105,\n\t\t381,\n\t\t2105\n\t],\n\t\"./kk.js\": [\n\t\t47772,\n\t\t381,\n\t\t7772\n\t],\n\t\"./km.js\": [\n\t\t18758,\n\t\t381,\n\t\t8758\n\t],\n\t\"./kn.js\": [\n\t\t79282,\n\t\t381,\n\t\t9282\n\t],\n\t\"./ko.js\": [\n\t\t33730,\n\t\t381,\n\t\t3730\n\t],\n\t\"./ku.js\": [\n\t\t1408,\n\t\t381,\n\t\t1408\n\t],\n\t\"./ky.js\": [\n\t\t33291,\n\t\t381,\n\t\t3291\n\t],\n\t\"./lb.js\": [\n\t\t36841,\n\t\t381,\n\t\t6841\n\t],\n\t\"./lo.js\": [\n\t\t55466,\n\t\t381,\n\t\t5466\n\t],\n\t\"./lt.js\": [\n\t\t57010,\n\t\t381,\n\t\t7010\n\t],\n\t\"./lv.js\": [\n\t\t37595,\n\t\t381,\n\t\t7595\n\t],\n\t\"./me.js\": [\n\t\t39861,\n\t\t381,\n\t\t9861\n\t],\n\t\"./mi.js\": [\n\t\t35493,\n\t\t381,\n\t\t5493\n\t],\n\t\"./mk.js\": [\n\t\t95966,\n\t\t381,\n\t\t5966\n\t],\n\t\"./ml.js\": [\n\t\t87341,\n\t\t381,\n\t\t7341\n\t],\n\t\"./mn.js\": [\n\t\t5115,\n\t\t381,\n\t\t5115\n\t],\n\t\"./mr.js\": [\n\t\t10370,\n\t\t381,\n\t\t370\n\t],\n\t\"./ms-my.js\": [\n\t\t41237,\n\t\t381,\n\t\t1237\n\t],\n\t\"./ms.js\": [\n\t\t9847,\n\t\t381,\n\t\t9847\n\t],\n\t\"./mt.js\": [\n\t\t72126,\n\t\t381,\n\t\t2126\n\t],\n\t\"./my.js\": [\n\t\t56165,\n\t\t381,\n\t\t6165\n\t],\n\t\"./nb.js\": [\n\t\t64924,\n\t\t381,\n\t\t4924\n\t],\n\t\"./ne.js\": [\n\t\t16744,\n\t\t381,\n\t\t6744\n\t],\n\t\"./nl-be.js\": [\n\t\t59814,\n\t\t381,\n\t\t9814\n\t],\n\t\"./nl.js\": [\n\t\t93901,\n\t\t381,\n\t\t3901\n\t],\n\t\"./nn.js\": [\n\t\t83877,\n\t\t381,\n\t\t3877\n\t],\n\t\"./oc-lnc.js\": [\n\t\t92135,\n\t\t381,\n\t\t2135\n\t],\n\t\"./pa-in.js\": [\n\t\t15858,\n\t\t381,\n\t\t5858\n\t],\n\t\"./pl.js\": [\n\t\t64495,\n\t\t381,\n\t\t4495\n\t],\n\t\"./pt-br.js\": [\n\t\t57971,\n\t\t381,\n\t\t7971\n\t],\n\t\"./pt.js\": [\n\t\t89520,\n\t\t381,\n\t\t9520\n\t],\n\t\"./ro.js\": [\n\t\t96459,\n\t\t381,\n\t\t6459\n\t],\n\t\"./ru.js\": [\n\t\t21793,\n\t\t381,\n\t\t1793\n\t],\n\t\"./sd.js\": [\n\t\t40950,\n\t\t381,\n\t\t950\n\t],\n\t\"./se.js\": [\n\t\t10490,\n\t\t381,\n\t\t490\n\t],\n\t\"./si.js\": [\n\t\t90124,\n\t\t381,\n\t\t124\n\t],\n\t\"./sk.js\": [\n\t\t64249,\n\t\t381,\n\t\t4249\n\t],\n\t\"./sl.js\": [\n\t\t14985,\n\t\t381,\n\t\t4985\n\t],\n\t\"./sq.js\": [\n\t\t51104,\n\t\t381,\n\t\t1104\n\t],\n\t\"./sr-cyrl.js\": [\n\t\t79915,\n\t\t381,\n\t\t9915\n\t],\n\t\"./sr.js\": [\n\t\t49131,\n\t\t381,\n\t\t9131\n\t],\n\t\"./ss.js\": [\n\t\t85893,\n\t\t381,\n\t\t5893\n\t],\n\t\"./sv.js\": [\n\t\t98760,\n\t\t381,\n\t\t8760\n\t],\n\t\"./sw.js\": [\n\t\t91172,\n\t\t381,\n\t\t1172\n\t],\n\t\"./ta.js\": [\n\t\t27333,\n\t\t381,\n\t\t7333\n\t],\n\t\"./te.js\": [\n\t\t23110,\n\t\t381,\n\t\t3110\n\t],\n\t\"./tet.js\": [\n\t\t52095,\n\t\t381,\n\t\t2095\n\t],\n\t\"./tg.js\": [\n\t\t27321,\n\t\t381,\n\t\t7321\n\t],\n\t\"./th.js\": [\n\t\t9041,\n\t\t381,\n\t\t9041\n\t],\n\t\"./tk.js\": [\n\t\t19005,\n\t\t381,\n\t\t9005\n\t],\n\t\"./tl-ph.js\": [\n\t\t75768,\n\t\t381,\n\t\t5768\n\t],\n\t\"./tlh.js\": [\n\t\t89444,\n\t\t381,\n\t\t9444\n\t],\n\t\"./tr.js\": [\n\t\t72397,\n\t\t381,\n\t\t2397\n\t],\n\t\"./tzl.js\": [\n\t\t28254,\n\t\t381,\n\t\t8254\n\t],\n\t\"./tzm-latn.js\": [\n\t\t30699,\n\t\t381,\n\t\t699\n\t],\n\t\"./tzm.js\": [\n\t\t51106,\n\t\t381,\n\t\t1106\n\t],\n\t\"./ug-cn.js\": [\n\t\t9288,\n\t\t381,\n\t\t9288\n\t],\n\t\"./uk.js\": [\n\t\t67691,\n\t\t381,\n\t\t7691\n\t],\n\t\"./ur.js\": [\n\t\t13795,\n\t\t381,\n\t\t3795\n\t],\n\t\"./uz-latn.js\": [\n\t\t60588,\n\t\t381,\n\t\t588\n\t],\n\t\"./uz.js\": [\n\t\t6791,\n\t\t381,\n\t\t6791\n\t],\n\t\"./vi.js\": [\n\t\t65666,\n\t\t381,\n\t\t5666\n\t],\n\t\"./x-pseudo.js\": [\n\t\t14378,\n\t\t381,\n\t\t4378\n\t],\n\t\"./yo.js\": [\n\t\t75805,\n\t\t381,\n\t\t5805\n\t],\n\t\"./zh-cn.js\": [\n\t\t83839,\n\t\t381,\n\t\t3839\n\t],\n\t\"./zh-hk.js\": [\n\t\t55726,\n\t\t381,\n\t\t5726\n\t],\n\t\"./zh-mo.js\": [\n\t\t99807,\n\t\t381,\n\t\t9807\n\t],\n\t\"./zh-tw.js\": [\n\t\t74152,\n\t\t381,\n\t\t4152\n\t]\n};\nfunction webpackAsyncContext(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\treturn Promise.resolve().then(function() {\n\t\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\t\te.code = 'MODULE_NOT_FOUND';\n\t\t\tthrow e;\n\t\t});\n\t}\n\n\tvar ids = map[req], id = ids[0];\n\treturn Promise.all(ids.slice(1).map(__webpack_require__.e)).then(function() {\n\t\treturn __webpack_require__.t(id, 7 | 16);\n\t});\n}\nwebpackAsyncContext.keys = function() { return Object.keys(map); };\nwebpackAsyncContext.id = 77961;\nmodule.exports = webpackAsyncContext;"],"names":["map","webpackAsyncContext","req","__webpack_require__","o","Promise","resolve","then","e","Error","code","ids","id","t","keys","Object","module","exports","window","hadGlobal","oldGlobal","Modernizr","scriptGlobalObject","document","undefined","tests","ModernizrProto","_version","_config","_q","on","test","cb","self","this","setTimeout","addTest","name","fn","options","push","addAsyncTest","prototype","classes","is","obj","type","hasOwnProp","_hasOwnProperty","docElement","documentElement","isSVG","nodeName","toLowerCase","setClasses","className","classPrefix","baseVal","enableJSClass","reJS","RegExp","replace","enableClasses","length","join","feature","key","featureNameSplit","split","last","Boolean","_trigger","hasOwnProperty","call","object","property","constructor","_l","res","cbs","i","omPrefixes","cssomPrefixes","usePrefixes","_cssomPrefixes","atRule","prop","rule","prefixes","cssrule","CSSRule","toUpperCase","prefix","domPrefixes","createElement","arguments","createElementNS","apply","_domPrefixes","needsFallback","hasEvent","eventName","element","isSupported","setAttribute","removeAttribute","supportsHtml5Styles","supportsUnknownElements","html5","reSkip","saveClones","expando","expanID","expandoData","addStyleSheet","ownerDocument","cssText","p","parent","getElementsByTagName","innerHTML","insertBefore","lastChild","firstChild","getElements","elements","getExpandoData","data","node","cache","cloneNode","createElem","canHaveChildren","tagUrn","frag","appendChild","shivDocument","shivCSS","hasCSS","createFrag","createDocumentFragment","shivMethods","Function","a","childNodes","clone","elems","l","addElements","newElements","docEl","reMedia","shivNamespace","supportsShivableSheets","namespaces","parentWindow","applyElement","removeNode","attachEvent","createWrapper","nodes","attributes","index","wrapper","specified","nodeValue","style","shivPrint","shivedSheet","wrappers","ownerWindow","printShived","removeSheet","clearTimeout","_removeSheetTimer","add","imports","sheet","collection","styleSheets","sheets","Array","pop","disabled","media","er","pair","parts","reElements","shivCssText","reverse","result","addWrappers","removeWrappers","err","warn","injectElementWithStyles","callback","testnames","ret","docOverflow","mod","div","body","fake","getBody","parseInt","styleSheet","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","computedStyle","elem","pseudo","getComputedStyle","console","getPropertyValue","error","currentStyle","method","slice","load","yepnope","matchMedia","mq","msMatchMedia","mql","matches","bool","contains","str","substr","indexOf","modElem","mStyle","domToCSS","m1","cssToDOM","m2","testProps","props","prefixed","value","skipValueTest","CSS","supports","conditionText","nativeTestProps","afterInit","propsLength","before","shift","cleanElems","fnBind","that","testPropsAll","ucProp","charAt","item","testDOMProps","unshift","testAllProps","_prefixes","prefixedCSS","prefixedProp","testProp","useValue","testStyles","externalHost","Blob","aliases","getContext","canvas","ctx","globalCompositeOperation","toDataURL","rect","isPointInPath","fillText","contentEditable","cookie","XMLHttpRequest","eStyle","val","backgroundPosition","documentMode","el","offsetLeft","elemStyle","fontSize","child","escape","ua","webos","wppre8","newSyntax","oldSyntax","roundedEquals","b","navigator","userAgent","match","parseFloat","$1","getElementById","cssRules","angle","str1","css","len","backgroundImage","backgroundColor","input","required","clientWidth","offsetWidth","correctWidths","opacity","pointerEvents","position","cssanimations","styles","csstransitions","flowFromProperty","flowIntoProperty","flowedRect","delta","iframeContainer","container","content","region","flowName","innerText","plainRect","getBoundingClientRect","left","height","scrollWidth","subpixel","doc","querySelectorAll","outerAnchor","innerAnchor","width","compStyle","scroller","fullSizeElem","scrollbarWidth","one_vw","one_vh","clientHeight","expectedWidth","Math","max","compWidth","min","innerWidth","prefixedProperty","wrapFlowProperty","exclusion","leftOffset","getAttribute","n","dataset","aB","MutationObserver","WebKitMutationObserver","supportsPassiveOption","opts","defineProperty","get","noop","addEventListener","removeEventListener","supportsOnInput","oninput","testEvent","createEvent","handler","preventDefault","stopPropagation","initKeyEvent","charCodeAt","focus","dispatchEvent","img","Image","onerror","onload","src","domPrefixesAll","concat","_domPrefixesAll","attr","form","Date","getTime","createAttribute","setAttributeNode","invalidFired","formvalidationapi","opera","operamini","formvalidationmessage","validationMessage","click","inputElem","inputElemType","defaultView","WebkitAppearance","checkValidity","location","protocol","history","JSON","Notification","requestPermission","permission","postMessage","toString","timeout","advertiseSupport","localStorage","setItem","removeItem","sessionStorage","TouchEvent","DocumentTouch","query","missingGlyph","star","testGlyphs","elm","url","datauri","datauriBig","base64str","testOver32kb","URL","href","addBehavior","canPlayType","currentTry","testAutoplay","arg","currentTime","video","ogg","h264","featureNames","aliasIdx","nameIdx","featureIdx","testRunner","getOptions","$el","patternName","$","elOptions","tmpOptions","log","logging","initBasePattern","trigger","jquery","plog","pattern","Registry","parser","mockupParser","Base","defaults","init","emit","eventCallback","one","args","extend","patternProps","jquery_plugin","Surrogate","__super__","autoregister","DATA_PREFIX","DATA_STYLE_DISPLAY","get_css_value","as_pixels","as_float","round","dom","toNodeArray","NodeList","querySelectorAllAndMe","selector","all","wrap","hide","display","show","find_parents","closest","find_scoped","get_parents","parents","HTMLElement","acquire_attribute","attribute","include_empty","include_all","_el","parentElement","is_visible","create_from_string","string","createRange","createContextualFragment","trim","find_scroll_container","direction","fallback","overflow_y","includes","overflow_x","get_data","default_value","set_data","template","template_string","template_variables","add_event_listener","events","remove_event_listener","event_listener_map","el_events","entries","entry","event_type","capture","await_event","event_name","once","await_pattern_init","blur_event","Event","bubbles","cancelable","click_event","change_event","focus_event","input_event","mousedown_event","mouseup_event","scroll_event","submit_event","translate","methods","settings","time","initialTime","exceptionAreas","each","$this","lastEvent","trueTime","untouched","inExceptionArea","mouseMoved","find","live","enteredException","leftException","addClass","event","destroy","off","remove","removeData","hasClass","removeClass","startTimer","floor","now","diff","scrollable","scrollHeight","parent_id","absoluteParent","elemTop","top","elemBottom","viewTop","scrollTop","viewBottom","docElem","origin","nodeType","offsettop","offsetleft","thiswidth","pos","safeOffset","setleft","settop","appendTo","$ancestor","$child","childMarginEdgeLeft","childMarginEdgeTop","ancestorPaddingEdgeLeft","ancestorPaddingEdgeTop","addBack","filter","speed","easing","animate","m","text","root","writer","bind","oThis","TypeError","aArgs","fToBind","fNOP","fBound","Level","DEBUG","INFO","WARN","ERROR","FATAL","ConsoleWriter","Logger","_loggers","_parent","_enabled","_level","setWriter","w","output","log_name","level","messages","info","getLogger","path","route","_getFlag","flag","context","setEnabled","state","isEnabled","setLevel","getLevel","debug","fatal","logconfig","exec","search","api","getWriter","ArgumentParser","order","parameters","enum_values","enum_conflicts","groups","possible_groups","group_pattern","json_param_pattern","named_param_pattern","token_pattern","__","p1","alias","original","spec","group","field","first_spec","first_name","dest","addArgument","choices","multiple","_camelCase","addGroupToSpec","isArray","_typeof","choice","parse","num","isNaN","part","v","_coerce","tokens","quoted","simple","argstring","values","it","_set","subopt","_parseShorthandNotation","parameter","_split","sense","positional","_parseExtendedNotation","sep","extended","group_options","target","inherit","stack","_defaults","final_length","provider","frame","_parse","results","utils","current_value","_cleanupOptions","add_argument","last_btn","submitable_buttons","canditates","activeElement","candidate","submitter","querySelector","disable_re","dont_catch_re","dont_catch","__patternslib_registry","PATTERN_REGISTRY","__patternslib_registry_initialized","registry","patterns","ready","sort","scan","clear","transformPattern","transform","initPattern","orderPatterns","splice","selectors","classList","register","plugin_name","Storage","backend","ValueStorage","store","_key","_allKeys","prefix_length","getItem","set","stringify","supported","local","session","updateOptions","$clone","findInclusive","$item","forEach","thisArg","T","k","O","kValue","singleBoundJQueryPlugin","pat","pluralBoundJQueryPlugin","isObject","jqueryPlugin","escapeRegExp","source","findLabel","$label","label","tagName","elementInViewport","vWidth","vHeight","innerHeight","right","bottom","removeWildcardClass","targets","ensureArray","matcher","class_list","ok","hideOrShow","visible","pattern_name","transitions","none","fade","slide","duration","transition","effect","on_complete","complete","addURLQueryParameter","fullURL","param","hash","newURL","removeDuplicateObjects","objs","comparator","reduce","list","next_obj","is_duplicate","mergeStack","frame_length","x","isElementInViewport","partial","offset","rec","rec_values","every","hasValue","checked","selectedIndex","parseTime","amount","findRelatives","$relatives","$form","get_bounds","bounds","y","checkInputSupport","invalid_value","support","checkCSSFeature","tag","animation_frame","requestAnimationFrame","ms","debounce","func","timer","isIE","jqToNode","force_array","isPrototypeOf","localized_isodate","date","day","getDate","padStart","month","getMonth","year","getFullYear","escape_html","html","unescape_html","escaped_html","is_iso_date_time","optional_time","re_date_time","is_iso_date","date_diff","date_1","date_2","utc_1","UTC","utc_2","getCSSValue","Parser","xhrCount","_","onTriggerEvents","onClickSubmit","request","_request","cfg","seqNumber","inc","temp","clickedData","serialize","headers","browserCache","accept","Accept","formdata","FormData","append","ajax_deferred","done","status","jqxhr","fail","dialog_panel","close","addAlias","format","after","befores","b_date","a_date","offsetDays","setDate","toISOString","substring","dispatch_change_event","behavior","display_el","insertAdjacentElement","outputFormat","PatDisplayTime","default","display_time_config","locale","display_el_pat","textContent","add_clear_button","__patternslib_import_styles","Pikaday","config","firstDay","showWeekNumber","weekNumbers","onSelect","onClose","minDate","maxDate","i18n","fetch","response","json","pikaday","el_append_to","clear_button","firedBy","Moment","lang","datetime","out","strict","fromNow","rtf","Intl","RelativeTimeFormat","numeric","toDate","calendar","lastWeek","lastDay","sameDay","nextDay","nextWeek","sameElse","noSuffix","inject","cfgs","extractConfig","some","nextHref","pushMarker","onTrigger","currentTarget","idleTrigger","_initIdleTrigger","delay","processDelay","ajax","onFormActionSubmit","uid","random","uid_","_initAutoloadVisible","params","serializeArray","execute","$button","formaction","first","$cfg_node","submitSubform","$sub","$context","urlparts","defaultSelector","elementIsDirty","askForConfirmation","message","should_confirm","_confirm","confirm","$target","confirmMessage","ensureTarget","createTarget","$injected","verifySingleConfig","extractModifiers","listenForFormReset","verifyConfig","source_match","target_match","sourceMod","targetMod","targetPosition","loadingClass","action","stopBubblingFromRemovedElement","ev","sel","isPropagationStopped","_performInjection","$source","title","$src","contents","idx","outerHTML","safeClone","_inject","_update_history","_afterInjection","glue","pushState","el_","scroll","scroll_container","scroll_target","scroll_container_ref","abs","scrollLeft","scrollTo","_onInjectSuccess","responseText","hooks","hook","callTypeHandler","dataType","sources$","idx1","perform_inject","idx2","_onInjectError","explanation","timestamp","URLSearchParams","error_page_url","error_page_fragment","error_page","error_page_response","executingClass","error_zone","msg_attr","statusText","removeAttr","do_close_panel","stopImmediatePropagation","contentbefore","contentafter","elementbefore","elementafter","replaceWith","empty","_sourcesFromHtml","sources","$html","_parseRawHtml","_rebaseAttrs","A","FORM","IMG","OBJECT","SOURCE","VIDEO","_rebaseOptions","_rebaseURL","base","lastIndexOf","_rebaseHTML","$page","wrapAll","$el_","attrName","pattern_parser","changed","opt","clean_html","children","timeout_id","observer","IntersectionObserver","isIntersecting","disconnect","threshold","margin","observe","onTimeout","unsub","onInteraction","registerTypeHandler","handlers","injected","skipPatInjectHandler","executedClass","CustomEvent","detail","originalEvent","reload","replaceState","is_markdown_resource","Markdown","render","replaceAll","Showdown","extensions","prettify","pre","$rendering","converter","Converter","tables","makeHtml","renderForInjection","header","extractSection","rendered","ImagesLoaded","smoothScroll","onClick","onPatternsUpdate","markBasedOnFragment","clearIfHidden","markIfVisible","fragment","active_target","$active_target","_get_selector_target","start","promise","tippy","active_class","inactive_class","Tippy","tippy_options","parseOptionsForTippy","defaultProps","animation","arrow","hideOnClick","closing","ignoreAttributes","interactive","onHide","_onHide","onShow","_onShow","setDefaultProps","markInactive","placement","pos0","r","popperOptions","modifiers","arrowPadding","padding","parsers","flip_options","enabled","policy","fallbacks","fallbackPlacements","allowHTML","_initialize_content","popper","tippy_classes","class","close_button","setProps","_get_content","setContent","get_url_parts","_ajaxDataTypeHandlers","ajaxDataType","popperInstance","forceUpdate","get_content","tmp","markdown","pat_markdown","jQuery","logger","push_kit","exchange","topicfilter","user_login","user_pass","StompJS","client","Client","brokerURL","connectHeaders","login","passcode","reconnectDelay","heartbeatIncoming","heartbeatOutgoing","onConnect","subscribe","on_push_marker","onStompError","activate","force_method","_setup","scale","scaler","available_space","scaled_height","scaled_width","size","outerWidth","outerHeight","namespace","setup","setupInputHandlers","registerHandlersForElement","isNumber","isText","propertyName","input_change_events","registerListeners","registerTriggers","onInputChange","registerSubformListeners","refreshListeners","submit","not","trigger_event","tokenSeparators","openOnEnter","maximumSelectionSize","maxSelectionSize","minimumInputLength","allowClear","hasAttribute","placeholder","selectionClasses","formatSelection","SyntaxError","create_input_config","$sel2","select2","initiate_empty_check","words","createSearchChoice","term","allowNewWords","localeCompare","wordsJson","tags","prefill","initSelection","prefillJson","d","_data","quietMillis","page","q","page_limit","scheduled_task","set_focus","$content","$ctrl","prependTo","shifted","shifting","difference","shifter","toggle","toggleClass","maybeshift","recalculate","toArray","acc","target_element","_init","scroll_container_y","scroll_container_x","intersection_observer_config","rootMargin","_intersection_observer_callback","intersectionRatio","bump","rootBounds","boundingClientRect","unbump","_init_div1","_init_inject1","detach","$children","closeText","panelHeaderContent","_init_handlers","resize","setPosition","_onKeyUp","_onPossibleOutsideClick","has","which","getTallestChild","$tallest_child","panel_content_elem","header_elem","modal_height","classMap","agendaWeek","agendaDay","viewMap","week","basicWeek","basicDay","dayNames","active_categories","Calendar","fcDayGrid","fcInteraction","fcList","fcLuxon","fcTimeGrid","calendar_controls","calendarControls","el_jump_next","el_jump_prev","el_jump_today","el_view_month","el_view_week","el_view_day","el_view_list_year","el_view_list_month","el_view_list_week","el_view_list_day","el_timezone","el_title","storage_prefix","pathname","storage","query_string","headerToolbar","initialDate","initial","initialView","view","editable","plugins","eventColor","timezone","timeZone","timeFormat","eventTimeFormat","hour12","meridiem","hour","eventSources","create_event_source","_restoreCategoryControls","_registerCategoryControls","reset_active_categories","eventDidMount","init_event","cal_el","addUrl","dateClick","addNewEvent","mod_el","_viewChanged","_registerCalendarControls","setActiveClasses","success","failure","_fetch_events","event_mapper","UID","end","allDay","whole_day","color","borderColor","classNames","description","open_end","recurrence","attendees","contact_name","contact_phone","contact_email","event_url","update_event","setDates","setAllDay","setProp","setExtendedProp","startStr","endStr","mode","results_","items","batching","next","filter_event","do_scan","switch_sel","switch_add","switch_rm","ctrls","get_category_controls","categoryControls","inp","Set","getEvents","ctrl","hidden","prev","today","changeView","setOption","cdate","currentData","currentDate","getYear","currentStart","addEvent","Modal","form_data","autoplay","auto","play","autoplaySpeed","adaptiveHeight","arrows","slidesToShow","slides","slidesToScroll","dots","infinite","appendDots","$carousel","slick","$panel_links","$links","control","currentPage","onPanelLinkClick","onSlideComplete","_loadPanelImages","slider","$img","$items","eq","gotoPage","onInitialized","startPanel","pages","onSlideInit","targetPage","$targetPage","all_selects","all_deselects","all_checkboxes","all_radios","select","select_all","deselect","deselect_all","_handler_change","change_buttons","change_checked","find_siblings","find_checkboxes","ref_el","chkbxs","btn","box","labels","fieldset","bind_trigger","clones","cloneElement","num_clones","bind_remove","alert","incrementValues","clone_triggers","triggers","triggerElement","behaviour","confirmation","debounce_scroll_timer","closed","open","$trigger","$panel","insertAfter","loadContent","_loadContent","_onClick","_onKeyPress","closeTrigger","openTrigger","debounce_scroll","_scroll","keyCode","components","new_state","_transit","scroll_selector","pat_scroll","from_cls","to_cls","spectrum","preferredFormat","el_date","el_time","DatePicker","date_value","time_value","el_wrapper","html_btn_now","html_btn_clear","update","isotime","date_options","isodate","toTimeString","DependsHandler","dependent","$modal","condition","evaluate","updateModal","enable","disable","getAllInputs","dependents","onReset","onChange","$depdendent","equaliser","$container","_onEvent","_update","childList","subtree","characterData","max_height","new_css","$folders","prepend","$folder","patExpandable","onNewContent","_doFocus","$root","ix","onFocus","_updateHasValue","inputs","onBlur","setReset","saveState","setModified","setError","setSaved","msg","modal","timestr","getHours","getMinutes","getSeconds","skip","on_click","Screenfull","exit","fullscreen_handler","fs_el_sel","fs_el","closeButton","setup_exit_button","exit_el","isFullscreen","PhotoSwipe","PhotoSwipeUI","orig_body_overflow","images","get_template","initialize_trigger","raw_template","image_wrapper_els","itemSelector","initialize_gallery","h","trigger_el","pswp_el","scaleMode","scaleMethod","loop","slideshowDelay","hideAnimationDuration","effectDuration","showAnimationDuration","pinchToClose","closeOnScroll","gallery","gallery_reinit_sizes_debouncer","updateSize","listen","_e","img_el","needsUpdate","inputNames","preview","previewWidth","formId","inputPrefix","_setupInput","ic","_parseOpt","initialSel","initialCoords","aspectRatio","minSize","maxSize","c","Jcrop","onRelease","setSelect","tellSelect","updatePreview","updateInputs","rx","ry","getBounds","marginLeft","marginTop","x1","y1","x2","y2","legend","_convertToIframes","$object","$iframe","Masonry","initMasonry","imgLoad","msnry","quicklayout","layout","attributeOldValue","attributeFilter","containerStyle","columnWidth","getTypeCastedValue","fitWidth","gutter","horizontalOrder","initLayout","originLeft","originTop","percentPosition","stamp","transitionDuration","patMasonry","Number","navItemSelector","$it","mouseOverHandler","mouseOutHandler","openMenu","siblings","closeMenu","init_listeners","init_markings","current","currentClass","clear_items","mark_current","mark_items_url","get_parent","stop_el","matching_parent","current_el","itemWrapper","mark_in_path","start_el","path_el","inPathClass","current_url","base_url","current_url_prepared","prepare_url","portal_url","portalUrl","nav_item","nav_url","count","_init_inject","_init_notification","closetext","onMouseEnter","onMouseLeave","controls","healing","init_remove_timer","$temp","panel","stop","step","slideUp","rfp_key","desktop_notification__request_permission","pushId","desktop_notification","insertAdjacentHTML","notification","scroll_listener","last_known_scroll_position","timeout_id__scroll_stop","overflowY","ticking","set_scroll_classes","clear_scrolling_classes","timeoutStop","scroll_pos","get_scroll_y","to_add","scrollY","pageYOffset","KEY_RESET","form_reset","change_select","UrlArgumentParser","_cache","_reset","space_pattern","keyvalue_pattern","_decodeQS","bit","decodeURIComponent","qs","url_parser","real_cleanData","triggerHandler","requested_ids","_collapse_ids","_remove_slides","presentation","Presentation","_onSlideDisplay","_onSlideHide","_hook","paused","pause","$shows","has_bad_id","recordPositions","addHandles","initScrolling","onPatternUpdate","onDragStart","onDragEnd","$sortables","$sortables_without_handles","$handles","scrollup","scrolldn","zIndex","newpos","$dragged","dragClass","change","submitChangedAmount","drop","$amount_input","old_position","new_position","dataTransfer","setData","effectAllowed","setDragImage","clientY","$dropTarget","midlineY","_setupStack","$invisible","selected","_currentFragment","$sheets","$visible","_updateAnchors","_base_URL","href_parts","_switch","$anchors","sheet_id","$sheet","keyboard_handler","submitClicked","scopedSubmit","$exclude","names","$subform","previousValue","_validateOptions","_go","option","_storage","correct","logged_error","Prettify","prettyPrint","allowed_update_patterns","debounced_resize","adjust_tabs","previous_parent_width","resize_observer","ResizeObserver","contentRect","_flatten_tabs","dimensions","_get_dimensions","_adjust_tabs","extra_wrapper","border_left","padding_left","border_right","padding_right","max_width","max_x","children_no_extra","tabs_fit","it_x","it_w","last_x","extra_tabs","ClassToggler","AttributeToggler","value_storage","victims","toggler","last_state","victim","click_debouncer","_makeToggler","updated","next_state","j","KEY_ERROR_EL","KEY_ERROR_MSG","disabled_elements","disableSelector","cnt","debouncer","check_input","_input","set_validity","validity_state","validity","badInput","customError","patternMismatch","rangeOverflow","rangeUnderflow","stepMismatch","tooLong","tooShort","typeMismatch","valid","valueMissing","input_options","equality","not_after","not_after_el","not_before","not_before_el","remove_error","number","email","set_error_message","setCustomValidity","all_of_group","error_node","validation_message","error_template","errorTemplate","zoom","$block","onZoom","change_color"],"sourceRoot":""}