https://okendo.io/wp-content/themes/okendo/dist/index-legacy.js?ver=1790139781

715          measurements.forEach((measurement) => {
716            size[measurement] = 0;
717          });
718          return size;
719        }
720        function getSize2(elem) {
721          if (typeof elem == "string") elem = document.querySelector(elem);
722          let isElement = elem && typeof elem == "object" && elem.nodeType;
723          if (!isElement) return;
724          let style = getComputedStyle(elem);
725          if (style.display == "none") return getZeroSize();
726          let size = {};
727          size.width = elem.offsetWidth;
728          size.height = elem.offsetHeight;
729          let isBorderBox = size.isBorderBox = style.boxSizing == "border-box";
730          measurements.forEach((measurement) => {
731            let value = style[measurement];
732            let num = parseFloat(value);
733            size[measurement] = !isNaN(num) ? num : 0;
734          });
735          let paddingWidth = size.paddingLeft + size.paddingRight;
736          let paddingHeight = size.paddingTop + size.paddingBottom;
737          let marginWidth = size.marginLeft + size.marginRight;
738          let marginHeight = size.marginTop + size.marginBottom;
739          let borderWidth = size.borderLeftWidth + size.borderRightWidth;
740          let borderHeight = size.borderTopWidth + size.borderBottomWidth;
741          let styleWidth = getStyleSize(style.width);
742          if (styleWidth !== false) {
743            size.width = styleWidth + // add padding and border unless it's already including it
744            (isBorderBox ? 0 : paddingWidth + borderWidth);
745          }
746          let styleHeight = getStyleSize(style.height);
747          if (styleHeight !== false) {
748            size.height = styleHeight + // add padding and border unless it's already including it
749            (isBorderBox ? 0 : paddingHeight + borderHeight);
750          }
751          size.innerWidth = size.width - (paddingWidth + borderWidth);
752          size.innerHeight = size.height - (paddingHeight + borderHeight);
753          size.outerWidth = size.width + marginWidth;
754          size.outerHeight = size.height + marginHeight;
755          return size;
756        }
757        return getSize2;
758      });
759    })(getSize);
760    return getSize.exports;
761  }
762  var utils$3 = { exports: {} };
763  var utils$2 = utils$3.exports;
764  var hasRequiredUtils;
765  function requireUtils() {
766    if (hasRequiredUtils) return utils$3.exports;
767    hasRequiredUtils = 1;
768    (function(module) {
769      (function(global2, factory) {
770        if (module.exports) {
771          module.exports = factory(global2);
772        } else {
773          global2.fizzyUIUtils = factory(global2);
774        }
775      })(utils$2, function factory(global2) {
776        let utils2 = {};
777        utils2.extend = function(a, b) {
778          return Object.assign(a, b);
779        };
780        utils2.modulo = function(num, div) {
781          return (num % div + div) % div;
782        };
783        utils2.makeArray = function(obj) {
784          if (Array.isArray(obj)) return obj;
785          if (obj === null || obj === void 0) return [];
786          let isArrayLike = typeof obj == "object" && typeof obj.length == "number";
787          if (isArrayLike) return [...obj];
788          return [obj];
789        };
790        utils2.removeFrom = function(ary, obj) {
791          let index = ary.indexOf(obj);
792          if (index != -1) {
793            ary.splice(index, 1);
794          }
795        };
796        utils2.getParent = function(elem, selector2) {
797          while (elem.parentNode && elem != document.body) {
798            elem = elem.parentNode;
799            if (elem.matches(selector2)) return elem;
800          }
801        };
802        utils2.getQueryElement = function(elem) {
803          if (typeof elem == "string") {
804            return document.querySelector(elem);
805          }
806          return elem;
807        };
808        utils2.handleEvent = function(event) {
809          let method = "on" + event.type;
810          if (this[method]) {
811            this[method](event);
812          }
813        };
814        utils2.filterFindElements = function(elems, selector2) {
815          elems = utils2.makeArray(elems);
816          return elems.filter((elem) => elem instanceof HTMLElement).reduce((ffElems, elem) => {
817            if (!selector2) {
818              ffElems.push(elem);
819              return ffElems;
820            }
821            if (elem.matches(selector2)) {
822              ffElems.push(elem);
823            }
824            let childElems = elem.querySelectorAll(selector2);
825            ffElems = ffElems.concat(...childElems);
826            return ffElems;
827          }, []);
828        };
829        utils2.debounceMethod = function(_class, methodName, threshold) {
830          threshold = threshold || 100;
831          let method = _class.prototype[methodName];
832          let timeoutName = methodName + "Timeout";
833          _class.prototype[methodName] = function() {
834            clearTimeout(this[timeoutName]);
835            let args = arguments;
836            this[timeoutName] = setTimeout(() => {
837              method.apply(this, args);
838              delete this[timeoutName];
839            }, threshold);
840          };
841        };
842        utils2.docReady = function(onDocReady) {
843          let readyState = document.readyState;
844          if (readyState == "complete" || readyState == "interactive") {
845            setTimeout(onDocReady);
846          } else {
847            document.addEventListener("DOMContentLoaded", onDocReady);
848          }
849        };
850        utils2.toDashed = function(str) {
851          return str.replace(/(.)([A-Z])/g, function(match, $1, $2) {
852            return $1 + "-" + $2;
853          }).toLowerCase();
854        };
855        let console2 = global2.console;
856        utils2.htmlInit = function(WidgetClass, namespace) {
857          utils2.docReady(function() {
858            let dashedNamespace = utils2.toDashed(namespace);
859            let dataAttr = "data-" + dashedNamespace;
860            let dataAttrElems = document.querySelectorAll(`[${dataAttr}]`);
861            let jQuery2 = global2.jQuery;
862            [...dataAttrElems].forEach((elem) => {
863              let attr = elem.getAttribute(dataAttr);
864              let options;
865              try {
866                options = attr && JSON.parse(attr);
867              } catch (error) {
868                if (console2) {
869                  console2.error(`Error parsing ${dataAttr} on ${elem.className}: ${error}`);
870                }
871                return;
872              }
873              let instance = new WidgetClass(elem, options);
874              if (jQuery2) {
875                jQuery2.data(elem, namespace, instance);
876              }
877            });
878          });
879        };
880        return utils2;
881      });
882    })(utils$3);
883    return utils$3.exports;
884  }
885  var cell$1 = { exports: {} };
886  var cell = cell$1.exports;
887  var hasRequiredCell;
888  function requireCell() {
889    if (hasRequiredCell) return cell$1.exports;
890    hasRequiredCell = 1;
891    (function(module) {
892      (function(window2, factory) {
893        if (module.exports) {
894          module.exports = factory(requireGetSize());
895        } else {
896          window2.Flickity = window2.Flickity || {};
897          window2.Flickity.Cell = factory(window2.getSize);
898        }
899      })(typeof window != "undefined" ? window : cell, function factory(getSize2) {
900        const cellClassName = "flickity-cell";
901        function Cell(elem) {
902          this.element = elem;
903          this.element.classList.add(cellClassName);
904          this.x = 0;
905          this.unselect();
906        }
907        let proto = Cell.prototype;
908        proto.destroy = function() {
909          this.unselect();
910          this.element.classList.remove(cellClassName);
911          this.element.style.transform = "";
912          this.element.removeAttribute("aria-hidden");
913        };
914        proto.getSize = function() {
915          this.size = getSize2(this.element);
916        };
917        proto.select = function() {
918          this.element.classList.add("is-selected");
919          this.element.removeAttribute("aria-hidden");
920        };
921        proto.unselect = function() {
922          this.element.classList.remove("is-selected");
923          this.element.setAttribute("aria-hidden", "true");
924        };
925        proto.remove = function() {
926          this.element.remove();
927        };
928        return Cell;
929      });
930    })(cell$1);
931    return cell$1.exports;
932  }
933  var slide$1 = { exports: {} };
934  var slide = slide$1.exports;
935  var hasRequiredSlide;
936  function requireSlide() {
937    if (hasRequiredSlide) return slide$1.exports;
938    hasRequiredSlide = 1;
939    (function(module) {
940      (function(window2, factory) {
941        if (module.exports) {
942          module.exports = factory();
943        } else {
944          window2.Flickity = window2.Flickity || {};
945          window2.Flickity.Slide = factory();
946        }
947      })(typeof window != "undefined" ? window : slide, function factory() {
948        function Slide(beginMargin, endMargin, cellAlign) {
949          this.beginMargin = beginMargin;
950          this.endMargin = endMargin;
951          this.cellAlign = cellAlign;
952          this.cells = [];
953          this.outerWidth = 0;
954          this.height = 0;
955        }
956        let proto = Slide.prototype;
957        proto.addCell = function(cell2) {
958          this.cells.push(cell2);
959          this.outerWidth += cell2.size.outerWidth;
960          this.height = Math.max(cell2.size.outerHeight, this.height);
961          if (this.cells.length === 1) {
962            this.x = cell2.x;
963            this.firstMargin = cell2.size[this.beginMargin];
964          }
965        };
966        proto.updateTarget = function() {
967          let lastCell = this.getLastCell();
968          let lastMargin = lastCell ? lastCell.size[this.endMargin] : 0;
969          let slideWidth = this.outerWidth - (this.firstMargin + lastMargin);
970          this.target = this.x + this.firstMargin + slideWidth * this.cellAlign;
971        };
972        proto.getLastCell = function() {
973          return this.cells[this.cells.length - 1];
974        };
975        proto.select = function() {
976          this.cells.forEach((cell2) => cell2.select());
977        };
978        proto.unselect = function() {
979          this.cells.forEach((cell2) => cell2.unselect());
980        };
981        proto.getCellElements = function() {
982          return this.cells.map((cell2) => cell2.element);
983        };
984        return Slide;
985      });
986    })(slide$1);
987    return slide$1.exports;
988  }
989  var animate$1 = { exports: {} };
990  var animate = animate$1.exports;
991  var hasRequiredAnimate;
992  function requireAnimate() {
993    if (hasRequiredAnimate) return animate$1.exports;
994    hasRequiredAnimate = 1;
995    (function(module) {
996      (function(window2, factory) {
997        if (module.exports) {
998          module.exports = factory(requireUtils());
999        } else {
1000          window2.Flickity = window2.Flickity || {};
1001          window2.Flickity.animatePrototype = factory(window2.fizzyUIUtils);
1002        }
1003      })(typeof window != "undefined" ? window : animate, function factory(utils2) {
1004        let proto = {};
1005        proto.startAnimation = function() {
1006          if (this.isAnimating) return;
1007          this.isAnimating = true;
1008          this.restingFrames = 0;
1009          this.animate();
1010        };
1011        proto.animate = function() {
1012          this.applyDragForce();
1013          this.applySelectedAttraction();
1014          let previousX = this.x;
1015          this.integratePhysics();
1016          this.positionSlider();
1017          this.settle(previousX);
1018          if (this.isAnimating) requestAnimationFrame(() => this.animate());
1019        };
1020        proto.positionSlider = function() {
1021          let x = this.x;
1022          if (this.isWrapping) {
1023            x = utils2.modulo(x, this.slideableWidth) - this.slideableWidth;
1024            this.shiftWrapCells(x);
1025          }
1026          this.setTranslateX(x, this.isAnimating);
1027          this.dispatchScrollEvent();
1028        };
1029        proto.setTranslateX = function(x, is3d) {
1030          x += this.cursorPosition;
1031          if (this.options.rightToLeft) x = -x;
1032          let translateX = this.getPositionValue(x);
1033          this.slider.style.transform = is3d ? `translate3d(${translateX},0,0)` : `translateX(${translateX})`;
1034        };
1035        proto.dispatchScrollEvent = function() {
1036          let firstSlide = this.slides[0];
1037          if (!firstSlide) return;
1038          let positionX = -this.x - firstSlide.target;
1039          let progress = positionX / this.slidesWidth;
1040          this.dispatchEvent("scroll", null, [progress, positionX]);
1041        };
1042        proto.positionSliderAtSelected = function() {
1043          if (!this.cells.length) return;
1044          this.x = -this.selectedSlide.target;
1045          this.velocity = 0;
1046          this.positionSlider();
1047        };
1048        proto.getPositionValue = function(position) {
1049          if (this.options.percentPosition) {
1050            return Math.round(position / this.size.innerWidth * 1e4) * 0.01 + "%";
1051          } else {
1052            return Math.round(position) + "px";
1053          }
1054        };
1055        proto.settle = function(previousX) {
1056          let isResting = !this.isPointerDown && Math.round(this.x * 100) === Math.round(previousX * 100);
1057          if (isResting) this.restingFrames++;
1058          if (this.restingFrames > 2) {
1059            this.isAnimating = false;
1060            delete this.isFreeScrolling;
1061            this.positionSlider();
1062            this.dispatchEvent("settle", null, [this.selectedIndex]);
1063          }
1064        };
1065        proto.shiftWrapCells = function(x) {
1066          let beforeGap = this.cursorPosition + x;
1067          this._shiftCells(this.beforeShiftCells, beforeGap, -1);
1068          let afterGap = this.size.innerWidth - (x + this.slideableWidth + this.cursorPosition);
1069          this._shiftCells(this.afterShiftCells, afterGap, 1);
1070        };
1071        proto._shiftCells = function(cells, gap, shift) {
1072          cells.forEach((cell2) => {
1073            let cellShift = gap > 0 ? shift : 0;
1074            this._wrapShiftCell(cell2, cellShift);
1075            gap -= cell2.size.outerWidth;
1076          });
1077        };
1078        proto._unshiftCells = function(cells) {
1079          if (!cells || !cells.length) return;
1080          cells.forEach((cell2) => this._wrapShiftCell(cell2, 0));
1081        };
1082        proto._wrapShiftCell = function(cell2, shift) {
1083          this._renderCellPosition(cell2, cell2.x + this.slideableWidth * shift);
1084        };
1085        proto.integratePhysics = function() {
1086          this.x += this.velocity;
1087          this.velocity *= this.getFrictionFactor();
1088        };
1089        proto.applyForce = function(force) {
1090          this.velocity += force;
1091        };
1092        proto.getFrictionFactor = function() {
1093          return 1 - this.options[this.isFreeScrolling ? "freeScrollFriction" : "friction"];
1094        };
1095        proto.getRestingPosition = function() {
1096          return this.x + this.velocity / (1 - this.getFrictionFactor());
1097        };
1098        proto.applyDragForce = function() {
1099          if (!this.isDraggable || !this.isPointerDown) return;
1100          let dragVelocity = this.dragX - this.x;
1101          let dragForce = dragVelocity - this.velocity;
1102          this.applyForce(dragForce);
1103        };
1104        proto.applySelectedAttraction = function() {
1105          let dragDown = this.isDraggable && this.isPointerDown;
1106          if (dragDown || this.isFreeScrolling || !this.slides.length) return;
1107          let distance = this.selectedSlide.target * -1 - this.x;
1108          let force = distance * this.options.selectedAttraction;
1109          this.applyForce(force);
1110        };
1111        return proto;
1112      });
1113    })(animate$1);
1114    return animate$1.exports;
1115  }
1116  var core = core$1.exports;
1117  var hasRequiredCore;
1118  function requireCore() {
1119    if (hasRequiredCore) return core$1.exports;
1120    hasRequiredCore = 1;
1121    (function(module) {
1122      (function(window2, factory) {
1123        if (module.exports) {
1124          module.exports = factory(
1125            window2,
1126            requireEvEmitter(),
1127            requireGetSize(),
1128            requireUtils(),
1129            requireCell(),
1130            requireSlide(),
1131            requireAnimate()
1132          );
1133        } else {
1134          let _Flickity = window2.Flickity;
1135          window2.Flickity = factory(
1136            window2,
1137            window2.EvEmitter,
1138            window2.getSize,
1139            window2.fizzyUIUtils,
1140            _Flickity.Cell,
1141            _Flickity.Slide,
1142            _Flickity.animatePrototype
1143          );
1144        }
1145      })(
1146        typeof window != "undefined" ? window : core,
1147        function factory(window2, EvEmitter, getSize2, utils2, Cell, Slide, animatePrototype) {
1148          const { getComputedStyle: getComputedStyle2, console: console2 } = window2;
1149          let { jQuery: jQuery2 } = window2;
1150          let GUID = 0;
1151          let instances = {};
1152          function Flickity2(element, options) {
1153            let queryElement = utils2.getQueryElement(element);
1154            if (!queryElement) {
1155              if (console2) console2.error(`Bad element for Flickity: ${queryElement || element}`);
1156              return;
1157            }
1158            this.element = queryElement;
1159            if (this.element.flickityGUID) {
1160              let instance = instances[this.element.flickityGUID];
1161              if (instance) instance.option(options);
1162              return instance;
1163            }
1164            if (jQuery2) {
1165              this.$element = jQuery2(this.element);
1166            }
1167            this.options = { ...this.constructor.defaults };
1168            this.option(options);
1169            this._create();
1170          }
1171          Flickity2.defaults = {
1172            accessibility: true,
1173            // adaptiveHeight: false,
1174            cellAlign: "center",
1175            // cellSelector: undefined,
1176            // contain: false,
1177            freeScrollFriction: 0.075,
1178            // friction when free-scrolling
1179            friction: 0.28,
1180            // friction when selecting
1181            namespaceJQueryEvents: true,
1182            // initialIndex: 0,
1183            percentPosition: true,
1184            resize: true,
1185            selectedAttraction: 0.025,
1186            setGallerySize: true
1187            // watchCSS: false,
1188            // wrapAround: false
1189          };
1190          Flickity2.create = {};
1191          let proto = Flickity2.prototype;
1192          Object.assign(proto, EvEmitter.prototype);
1193          proto._create = function() {
1194            let { resize, watchCSS, rightToLeft } = this.options;
1195            let id = this.guid = ++GUID;
1196            this.element.flickityGUID = id;
1197            instances[id] = this;
1198            this.selectedIndex = 0;
1199            this.restingFrames = 0;
1200            this.x = 0;
1201            this.velocity = 0;
1202            this.beginMargin = rightToLeft ? "marginRight" : "marginLeft";
1203            this.endMargin = rightToLeft ? "marginLeft" : "marginRight";
1204            this.viewport = document.createElement("div");
1205            this.viewport.className = "flickity-viewport";
1206            this._createSlider();
1207            this.focusableElems = [this.element];
1208            if (resize || watchCSS) {
1209              window2.addEventListener("resize", this);
1210            }
1211            for (let eventName in this.options.on) {
1212              let listener = this.options.on[eventName];
1213              this.on(eventName, listener);
1214            }
1215            for (let method in Flickity2.create) {
1216              Flickity2.create[method].call(this);
1217            }
1218            if (watchCSS) {
1219              this.watchCSS();
1220            } else {
1221              this.activate();
1222            }
1223          };
1224          proto.option = function(opts) {
1225            Object.assign(this.options, opts);
1226          };
1227          proto.activate = function() {
1228            if (this.isActive) return;
1229            this.isActive = true;
1230            this.element.classList.add("flickity-enabled");
1231            if (this.options.rightToLeft) {
1232              this.element.classList.add("flickity-rtl");
1233            }
1234            this.getSize();
1235            let cellElems = this._filterFindCellElements(this.element.children);
1236            this.slider.append(...cellElems);
1237            this.viewport.append(this.slider);
1238            this.element.append(this.viewport);
1239            this.reloadCells();
1240            if (this.options.accessibility) {
1241              this.element.tabIndex = 0;
1242              this.element.addEventListener("keydown", this);
1243            }
1244            this.emitEvent("activate");
1245            this.selectInitialIndex();
1246            this.isInitActivated = true;
1247            this.dispatchEvent("ready");
1248          };
1249          proto._createSlider = function() {
1250            let slider = document.createElement("div");
1251            slider.className = "flickity-slider";
1252            this.slider = slider;
1253          };
1254          proto._filterFindCellElements = function(elems) {
1255            return utils2.filterFindElements(elems, this.options.cellSelector);
1256          };
1257          proto.reloadCells = function() {
1258            this.cells = this._makeCells(this.slider.children);
1259            this.positionCells();
1260            this._updateWrapShiftCells();
1261            this.setGallerySize();
1262          };
1263          proto._makeCells = function(elems) {
1264            let cellElems = this._filterFindCellElements(elems);
1265            return cellElems.map((cellElem) => new Cell(cellElem));
1266          };
1267          proto.getLastCell = function() {
1268            return this.cells[this.cells.length - 1];
1269          };
1270          proto.getLastSlide = function() {
1271            return this.slides[this.slides.length - 1];
1272          };
1273          proto.positionCells = function() {
1274            this._sizeCells(this.cells);
1275            this._positionCells(0);
1276          };
1277          proto._positionCells = function(index) {
1278            index = index || 0;
1279            this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
1280            let cellX = 0;
1281            if (index > 0) {
1282              let startCell = this.cells[index - 1];
1283              cellX = startCell.x + startCell.size.outerWidth;
1284            }
1285            this.cells.slice(index).forEach((cell2) => {
1286              cell2.x = cellX;
1287              this._renderCellPosition(cell2, cellX);
1288              cellX += cell2.size.outerWidth;
1289              this.maxCellHeight = Math.max(cell2.size.outerHeight, this.maxCellHeight);
1290            });
1291            this.slideableWidth = cellX;
1292            this.updateSlides();
1293            this._containSlides();
1294            this.slidesWidth = this.cells.length ? this.getLastSlide().target - this.slides[0].target : 0;
1295          };
1296          proto._renderCellPosition = function(cell2, x) {
1297            let sideOffset = this.options.rightToLeft ? -1 : 1;
1298            let renderX = x * sideOffset;
1299            if (this.options.percentPosition) renderX *= this.size.innerWidth / cell2.size.width;
1300            let positionValue = this.getPositionValue(renderX);
1301            cell2.element.style.transform = `translateX( ${positionValue} )`;
1302          };
1303          proto._sizeCells = function(cells) {
1304            cells.forEach((cell2) => cell2.getSize());
1305          };
1306          proto.updateSlides = function() {
1307            this.slides = [];
1308            if (!this.cells.length) return;
1309            let { beginMargin, endMargin } = this;
1310            let slide2 = new Slide(beginMargin, endMargin, this.cellAlign);
1311            this.slides.push(slide2);
1312            let canCellFit = this._getCanCellFit();
1313            this.cells.forEach((cell2, i2) => {
1314              if (!slide2.cells.length) {
1315                slide2.addCell(cell2);
1316                return;
1317              }
1318              let slideWidth = slide2.outerWidth - slide2.firstMargin + (cell2.size.outerWidth - cell2.size[endMargin]);
1319              if (canCellFit(i2, slideWidth)) {
1320                slide2.addCell(cell2);
1321              } else {
1322                slide2.updateTarget();
1323                slide2 = new Slide(beginMargin, endMargin, this.cellAlign);
1324                this.slides.push(slide2);
1325                slide2.addCell(cell2);
1326              }
1327            });
1328            slide2.updateTarget();
1329            this.updateSelectedSlide();
1330          };
1331          proto._getCanCellFit = function() {
1332            let { groupCells } = this.options;
1333            if (!groupCells) return () => false;
1334            if (typeof groupCells == "number") {
1335              let number = parseInt(groupCells, 10);
1336              return (i2) => i2 % number !== 0;
1337            }
1338            let percent = 1;
1339            let percentMatch = typeof groupCells == "string" && groupCells.match(/^(\d+)%$/);
1340            if (percentMatch) percent = parseInt(percentMatch[1], 10) / 100;
1341            let groupWidth = (this.size.innerWidth + 1) * percent;
1342            return (i2, slideWidth) => slideWidth <= groupWidth;
1343          };
1344          proto._init = proto.reposition = function() {
1345            this.positionCells();
1346            this.positionSliderAtSelected();
1347          };
1348          proto.getSize = function() {
1349            this.size = getSize2(this.element);
1350            this.setCellAlign();
1351            this.cursorPosition = this.size.innerWidth * this.cellAlign;
1352          };
1353          let cellAlignShorthands = {
1354            left: 0,
1355            center: 0.5,
1356            right: 1
1357          };
1358          proto.setCellAlign = function() {
1359            let { cellAlign, rightToLeft } = this.options;
1360            let shorthand = cellAlignShorthands[cellAlign];
1361            this.cellAlign = shorthand !== void 0 ? shorthand : cellAlign;
1362            if (rightToLeft) this.cellAlign = 1 - this.cellAlign;
1363          };
1364          proto.setGallerySize = function() {
1365            if (!this.options.setGallerySize) return;
1366            let height = this.options.adaptiveHeight && this.selectedSlide ? this.selectedSlide.height : this.maxCellHeight;
1367            this.viewport.style.height = `${height}px`;
1368          };
1369          proto._updateWrapShiftCells = function() {
1370            this.isWrapping = this.getIsWrapping();
1371            if (!this.isWrapping) return;
1372            this._unshiftCells(this.beforeShiftCells);
1373            this._unshiftCells(this.afterShiftCells);
1374            let beforeGapX = this.cursorPosition;
1375            let lastIndex = this.cells.length - 1;
1376            this.beforeShiftCells = this._getGapCells(beforeGapX, lastIndex, -1);
1377            let afterGapX = this.size.innerWidth - this.cursorPosition;
1378            this.afterShiftCells = this._getGapCells(afterGapX, 0, 1);
1379          };
1380          proto.getIsWrapping = function() {
1381            let { wrapAround } = this.options;
1382            if (!wrapAround || this.slides.length < 2) return false;
1383            if (wrapAround !== "fill") return true;
1384            let gapWidth = this.slideableWidth - this.size.innerWidth;
1385            if (gapWidth > this.size.innerWidth) return true;
1386            for (let cell2 of this.cells) {
1387              if (cell2.size.outerWidth > gapWidth) return false;
1388            }
1389            return true;
1390          };
1391          proto._getGapCells = function(gapX, cellIndex, increment) {
1392            let cells = [];
1393            while (gapX > 0) {
1394              let cell2 = this.cells[cellIndex];
1395              if (!cell2) break;
1396              cells.push(cell2);
1397              cellIndex += increment;
1398              gapX -= cell2.size.outerWidth;
1399            }
1400            return cells;
1401          };
1402          proto._containSlides = function() {
1403            let isContaining = this.options.contain && !this.isWrapping && this.cells.length;
1404            if (!isContaining) return;
1405            let contentWidth = this.slideableWidth - this.getLastCell().size[this.endMargin];
1406            let isContentSmaller = contentWidth < this.size.innerWidth;
1407            if (isContentSmaller) {
1408              this.slides.forEach((slide2) => {
1409                slide2.target = contentWidth * this.cellAlign;
1410              });
1411            } else {
1412              let beginBound = this.cursorPosition + this.cells[0].size[this.beginMargin];
1413              let endBound = contentWidth - this.size.innerWidth * (1 - this.cellAlign);
1414              this.slides.forEach((slide2) => {
1415                slide2.target = Math.max(slide2.target, beginBound);
1416                slide2.target = Math.min(slide2.target, endBound);
1417              });
1418            }
1419          };
1420          proto.dispatchEvent = function(type, event, args) {
1421            let emitArgs = event ? [event].concat(args) : args;
1422            this.emitEvent(type, emitArgs);
1423            if (jQuery2 && this.$element) {
1424              type += this.options.namespaceJQueryEvents ? ".flickity" : "";
1425              let $event = type;
1426              if (event) {
1427                let jQEvent = new jQuery2.Event(event);
1428                jQEvent.type = type;
1429                $event = jQEvent;
1430              }
1431              this.$element.trigger($event, args);
1432            }
1433          };
1434          const unidraggerEvents = [
1435            "dragStart",
1436            "dragMove",
1437            "dragEnd",
1438            "pointerDown",
1439            "pointerMove",
1440            "pointerEnd",
1441            "staticClick"
1442          ];
1443          let _emitEvent = proto.emitEvent;
1444          proto.emitEvent = function(eventName, args) {
1445            if (eventName === "staticClick") {
1446              let clickedCell = this.getParentCell(args[0].target);
1447              let cellElem = clickedCell && clickedCell.element;
1448              let cellIndex = clickedCell && this.cells.indexOf(clickedCell);
1449              args = args.concat(cellElem, cellIndex);
1450            }
1451            _emitEvent.call(this, eventName, args);
1452            let isUnidraggerEvent = unidraggerEvents.includes(eventName);
1453            if (!isUnidraggerEvent || !jQuery2 || !this.$element) return;
1454            eventName += this.options.namespaceJQueryEvents ? ".flickity" : "";
1455            let event = args.shift(0);
1456            let jQEvent = new jQuery2.Event(event);
1457            jQEvent.type = eventName;
1458            this.$element.trigger(jQEvent, args);
1459          };
1460          proto.select = function(index, isWrap, isInstant) {
1461            if (!this.isActive) return;
1462            index = parseInt(index, 10);
1463            this._wrapSelect(index);
1464            if (this.isWrapping || isWrap) {
1465              index = utils2.modulo(index, this.slides.length);
1466            }
1467            if (!this.slides[index]) return;
1468            let prevIndex = this.selectedIndex;
1469            this.selectedIndex = index;
1470            this.updateSelectedSlide();
1471            if (isInstant) {
1472              this.positionSliderAtSelected();
1473            } else {
1474              this.startAnimation();
1475            }
1476            if (this.options.adaptiveHeight) {
1477              this.setGallerySize();
1478            }
1479            this.dispatchEvent("select", null, [index]);
1480            if (index !== prevIndex) {
1481              this.dispatchEvent("change", null, [index]);
1482            }
1483          };
1484          proto._wrapSelect = function(index) {
1485            if (!this.isWrapping) return;
1486            const { selectedIndex, slideableWidth, slides: { length } } = this;
1487            if (!this.isDragSelect) {
1488              let wrapIndex = utils2.modulo(index, length);
1489              let delta = Math.abs(wrapIndex - selectedIndex);
1490              let backWrapDelta = Math.abs(wrapIndex + length - selectedIndex);
1491              let forewardWrapDelta = Math.abs(wrapIndex - length - selectedIndex);
1492              if (backWrapDelta < delta) {
1493                index += length;
1494              } else if (forewardWrapDelta < delta) {
1495                index -= length;
1496              }
1497            }
1498            if (index < 0) {
1499              this.x -= slideableWidth;
1500            } else if (index >= length) {
1501              this.x += slideableWidth;
1502            }
1503          };
1504          proto.previous = function(isWrap, isInstant) {
1505            this.select(this.selectedIndex - 1, isWrap, isInstant);
1506          };
1507          proto.next = function(isWrap, isInstant) {
1508            this.select(this.selectedIndex + 1, isWrap, isInstant);
1509          };
1510          proto.updateSelectedSlide = function() {
1511            let slide2 = this.slides[this.selectedIndex];
1512            if (!slide2) return;
1513            this.unselectSelectedSlide();
1514            this.selectedSlide = slide2;
1515            slide2.select();
1516            this.selectedCells = slide2.cells;
1517            this.selectedElements = slide2.getCellElements();
1518            this.selectedCell = slide2.cells[0];
1519            this.selectedElement = this.selectedElements[0];
1520          };
1521          proto.unselectSelectedSlide = function() {
1522            if (this.selectedSlide) this.selectedSlide.unselect();
1523          };
1524          proto.selectInitialIndex = function() {
1525            let initialIndex = this.options.initialIndex;
1526            if (this.isInitActivated) {
1527              this.select(this.selectedIndex, false, true);
1528              return;
1529            }
1530            if (initialIndex && typeof initialIndex == "string") {
1531              let cell2 = this.queryCell(initialIndex);
1532              if (cell2) {
1533                this.selectCell(initialIndex, false, true);
1534                return;
1535              }
1536            }
1537            let index = 0;
1538            if (initialIndex && this.slides[initialIndex]) {
1539              index = initialIndex;
1540            }
1541            this.select(index, false, true);
1542          };
1543          proto.selectCell = function(value, isWrap, isInstant) {
1544            let cell2 = this.queryCell(value);
1545            if (!cell2) return;
1546            let index = this.getCellSlideIndex(cell2);
1547            this.select(index, isWrap, isInstant);
1548          };
1549          proto.getCellSlideIndex = function(cell2) {
1550            let cellSlide = this.slides.find((slide2) => slide2.cells.includes(cell2));
1551            return this.slides.indexOf(cellSlide);
1552          };
1553          proto.getCell = function(elem) {
1554            for (let cell2 of this.cells) {
1555              if (cell2.element === elem) return cell2;
1556            }
1557          };
1558          proto.getCells = function(elems) {
1559            elems = utils2.makeArray(elems);
1560            return elems.map((elem) => this.getCell(elem)).filter(Boolean);
1561          };
1562          proto.getCellElements = function() {
1563            return this.cells.map((cell2) => cell2.element);
1564          };
1565          proto.getParentCell = function(elem) {
1566            let cell2 = this.getCell(elem);
1567            if (cell2) return cell2;
1568            let closest = elem.closest(".flickity-slider > *");
1569            return this.getCell(closest);
1570          };
1571          proto.getAdjacentCellElements = function(adjCount, index) {
1572            if (!adjCount) return this.selectedSlide.getCellElements();
1573            index = index === void 0 ? this.selectedIndex : index;
1574            let len = this.slides.length;
1575            if (1 + adjCount * 2 >= len) {
1576              return this.getCellElements();
1577            }
1578            let cellElems = [];
1579            for (let i2 = index - adjCount; i2 <= index + adjCount; i2++) {
1580              let slideIndex = this.isWrapping ? utils2.modulo(i2, len) : i2;
1581              let slide2 = this.slides[slideIndex];
1582              if (slide2) {
1583                cellElems = cellElems.concat(slide2.getCellElements());
1584              }
1585            }
1586            return cellElems;
1587          };
1588          proto.queryCell = function(selector2) {
1589            if (typeof selector2 == "number") {
1590              return this.cells[selector2];
1591            }
1592            let isSelectorString = typeof selector2 == "string" && !selector2.match(/^[#.]?[\d/]/);
1593            if (isSelectorString) {
1594              selector2 = this.element.querySelector(selector2);
1595            }
1596            return this.getCell(selector2);
1597          };
1598          proto.uiChange = function() {
1599            this.emitEvent("uiChange");
1600          };
1601          proto.onresize = function() {
1602            this.watchCSS();
1603            this.resize();
1604          };
1605          utils2.debounceMethod(Flickity2, "onresize", 150);
1606          proto.resize = function() {
1607            if (!this.isActive || this.isAnimating || this.isDragging) return;
1608            this.getSize();
1609            if (this.isWrapping) {
1610              this.x = utils2.modulo(this.x, this.slideableWidth);
1611            }
1612            this.positionCells();
1613            this._updateWrapShiftCells();
1614            this.setGallerySize();
1615            this.emitEvent("resize");
1616            let selectedElement = this.selectedElements && this.selectedElements[0];
1617            this.selectCell(selectedElement, false, true);
1618          };
1619          proto.watchCSS = function() {
1620            if (!this.options.watchCSS) return;
1621            let afterContent = getComputedStyle2(this.element, ":after").content;
1622            if (afterContent.includes("flickity")) {
1623              this.activate();
1624            } else {
1625              this.deactivate();
1626            }
1627          };
1628          proto.onkeydown = function(event) {
1629            let { activeElement } = document;
1630            let handler = Flickity2.keyboardHandlers[event.key];
1631            if (!this.options.accessibility || !activeElement || !handler) return;
1632            let isFocused = this.focusableElems.some((elem) => activeElement === elem);
1633            if (isFocused) handler.call(this);
1634          };
1635          Flickity2.keyboardHandlers = {
1636            ArrowLeft: function() {
1637              this.uiChange();
1638              let leftMethod = this.options.rightToLeft ? "next" : "previous";
1639              this[leftMethod]();
1640            },
1641            ArrowRight: function() {
1642              this.uiChange();
1643              let rightMethod = this.options.rightToLeft ? "previous" : "next";
1644              this[rightMethod]();
1645            }
1646          };
1647          proto.focus = function() {
1648            this.element.focus({ preventScroll: true });
1649          };
1650          proto.deactivate = function() {
1651            if (!this.isActive) return;
1652            this.element.classList.remove("flickity-enabled");
1653            this.element.classList.remove("flickity-rtl");
1654            this.unselectSelectedSlide();
1655            this.cells.forEach((cell2) => cell2.destroy());
1656            this.viewport.remove();
1657            this.element.append(...this.slider.children);
1658            if (this.options.accessibility) {
1659              this.element.removeAttribute("tabIndex");
1660              this.element.removeEventListener("keydown", this);
1661            }
1662            this.isActive = false;
1663            this.emitEvent("deactivate");
1664          };
1665          proto.destroy = function() {
1666            this.deactivate();
1667            window2.removeEventListener("resize", this);
1668            this.allOff();
1669            this.emitEvent("destroy");
1670            if (jQuery2 && this.$element) {
1671              jQuery2.removeData(this.element, "flickity");
1672            }
1673            delete this.element.flickityGUID;
1674            delete instances[this.guid];
1675          };
1676          Object.assign(proto, animatePrototype);
1677          Flickity2.data = function(elem) {
1678            elem = utils2.getQueryElement(elem);
1679            if (elem) return instances[elem.flickityGUID];
1680          };
1681          utils2.htmlInit(Flickity2, "flickity");
1682          let { jQueryBridget } = window2;
1683          if (jQuery2 && jQueryBridget) {
1684            jQueryBridget("flickity", Flickity2, jQuery2);
1685          }
1686          Flickity2.setJQuery = function(jq) {
1687            jQuery2 = jq;
1688          };
1689          Flickity2.Cell = Cell;
1690          Flickity2.Slide = Slide;
1691          return Flickity2;
1692        }
1693      );
1694    })(core$1);
1695    return core$1.exports;
1696  }
1697  var drag$1 = { exports: {} };
1698  var unidragger$1 = { exports: {} };
1699  /*!
1700   * Unidragger v3.0.1
1701   * Draggable base class
1702   * MIT license
1703   */
1704  var unidragger = unidragger$1.exports;
1705  var hasRequiredUnidragger;
1706  function requireUnidragger() {
1707    if (hasRequiredUnidragger) return unidragger$1.exports;
1708    hasRequiredUnidragger = 1;
1709    (function(module) {
1710      (function(window2, factory) {
1711        if (module.exports) {
1712          module.exports = factory(
1713            window2,
1714            requireEvEmitter()
1715          );
1716        } else {
1717          window2.Unidragger = factory(
1718            window2,
1719            window2.EvEmitter
1720          );
1721        }
1722      })(typeof window != "undefined" ? window : unidragger, function factory(window2, EvEmitter) {
1723        function Unidragger() {
1724        }
1725        let proto = Unidragger.prototype = Object.create(EvEmitter.prototype);
1726        proto.handleEvent = function(event) {
1727          let method = "on" + event.type;
1728          if (this[method]) {
1729            this[method](event);
1730          }
1731        };
1732        let startEvent, activeEvents;
1733        if ("ontouchstart" in window2) {
1734          startEvent = "touchstart";
1735          activeEvents = ["touchmove", "touchend", "touchcancel"];
1736        } else if (window2.PointerEvent) {
1737          startEvent = "pointerdown";
1738          activeEvents = ["pointermove", "pointerup", "pointercancel"];
1739        } else {
1740          startEvent = "mousedown";
1741          activeEvents = ["mousemove", "mouseup"];
1742        }
1743        proto.touchActionValue = "none";
1744        proto.bindHandles = function() {
1745          this._bindHandles("addEventListener", this.touchActionValue);
1746        };
1747        proto.unbindHandles = function() {
1748          this._bindHandles("removeEventListener", "");
1749        };
1750        proto._bindHandles = function(bindMethod, touchAction) {
1751          this.handles.forEach((handle) => {
1752            handle[bindMethod](startEvent, this);
1753            handle[bindMethod]("click", this);
1754            if (window2.PointerEvent) handle.style.touchAction = touchAction;
1755          });
1756        };
1757        proto.bindActivePointerEvents = function() {
1758          activeEvents.forEach((eventName) => {
1759            window2.addEventListener(eventName, this);
1760          });
1761        };
1762        proto.unbindActivePointerEvents = function() {
1763          activeEvents.forEach((eventName) => {
1764            window2.removeEventListener(eventName, this);
1765          });
1766        };
1767        proto.withPointer = function(methodName, event) {
1768          if (event.pointerId === this.pointerIdentifier) {
1769            this[methodName](event, event);
1770          }
1771        };
1772        proto.withTouch = function(methodName, event) {
1773          let touch;
1774          for (let changedTouch of event.changedTouches) {
1775            if (changedTouch.identifier === this.pointerIdentifier) {
1776              touch = changedTouch;
1777            }
1778          }
1779          if (touch) this[methodName](event, touch);
1780        };
1781        proto.onmousedown = function(event) {
1782          this.pointerDown(event, event);
1783        };
1784        proto.ontouchstart = function(event) {
1785          this.pointerDown(event, event.changedTouches[0]);
1786        };
1787        proto.onpointerdown = function(event) {
1788          this.pointerDown(event, event);
1789        };
1790        const cursorNodes = ["TEXTAREA", "INPUT", "SELECT", "OPTION"];
1791        const clickTypes = ["radio", "checkbox", "button", "submit", "image", "file"];
1792        proto.pointerDown = function(event, pointer) {
1793          let isCursorNode = cursorNodes.includes(event.target.nodeName);
1794          let isClickType = clickTypes.includes(event.target.type);
1795          let isOkayElement = !isCursorNode || isClickType;
1796          let isOkay = !this.isPointerDown && !event.button && isOkayElement;
1797          if (!isOkay) return;
1798          this.isPointerDown = true;
1799          this.pointerIdentifier = pointer.pointerId !== void 0 ? (
1800            // pointerId for pointer events, touch.indentifier for touch events
1801            pointer.pointerId
1802          ) : pointer.identifier;
1803          this.pointerDownPointer = {
1804            pageX: pointer.pageX,
1805            pageY: pointer.pageY
1806          };
1807          this.bindActivePointerEvents();
1808          this.emitEvent("pointerDown", [event, pointer]);
1809        };
1810        proto.onmousemove = function(event) {
1811          this.pointerMove(event, event);
1812        };
1813        proto.onpointermove = function(event) {
1814          this.withPointer("pointerMove", event);
1815        };
1816        proto.ontouchmove = function(event) {
1817          this.withTouch("pointerMove", event);
1818        };
1819        proto.pointerMove = function(event, pointer) {
1820          let moveVector = {
1821            x: pointer.pageX - this.pointerDownPointer.pageX,
1822            y: pointer.pageY - this.pointerDownPointer.pageY
1823          };
1824          this.emitEvent("pointerMove", [event, pointer, moveVector]);
1825          let isDragStarting = !this.isDragging && this.hasDragStarted(moveVector);
1826          if (isDragStarting) this.dragStart(event, pointer);
1827          if (this.isDragging) this.dragMove(event, pointer, moveVector);
1828        };
1829        proto.hasDragStarted = function(moveVector) {
1830          return Math.abs(moveVector.x) > 3 || Math.abs(moveVector.y) > 3;
1831        };
1832        proto.dragStart = function(event, pointer) {
1833          this.isDragging = true;
1834          this.isPreventingClicks = true;
1835          this.emitEvent("dragStart", [event, pointer]);
1836        };
1837        proto.dragMove = function(event, pointer, moveVector) {
1838          this.emitEvent("dragMove", [event, pointer, moveVector]);
1839        };
1840        proto.onmouseup = function(event) {
1841          this.pointerUp(event, event);
1842        };
1843        proto.onpointerup = function(event) {
1844          this.withPointer("pointerUp", event);
1845        };
1846        proto.ontouchend = function(event) {
1847          this.withTouch("pointerUp", event);
1848        };
1849        proto.pointerUp = function(event, pointer) {
1850          this.pointerDone();
1851          this.emitEvent("pointerUp", [event, pointer]);
1852          if (this.isDragging) {
1853            this.dragEnd(event, pointer);
1854          } else {
1855            this.staticClick(event, pointer);
1856          }
1857        };
1858        proto.dragEnd = function(event, pointer) {
1859          this.isDragging = false;
1860          setTimeout(() => delete this.isPreventingClicks);
1861          this.emitEvent("dragEnd", [event, pointer]);
1862        };
1863        proto.pointerDone = function() {
1864          this.isPointerDown = false;
1865          delete this.pointerIdentifier;
1866          this.unbindActivePointerEvents();
1867          this.emitEvent("pointerDone");
1868        };
1869        proto.onpointercancel = function(event) {
1870          this.withPointer("pointerCancel", event);
1871        };
1872        proto.ontouchcancel = function(event) {
1873          this.withTouch("pointerCancel", event);
1874        };
1875        proto.pointerCancel = function(event, pointer) {
1876          this.pointerDone();
1877          this.emitEvent("pointerCancel", [event, pointer]);
1878        };
1879        proto.onclick = function(event) {
1880          if (this.isPreventingClicks) event.preventDefault();
1881        };
1882        proto.staticClick = function(event, pointer) {
1883          let isMouseup = event.type === "mouseup";
1884          if (isMouseup && this.isIgnoringMouseUp) return;
1885          this.emitEvent("staticClick", [event, pointer]);
1886          if (isMouseup) {
1887            this.isIgnoringMouseUp = true;
1888            setTimeout(() => {
1889              delete this.isIgnoringMouseUp;
1890            }, 400);
1891          }
1892        };
1893        return Unidragger;
1894      });
1895    })(unidragger$1);
1896    return unidragger$1.exports;
1897  }
1898  var drag = drag$1.exports;
1899  var hasRequiredDrag;
1900  function requireDrag() {
1901    if (hasRequiredDrag) return drag$1.exports;
1902    hasRequiredDrag = 1;
1903    (function(module) {
1904      (function(window2, factory) {
1905        if (module.exports) {
1906          module.exports = factory(
1907            window2,
1908            requireCore(),
1909            requireUnidragger(),
1910            requireUtils()
1911          );
1912        } else {
1913          window2.Flickity = factory(
1914            window2,
1915            window2.Flickity,
1916            window2.Unidragger,
1917            window2.fizzyUIUtils
1918          );
1919        }
1920      })(
1921        typeof window != "undefined" ? window : drag,
1922        function factory(window2, Flickity2, Unidragger, utils2) {
1923          Object.assign(Flickity2.defaults, {
1924            draggable: ">1",
1925            dragThreshold: 3
1926          });
1927          let proto = Flickity2.prototype;
1928          Object.assign(proto, Unidragger.prototype);
1929          proto.touchActionValue = "";
1930          Flickity2.create.drag = function() {
1931            this.on("activate", this.onActivateDrag);
1932            this.on("uiChange", this._uiChangeDrag);
1933            this.on("deactivate", this.onDeactivateDrag);
1934            this.on("cellChange", this.updateDraggable);
1935            this.on("pointerDown", this.handlePointerDown);
1936            this.on("pointerUp", this.handlePointerUp);
1937            this.on("pointerDown", this.handlePointerDone);
1938            this.on("dragStart", this.handleDragStart);
1939            this.on("dragMove", this.handleDragMove);
1940            this.on("dragEnd", this.handleDragEnd);
1941            this.on("staticClick", this.handleStaticClick);
1942          };
1943          proto.onActivateDrag = function() {
1944            this.handles = [this.viewport];
1945            this.bindHandles();
1946            this.updateDraggable();
1947          };
1948          proto.onDeactivateDrag = function() {
1949            this.unbindHandles();
1950            this.element.classList.remove("is-draggable");
1951          };
1952          proto.updateDraggable = function() {
1953            if (this.options.draggable === ">1") {
1954              this.isDraggable = this.slides.length > 1;
1955            } else {
1956              this.isDraggable = this.options.draggable;
1957            }
1958            this.element.classList.toggle("is-draggable", this.isDraggable);
1959          };
1960          proto._uiChangeDrag = function() {
1961            delete this.isFreeScrolling;
1962          };
1963          proto.handlePointerDown = function(event) {
1964            if (!this.isDraggable) {
1965              this.bindActivePointerEvents(event);
1966              return;
1967            }
1968            let isTouchStart = event.type === "touchstart";
1969            let isTouchPointer = event.pointerType === "touch";
1970            let isFocusNode = event.target.matches("input, textarea, select");
1971            if (!isTouchStart && !isTouchPointer && !isFocusNode) event.preventDefault();
1972            if (!isFocusNode) this.focus();
1973            if (document.activeElement !== this.element) document.activeElement.blur();
1974            this.dragX = this.x;
1975            this.viewport.classList.add("is-pointer-down");
1976            this.pointerDownScroll = getScrollPosition();
1977            window2.addEventListener("scroll", this);
1978            this.bindActivePointerEvents(event);
1979          };
1980          proto.hasDragStarted = function(moveVector) {
1981            return Math.abs(moveVector.x) > this.options.dragThreshold;
1982          };
1983          proto.handlePointerUp = function() {
1984            delete this.isTouchScrolling;
1985            this.viewport.classList.remove("is-pointer-down");
1986          };
1987          proto.handlePointerDone = function() {
1988            window2.removeEventListener("scroll", this);
1989            delete this.pointerDownScroll;
1990          };
1991          proto.handleDragStart = function() {
1992            if (!this.isDraggable) return;
1993            this.dragStartPosition = this.x;
1994            this.startAnimation();
1995            window2.removeEventListener("scroll", this);
1996          };
1997          proto.handleDragMove = function(event, pointer, moveVector) {
1998            if (!this.isDraggable) return;
1999            event.preventDefault();
2000            this.previousDragX = this.dragX;
2001            let direction = this.options.rightToLeft ? -1 : 1;
2002            if (this.isWrapping) moveVector.x %= this.slideableWidth;
2003            let dragX = this.dragStartPosition + moveVector.x * direction;
2004            if (!this.isWrapping) {
2005              let originBound = Math.max(-this.slides[0].target, this.dragStartPosition);
2006              dragX = dragX > originBound ? (dragX + originBound) * 0.5 : dragX;
2007              let endBound = Math.min(-this.getLastSlide().target, this.dragStartPosition);
2008              dragX = dragX < endBound ? (dragX + endBound) * 0.5 : dragX;
2009            }
2010            this.dragX = dragX;
2011            this.dragMoveTime = /* @__PURE__ */ new Date();
2012          };
2013          proto.handleDragEnd = function() {
2014            if (!this.isDraggable) return;
2015            let { freeScroll } = this.options;
2016            if (freeScroll) this.isFreeScrolling = true;
2017            let index = this.dragEndRestingSelect();
2018            if (freeScroll && !this.isWrapping) {
2019              let restingX = this.getRestingPosition();
2020              this.isFreeScrolling = -restingX > this.slides[0].target && -restingX < this.getLastSlide().target;
2021            } else if (!freeScroll && index === this.selectedIndex) {
2022              index += this.dragEndBoostSelect();
2023            }
2024            delete this.previousDragX;
2025            this.isDragSelect = this.isWrapping;
2026            this.select(index);
2027            delete this.isDragSelect;
2028          };
2029          proto.dragEndRestingSelect = function() {
2030            let restingX = this.getRestingPosition();
2031            let distance = Math.abs(this.getSlideDistance(-restingX, this.selectedIndex));
2032            let positiveResting = this._getClosestResting(restingX, distance, 1);
2033            let negativeResting = this._getClosestResting(restingX, distance, -1);
2034            return positiveResting.distance < negativeResting.distance ? positiveResting.index : negativeResting.index;
2035          };
2036          proto._getClosestResting = function(restingX, distance, increment) {
2037            let index = this.selectedIndex;
2038            let minDistance = Infinity;
2039            let condition = this.options.contain && !this.isWrapping ? (
2040              // if containing, keep going if distance is equal to minDistance
2041              (dist, minDist) => dist <= minDist
2042            ) : (dist, minDist) => dist < minDist;
2043            while (condition(distance, minDistance)) {
2044              index += increment;
2045              minDistance = distance;
2046              distance = this.getSlideDistance(-restingX, index);
2047              if (distance === null) break;
2048              distance = Math.abs(distance);
2049            }
2050            return {
2051              distance: minDistance,
2052              // selected was previous index
2053              index: index - increment
2054            };
2055          };
2056          proto.getSlideDistance = function(x, index) {
2057            let len = this.slides.length;
2058            let isWrapAround = this.options.wrapAround && len > 1;
2059            let slideIndex = isWrapAround ? utils2.modulo(index, len) : index;
2060            let slide2 = this.slides[slideIndex];
2061            if (!slide2) return null;
2062            let wrap2 = isWrapAround ? this.slideableWidth * Math.floor(index / len) : 0;
2063            return x - (slide2.target + wrap2);
2064          };
2065          proto.dragEndBoostSelect = function() {
2066            if (this.previousDragX === void 0 || !this.dragMoveTime || // or if drag was held for 100 ms
2067            /* @__PURE__ */ new Date() - this.dragMoveTime > 100) {
2068              return 0;
2069            }
2070            let distance = this.getSlideDistance(-this.dragX, this.selectedIndex);
2071            let delta = this.previousDragX - this.dragX;
2072            if (distance > 0 && delta > 0) {
2073              return 1;
2074            } else if (distance < 0 && delta < 0) {
2075              return -1;
2076            }
2077            return 0;
2078          };
2079          proto.onscroll = function() {
2080            let scroll = getScrollPosition();
2081            let scrollMoveX = this.pointerDownScroll.x - scroll.x;
2082            let scrollMoveY = this.pointerDownScroll.y - scroll.y;
2083            if (Math.abs(scrollMoveX) > 3 || Math.abs(scrollMoveY) > 3) {
2084              this.pointerDone();
2085            }
2086          };
2087          function getScrollPosition() {
2088            return {
2089              x: window2.pageXOffset,
2090              y: window2.pageYOffset
2091            };
2092          }
2093          return Flickity2;
2094        }
2095      );
2096    })(drag$1);
2097    return drag$1.exports;
2098  }
2099  var prevNextButton$1 = { exports: {} };
2100  var prevNextButton = prevNextButton$1.exports;
2101  var hasRequiredPrevNextButton;
2102  function requirePrevNextButton() {
2103    if (hasRequiredPrevNextButton) return prevNextButton$1.exports;
2104    hasRequiredPrevNextButton = 1;
2105    (function(module) {
2106      (function(window2, factory) {
2107        if (module.exports) {
2108          module.exports = factory(requireCore());
2109        } else {
2110          factory(window2.Flickity);
2111        }
2112      })(typeof window != "undefined" ? window : prevNextButton, function factory(Flickity2) {
2113        const svgURI = "http://www.w3.org/2000/svg";
2114        function PrevNextButton(increment, direction, arrowShape) {
2115          this.increment = increment;
2116          this.direction = direction;
2117          this.isPrevious = increment === "previous";
2118          this.isLeft = direction === "left";
2119          this._create(arrowShape);
2120        }
2121        PrevNextButton.prototype._create = function(arrowShape) {
2122          let element = this.element = document.createElement("button");
2123          element.className = `flickity-button flickity-prev-next-button ${this.increment}`;
2124          let label = this.isPrevious ? "Previous" : "Next";
2125          element.setAttribute("type", "button");
2126          element.setAttribute("aria-label", label);
2127          this.disable();
2128          let svg = this.createSVG(label, arrowShape);
2129          element.append(svg);
2130        };
2131        PrevNextButton.prototype.createSVG = function(label, arrowShape) {
2132          let svg = document.createElementNS(svgURI, "svg");
2133          svg.setAttribute("class", "flickity-button-icon");
2134          svg.setAttribute("viewBox", "0 0 100 100");
2135          let title = document.createElementNS(svgURI, "title");
2136          title.append(label);
2137          let path = document.createElementNS(svgURI, "path");
2138          let pathMovements = getArrowMovements(arrowShape);
2139          path.setAttribute("d", pathMovements);
2140          path.setAttribute("class", "arrow");
2141          if (!this.isLeft) {
2142            path.setAttribute("transform", "translate(100, 100) rotate(180)");
2143          }
2144          svg.append(title, path);
2145          return svg;
2146        };
2147        function getArrowMovements(shape) {
2148          if (typeof shape == "string") return shape;
2149          let { x0, x1, x2, x3, y1, y2 } = shape;
2150          return `M ${x0}, 50
2151    L ${x1}, ${y1 + 50}
2152    L ${x2}, ${y2 + 50}
2153    L ${x3}, 50
2154    L ${x2}, ${50 - y2}
2155    L ${x1}, ${50 - y1}
2156    Z`;
2157        }
2158        PrevNextButton.prototype.enable = function() {
2159          this.element.removeAttribute("disabled");
2160        };
2161        PrevNextButton.prototype.disable = function() {
2162          this.element.setAttribute("disabled", true);
2163        };
2164        Object.assign(Flickity2.defaults, {
2165          prevNextButtons: true,
2166          arrowShape: {
2167            x0: 10,
2168            x1: 60,
2169            y1: 50,
2170            x2: 70,
2171            y2: 40,
2172            x3: 30
2173          }
2174        });
2175        Flickity2.create.prevNextButtons = function() {
2176          if (!this.options.prevNextButtons) return;
2177          let { rightToLeft, arrowShape } = this.options;
2178          let prevDirection = rightToLeft ? "right" : "left";
2179          let nextDirection = rightToLeft ? "left" : "right";
2180          this.prevButton = new PrevNextButton("previous", prevDirection, arrowShape);
2181          this.nextButton = new PrevNextButton("next", nextDirection, arrowShape);
2182          this.focusableElems.push(this.prevButton.element);
2183          this.focusableElems.push(this.nextButton.element);
2184          this.handlePrevButtonClick = () => {
2185            this.uiChange();
2186            this.previous();
2187          };
2188          this.handleNextButtonClick = () => {
2189            this.uiChange();
2190            this.next();
2191          };
2192          this.on("activate", this.activatePrevNextButtons);
2193          this.on("select", this.updatePrevNextButtons);
2194        };
2195        let proto = Flickity2.prototype;
2196        proto.updatePrevNextButtons = function() {
2197          let lastIndex = this.slides.length ? this.slides.length - 1 : 0;
2198          this.updatePrevNextButton(this.prevButton, 0);
2199          this.updatePrevNextButton(this.nextButton, lastIndex);
2200        };
2201        proto.updatePrevNextButton = function(button, disabledIndex) {
2202          if (this.isWrapping && this.slides.length > 1) {
2203            button.enable();
2204            return;
2205          }
2206          let isEnabled = this.selectedIndex !== disabledIndex;
2207          button[isEnabled ? "enable" : "disable"]();
2208          let isDisabledFocused = !isEnabled && document.activeElement === button.element;
2209          if (isDisabledFocused) this.focus();
2210        };
2211        proto.activatePrevNextButtons = function() {
2212          this.prevButton.element.addEventListener("click", this.handlePrevButtonClick);
2213          this.nextButton.element.addEventListener("click", this.handleNextButtonClick);
2214          this.element.append(this.prevButton.element, this.nextButton.element);
2215          this.on("deactivate", this.deactivatePrevNextButtons);
2216        };
2217        proto.deactivatePrevNextButtons = function() {
2218          this.prevButton.element.remove();
2219          this.nextButton.element.remove();
2220          this.prevButton.element.removeEventListener("click", this.handlePrevButtonClick);
2221          this.nextButton.element.removeEventListener("click", this.handleNextButtonClick);
2222          this.off("deactivate", this.deactivatePrevNextButtons);
2223        };
2224        Flickity2.PrevNextButton = PrevNextButton;
2225        return Flickity2;
2226      });
2227    })(prevNextButton$1);
2228    return prevNextButton$1.exports;
2229  }
2230  var pageDots$1 = { exports: {} };
2231  var pageDots = pageDots$1.exports;
2232  var hasRequiredPageDots;
2233  function requirePageDots() {
2234    if (hasRequiredPageDots) return pageDots$1.exports;
2235    hasRequiredPageDots = 1;
2236    (function(module) {
2237      (function(window2, factory) {
2238        if (module.exports) {
2239          module.exports = factory(
2240            requireCore(),
2241            requireUtils()
2242          );
2243        } else {
2244          factory(
2245            window2.Flickity,
2246            window2.fizzyUIUtils
2247          );
2248        }
2249      })(typeof window != "undefined" ? window : pageDots, function factory(Flickity2, utils2) {
2250        function PageDots() {
2251          this.holder = document.createElement("div");
2252          this.holder.className = "flickity-page-dots";
2253          this.dots = [];
2254        }
2255        PageDots.prototype.setDots = function(slidesLength) {
2256          let delta = slidesLength - this.dots.length;
2257          if (delta > 0) {
2258            this.addDots(delta);
2259          } else if (delta < 0) {
2260            this.removeDots(-delta);
2261          }
2262        };
2263        PageDots.prototype.addDots = function(count) {
2264          let newDots = new Array(count).fill().map((item, i2) => {
2265            let dot = document.createElement("button");
2266            dot.setAttribute("type", "button");
2267            let num = i2 + 1 + this.dots.length;
2268            dot.className = "flickity-page-dot";
2269            dot.textContent = `View slide ${num}`;
2270            return dot;
2271          });
2272          this.holder.append(...newDots);
2273          this.dots = this.dots.concat(newDots);
2274        };
2275        PageDots.prototype.removeDots = function(count) {
2276          let removeDots = this.dots.splice(this.dots.length - count, count);
2277          removeDots.forEach((dot) => dot.remove());
2278        };
2279        PageDots.prototype.updateSelected = function(index) {
2280          if (this.selectedDot) {
2281            this.selectedDot.classList.remove("is-selected");
2282            this.selectedDot.removeAttribute("aria-current");
2283          }
2284          if (!this.dots.length) return;
2285          this.selectedDot = this.dots[index];
2286          this.selectedDot.classList.add("is-selected");
2287          this.selectedDot.setAttribute("aria-current", "step");
2288        };
2289        Flickity2.PageDots = PageDots;
2290        Object.assign(Flickity2.defaults, {
2291          pageDots: true
2292        });
2293        Flickity2.create.pageDots = function() {
2294          if (!this.options.pageDots) return;
2295          this.pageDots = new PageDots();
2296          this.handlePageDotsClick = this.onPageDotsClick.bind(this);
2297          this.on("activate", this.activatePageDots);
2298          this.on("select", this.updateSelectedPageDots);
2299          this.on("cellChange", this.updatePageDots);
2300          this.on("resize", this.updatePageDots);
2301          this.on("deactivate", this.deactivatePageDots);
2302        };
2303        let proto = Flickity2.prototype;
2304        proto.activatePageDots = function() {
2305          this.pageDots.setDots(this.slides.length);
2306          this.focusableElems.push(...this.pageDots.dots);
2307          this.pageDots.holder.addEventListener("click", this.handlePageDotsClick);
2308          this.element.append(this.pageDots.holder);
2309        };
2310        proto.onPageDotsClick = function(event) {
2311          let index = this.pageDots.dots.indexOf(event.target);
2312          if (index === -1) return;
2313          this.uiChange();
2314          this.select(index);
2315        };
2316        proto.updateSelectedPageDots = function() {
2317          this.pageDots.updateSelected(this.selectedIndex);
2318        };
2319        proto.updatePageDots = function() {
2320          this.pageDots.dots.forEach((dot) => {
2321            utils2.removeFrom(this.focusableElems, dot);
2322          });
2323          this.pageDots.setDots(this.slides.length);
2324          this.focusableElems.push(...this.pageDots.dots);
2325        };
2326        proto.deactivatePageDots = function() {
2327          this.pageDots.holder.remove();
2328          this.pageDots.holder.removeEventListener("click", this.handlePageDotsClick);
2329        };
2330        Flickity2.PageDots = PageDots;
2331        return Flickity2;
2332      });
2333    })(pageDots$1);
2334    return pageDots$1.exports;
2335  }
2336  var player$1 = { exports: {} };
2337  var player = player$1.exports;
2338  var hasRequiredPlayer;
2339  function requirePlayer() {
2340    if (hasRequiredPlayer) return player$1.exports;
2341    hasRequiredPlayer = 1;
2342    (function(module) {
2343      (function(window2, factory) {
2344        if (module.exports) {
2345          module.exports = factory(requireCore());
2346        } else {
2347          factory(window2.Flickity);
2348        }
2349      })(typeof window != "undefined" ? window : player, function factory(Flickity2) {
2350        function Player(autoPlay, onTick) {
2351          this.autoPlay = autoPlay;
2352          this.onTick = onTick;
2353          this.state = "stopped";
2354          this.onVisibilityChange = this.visibilityChange.bind(this);
2355          this.onVisibilityPlay = this.visibilityPlay.bind(this);
2356        }
2357        Player.prototype.play = function() {
2358          if (this.state === "playing") return;
2359          let isPageHidden = document.hidden;
2360          if (isPageHidden) {
2361            document.addEventListener("visibilitychange", this.onVisibilityPlay);
2362            return;
2363          }
2364          this.state = "playing";
2365          document.addEventListener("visibilitychange", this.onVisibilityChange);
2366          this.tick();
2367        };
2368        Player.prototype.tick = function() {
2369          if (this.state !== "playing") return;
2370          let time = typeof this.autoPlay == "number" ? this.autoPlay : 3e3;
2371          this.clear();
2372          this.timeout = setTimeout(() => {
2373            this.onTick();
2374            this.tick();
2375          }, time);
2376        };
2377        Player.prototype.stop = function() {
2378          this.state = "stopped";
2379          this.clear();
2380          document.removeEventListener("visibilitychange", this.onVisibilityChange);
2381        };
2382        Player.prototype.clear = function() {
2383          clearTimeout(this.timeout);
2384        };
2385        Player.prototype.pause = function() {
2386          if (this.state === "playing") {
2387            this.state = "paused";
2388            this.clear();
2389          }
2390        };
2391        Player.prototype.unpause = function() {
2392          if (this.state === "paused") this.play();
2393        };
2394        Player.prototype.visibilityChange = function() {
2395          let isPageHidden = document.hidden;
2396          this[isPageHidden ? "pause" : "unpause"]();
2397        };
2398        Player.prototype.visibilityPlay = function() {
2399          this.play();
2400          document.removeEventListener("visibilitychange", this.onVisibilityPlay);
2401        };
2402        Object.assign(Flickity2.defaults, {
2403          pauseAutoPlayOnHover: true
2404        });
2405        Flickity2.create.player = function() {
2406          this.player = new Player(this.options.autoPlay, () => {
2407            this.next(true);
2408          });
2409          this.on("activate", this.activatePlayer);
2410          this.on("uiChange", this.stopPlayer);
2411          this.on("pointerDown", this.stopPlayer);
2412          this.on("deactivate", this.deactivatePlayer);
2413        };
2414        let proto = Flickity2.prototype;
2415        proto.activatePlayer = function() {
2416          if (!this.options.autoPlay) return;
2417          this.player.play();
2418          this.element.addEventListener("mouseenter", this);
2419        };
2420        proto.playPlayer = function() {
2421          this.player.play();
2422        };
2423        proto.stopPlayer = function() {
2424          this.player.stop();
2425        };
2426        proto.pausePlayer = function() {
2427          this.player.pause();
2428        };
2429        proto.unpausePlayer = function() {
2430          this.player.unpause();
2431        };
2432        proto.deactivatePlayer = function() {
2433          this.player.stop();
2434          this.element.removeEventListener("mouseenter", this);
2435        };
2436        proto.onmouseenter = function() {
2437          if (!this.options.pauseAutoPlayOnHover) return;
2438          this.player.pause();
2439          this.element.addEventListener("mouseleave", this);
2440        };
2441        proto.onmouseleave = function() {
2442          this.player.unpause();
2443          this.element.removeEventListener("mouseleave", this);
2444        };
2445        Flickity2.Player = Player;
2446        return Flickity2;
2447      });
2448    })(player$1);
2449    return player$1.exports;
2450  }
2451  var addRemoveCell$1 = { exports: {} };
2452  var addRemoveCell = addRemoveCell$1.exports;
2453  var hasRequiredAddRemoveCell;
2454  function requireAddRemoveCell() {
2455    if (hasRequiredAddRemoveCell) return addRemoveCell$1.exports;
2456    hasRequiredAddRemoveCell = 1;
2457    (function(module) {
2458      (function(window2, factory) {
2459        if (module.exports) {
2460          module.exports = factory(
2461            requireCore(),
2462            requireUtils()
2463          );
2464        } else {
2465          factory(
2466            window2.Flickity,
2467            window2.fizzyUIUtils
2468          );
2469        }
2470      })(typeof window != "undefined" ? window : addRemoveCell, function factory(Flickity2, utils2) {
2471        function getCellsFragment(cells) {
2472          let fragment = document.createDocumentFragment();
2473          cells.forEach((cell2) => fragment.appendChild(cell2.element));
2474          return fragment;
2475        }
2476        let proto = Flickity2.prototype;
2477        proto.insert = function(elems, index) {
2478          let cells = this._makeCells(elems);
2479          if (!cells || !cells.length) return;
2480          let len = this.cells.length;
2481          index = index === void 0 ? len : index;
2482          let fragment = getCellsFragment(cells);
2483          let isAppend = index === len;
2484          if (isAppend) {
2485            this.slider.appendChild(fragment);
2486          } else {
2487            let insertCellElement = this.cells[index].element;
2488            this.slider.insertBefore(fragment, insertCellElement);
2489          }
2490          if (index === 0) {
2491            this.cells = cells.concat(this.cells);
2492          } else if (isAppend) {
2493            this.cells = this.cells.concat(cells);
2494          } else {
2495            let endCells = this.cells.splice(index, len - index);
2496            this.cells = this.cells.concat(cells).concat(endCells);
2497          }
2498          this._sizeCells(cells);
2499          this.cellChange(index);
2500          this.positionSliderAtSelected();
2501        };
2502        proto.append = function(elems) {
2503          this.insert(elems, this.cells.length);
2504        };
2505        proto.prepend = function(elems) {
2506          this.insert(elems, 0);
2507        };
2508        proto.remove = function(elems) {
2509          let cells = this.getCells(elems);
2510          if (!cells || !cells.length) return;
2511          let minCellIndex = this.cells.length - 1;
2512          cells.forEach((cell2) => {
2513            cell2.remove();
2514            let index = this.cells.indexOf(cell2);
2515            minCellIndex = Math.min(index, minCellIndex);
2516            utils2.removeFrom(this.cells, cell2);
2517          });
2518          this.cellChange(minCellIndex);
2519          this.positionSliderAtSelected();
2520        };
2521        proto.cellSizeChange = function(elem) {
2522          let cell2 = this.getCell(elem);
2523          if (!cell2) return;
2524          cell2.getSize();
2525          let index = this.cells.indexOf(cell2);
2526          this.cellChange(index);
2527        };
2528        proto.cellChange = function(changedCellIndex) {
2529          let prevSelectedElem = this.selectedElement;
2530          this._positionCells(changedCellIndex);
2531          this._updateWrapShiftCells();
2532          this.setGallerySize();
2533          let cell2 = this.getCell(prevSelectedElem);
2534          if (cell2) this.selectedIndex = this.getCellSlideIndex(cell2);
2535          this.selectedIndex = Math.min(this.slides.length - 1, this.selectedIndex);
2536          this.emitEvent("cellChange", [changedCellIndex]);
2537          this.select(this.selectedIndex);
2538        };
2539        return Flickity2;
2540      });
2541    })(addRemoveCell$1);
2542    return addRemoveCell$1.exports;
2543  }
2544  var lazyload$1 = { exports: {} };
2545  var lazyload = lazyload$1.exports;
2546  var hasRequiredLazyload;
2547  function requireLazyload() {
2548    if (hasRequiredLazyload) return lazyload$1.exports;
2549    hasRequiredLazyload = 1;
2550    (function(module) {
2551      (function(window2, factory) {
2552        if (module.exports) {
2553          module.exports = factory(
2554            requireCore(),
2555            requireUtils()
2556          );
2557        } else {
2558          factory(
2559            window2.Flickity,
2560            window2.fizzyUIUtils
2561          );
2562        }
2563      })(typeof window != "undefined" ? window : lazyload, function factory(Flickity2, utils2) {
2564        const lazyAttr = "data-flickity-lazyload";
2565        const lazySrcAttr = `${lazyAttr}-src`;
2566        const lazySrcsetAttr = `${lazyAttr}-srcset`;
2567        const imgSelector = `img[${lazyAttr}], img[${lazySrcAttr}], img[${lazySrcsetAttr}], source[${lazySrcsetAttr}]`;
2568        Flickity2.create.lazyLoad = function() {
2569          this.on("select", this.lazyLoad);
2570          this.handleLazyLoadComplete = this.onLazyLoadComplete.bind(this);
2571        };
2572        let proto = Flickity2.prototype;
2573        proto.lazyLoad = function() {
2574          let { lazyLoad } = this.options;
2575          if (!lazyLoad) return;
2576          let adjCount = typeof lazyLoad == "number" ? lazyLoad : 0;
2577          this.getAdjacentCellElements(adjCount).map(getCellLazyImages).flat().forEach((img) => new LazyLoader(img, this.handleLazyLoadComplete));
2578        };
2579        function getCellLazyImages(cellElem) {
2580          if (cellElem.matches("img")) {
2581            let cellAttr = cellElem.getAttribute(lazyAttr);
2582            let cellSrcAttr = cellElem.getAttribute(lazySrcAttr);
2583            let cellSrcsetAttr = cellElem.getAttribute(lazySrcsetAttr);
2584            if (cellAttr || cellSrcAttr || cellSrcsetAttr) {
2585              return cellElem;
2586            }
2587          }
2588          return [...cellElem.querySelectorAll(imgSelector)];
2589        }
2590        proto.onLazyLoadComplete = function(img, event) {
2591          let cell2 = this.getParentCell(img);
2592          let cellElem = cell2 && cell2.element;
2593          this.cellSizeChange(cellElem);
2594          this.dispatchEvent("lazyLoad", event, cellElem);
2595        };
2596        function LazyLoader(img, onComplete) {
2597          this.img = img;
2598          this.onComplete = onComplete;
2599          this.load();
2600        }
2601        LazyLoader.prototype.handleEvent = utils2.handleEvent;
2602        LazyLoader.prototype.load = function() {
2603          this.img.addEventListener("load", this);
2604          this.img.addEventListener("error", this);
2605          let src = this.img.getAttribute(lazyAttr) || this.img.getAttribute(lazySrcAttr);
2606          let srcset = this.img.getAttribute(lazySrcsetAttr);
2607          this.img.src = src;
2608          if (srcset) this.img.setAttribute("srcset", srcset);
2609          this.img.removeAttribute(lazyAttr);
2610          this.img.removeAttribute(lazySrcAttr);
2611          this.img.removeAttribute(lazySrcsetAttr);
2612        };
2613        LazyLoader.prototype.onload = function(event) {
2614          this.complete(event, "flickity-lazyloaded");
2615        };
2616        LazyLoader.prototype.onerror = function(event) {
2617          this.complete(event, "flickity-lazyerror");
2618        };
2619        LazyLoader.prototype.complete = function(event, className) {
2620          this.img.removeEventListener("load", this);
2621          this.img.removeEventListener("error", this);
2622          let mediaElem = this.img.parentNode.matches("picture") ? this.img.parentNode : this.img;
2623          mediaElem.classList.add(className);
2624          this.onComplete(this.img, event);
2625        };
2626        Flickity2.LazyLoader = LazyLoader;
2627        return Flickity2;
2628      });
2629    })(lazyload$1);
2630    return lazyload$1.exports;
2631  }
2632  var imagesloaded$3 = { exports: {} };
2633  var imagesloaded$2 = { exports: {} };
2634  /*!
2635   * imagesLoaded v5.0.0
2636   * JavaScript is all like "You images are done yet or what?"
2637   * MIT License
2638   */
2639  var imagesloaded$1 = imagesloaded$2.exports;
2640  var hasRequiredImagesloaded$1;
2641  function requireImagesloaded$1() {
2642    if (hasRequiredImagesloaded$1) return imagesloaded$2.exports;
2643    hasRequiredImagesloaded$1 = 1;
2644    (function(module) {
2645      (function(window2, factory) {
2646        if (module.exports) {
2647          module.exports = factory(window2, requireEvEmitter());
2648        } else {
2649          window2.imagesLoaded = factory(window2, window2.EvEmitter);
2650        }
2651      })(
2652        typeof window !== "undefined" ? window : imagesloaded$1,
2653        function factory(window2, EvEmitter) {
2654          let $ = window2.jQuery;
2655          let console2 = window2.console;
2656          function makeArray(obj) {
2657            if (Array.isArray(obj)) return obj;
2658            let isArrayLike = typeof obj == "object" && typeof obj.length == "number";
2659            if (isArrayLike) return [...obj];
2660            return [obj];
2661          }
2662          function ImagesLoaded(elem, options, onAlways) {
2663            if (!(this instanceof ImagesLoaded)) {
2664              return new ImagesLoaded(elem, options, onAlways);
2665            }
2666            let queryElem = elem;
2667            if (typeof elem == "string") {
2668              queryElem = document.querySelectorAll(elem);
2669            }
2670            if (!queryElem) {
2671              console2.error(`Bad element for imagesLoaded ${queryElem || elem}`);
2672              return;
2673            }
2674            this.elements = makeArray(queryElem);
2675            this.options = {};
2676            if (typeof options == "function") {
2677              onAlways = options;
2678            } else {
2679              Object.assign(this.options, options);
2680            }
2681            if (onAlways) this.on("always", onAlways);
2682            this.getImages();
2683            if ($) this.jqDeferred = new $.Deferred();
2684            setTimeout(this.check.bind(this));
2685          }
2686          ImagesLoaded.prototype = Object.create(EvEmitter.prototype);
2687          ImagesLoaded.prototype.getImages = function() {
2688            this.images = [];
2689            this.elements.forEach(this.addElementImages, this);
2690          };
2691          const elementNodeTypes = [1, 9, 11];
2692          ImagesLoaded.prototype.addElementImages = function(elem) {
2693            if (elem.nodeName === "IMG") {
2694              this.addImage(elem);
2695            }
2696            if (this.options.background === true) {
2697              this.addElementBackgroundImages(elem);
2698            }
2699            let { nodeType } = elem;
2700            if (!nodeType || !elementNodeTypes.includes(nodeType)) return;
2701            let childImgs = elem.querySelectorAll("img");
2702            for (let img of childImgs) {
2703              this.addImage(img);
2704            }
2705            if (typeof this.options.background == "string") {
2706              let children = elem.querySelectorAll(this.options.background);
2707              for (let child of children) {
2708                this.addElementBackgroundImages(child);
2709              }
2710            }
2711          };
2712          const reURL = /url\((['"])?(.*?)\1\)/gi;
2713          ImagesLoaded.prototype.addElementBackgroundImages = function(elem) {
2714            let style = getComputedStyle(elem);
2715            if (!style) return;
2716            let matches = reURL.exec(style.backgroundImage);
2717            while (matches !== null) {
2718              let url = matches && matches[2];
2719              if (url) {
2720                this.addBackground(url, elem);
2721              }
2722              matches = reURL.exec(style.backgroundImage);
2723            }
2724          };
2725          ImagesLoaded.prototype.addImage = function(img) {
2726            let loadingImage = new LoadingImage(img);
2727            this.images.push(loadingImage);
2728          };
2729          ImagesLoaded.prototype.addBackground = function(url, elem) {
2730            let background = new Background(url, elem);
2731            this.images.push(background);
2732          };
2733          ImagesLoaded.prototype.check = function() {
2734            this.progressedCount = 0;
2735            this.hasAnyBroken = false;
2736            if (!this.images.length) {
2737              this.complete();
2738              return;
2739            }
2740            let onProgress = (image, elem, message) => {
2741              setTimeout(() => {
2742                this.progress(image, elem, message);
2743              });
2744            };
2745            this.images.forEach(function(loadingImage) {
2746              loadingImage.once("progress", onProgress);
2747              loadingImage.check();
2748            });
2749          };
2750          ImagesLoaded.prototype.progress = function(image, elem, message) {
2751            this.progressedCount++;
2752            this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded;
2753            this.emitEvent("progress", [this, image, elem]);
2754            if (this.jqDeferred && this.jqDeferred.notify) {
2755              this.jqDeferred.notify(this, image);
2756            }
2757            if (this.progressedCount === this.images.length) {
2758              this.complete();
2759            }
2760            if (this.options.debug && console2) {
2761              console2.log(`progress: ${message}`, image, elem);
2762            }
2763          };
2764          ImagesLoaded.prototype.complete = function() {
2765            let eventName = this.hasAnyBroken ? "fail" : "done";
2766            this.isComplete = true;
2767            this.emitEvent(eventName, [this]);
2768            this.emitEvent("always", [this]);
2769            if (this.jqDeferred) {
2770              let jqMethod = this.hasAnyBroken ? "reject" : "resolve";
2771              this.jqDeferred[jqMethod](this);
2772            }
2773          };
2774          function LoadingImage(img) {
2775            this.img = img;
2776          }
2777          LoadingImage.prototype = Object.create(EvEmitter.prototype);
2778          LoadingImage.prototype.check = function() {
2779            let isComplete = this.getIsImageComplete();
2780            if (isComplete) {
2781              this.confirm(this.img.naturalWidth !== 0, "naturalWidth");
2782              return;
2783            }
2784            this.proxyImage = new Image();
2785            if (this.img.crossOrigin) {
2786              this.proxyImage.crossOrigin = this.img.crossOrigin;
2787            }
2788            this.proxyImage.addEventListener("load", this);
2789            this.proxyImage.addEventListener("error", this);
2790            this.img.addEventListener("load", this);
2791            this.img.addEventListener("error", this);
2792            this.proxyImage.src = this.img.currentSrc || this.img.src;
2793          };
2794          LoadingImage.prototype.getIsImageComplete = function() {