@figurosity/consumer-pose-generator 0.1.0

package/dist/consumer-pose-generator.js

@@ -0,0 +1,4998 @@
+import { ref as j, computed as y, watch as Ne, onBeforeMount as To, defineComponent as T, h, openBlock as O, createBlock as _t, unref as A, createElementBlock as $, Fragment as Xe, renderList as Ze, createVNode as B, normalizeClass as mt, createElementVNode as De, toDisplayString as Co, onMounted as bt, onBeforeUnmount as Jt, Transition as qt, withDirectives as vt, vShow as yt, normalizeStyle as nn, TransitionGroup as _o, withCtx as jt, inject as bo } from "vue";
+import { useRoute as Io } from "vue-router";
+import { defineStore as ie, getActivePinia as Po, storeToRefs as S } from "pinia";
+import { useDynamicImages as xo, DEFAULT as Me, SKINS as Gt, DURATION as Yt, NOTHING as wo, EFFECTS as St, CAMERA_ANGLE as Ps, LIGHT_DIRECTION as xs, GENDER as Tt, GRID as ws, POSE_DIRECTION as Ds, ADJUSTMENTS as Ms, slugify as Do, useEventBus as on, useFilterStyle as Mo, FlipAnimation as Ao, useWakeLock as No } from "@figurosity/toolbox";
+import rn from "lodash-es/debounce";
+import { useQuasar as It, QSlider as Oo, QSeparator as J, QCard as ko, QItem as Lo, QItemSection as As, QIcon as Vo, QItemLabel as Ns, QCardSection as Uo, QBtn as Oe, QPageSticky as Ro, QCircularProgress as Bo } from "quasar";
+import { CExpansion as me, CBaseButton as Qe, CBaseButtons as an, CNewGridTool as $o, CBasicTool as es, CAnimatedNumber as zo, CGridOverlay as Ho, CFloatingModal as Fo, CDraggableDrawer as ln, CDraggableDrawers as qo } from "@figurosity/consumer-controls";
+import { historyCircle as cn, contrast as un, brightness as dn, shirt as jo, cameraAngle as Go, bulbLight as Yo, venus as Wo, cameraOrientation as Xo, grid as Zo, refresh as Qo, pause as Ko, play as Jo } from "@figurosity/icons";
+function er(e, t) {
+  for (var s = 0; s < t.length; s++) {
+    const n = t[s];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const r in n)
+        if (r !== "default" && !(r in e)) {
+          const a = Object.getOwnPropertyDescriptor(n, r);
+          a && Object.defineProperty(e, r, a.get ? a : {
+            enumerable: !0,
+            get: () => n[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+const tr = {
+  models: {},
+  collection: [],
+  slugs: {},
+  selected: [],
+  playSelected: 1
+}, hn = {
+  random(e) {
+    var s;
+    if (!e.selected) return 1;
+    const t = ((s = e.selected) == null ? void 0 : s.length) || 1;
+    return e.selected[Math.floor(Math.random() * t)];
+  },
+  collectedModels(e) {
+    return e.collection.length > 0 ? e.collection.map((t) => e.models[t]) : [];
+  },
+  propertyById: (e) => (t, s, n = null) => e.models[t] && s in e.models[t] ? e.models[t][s] : n
+}, pn = {
+  getRandom(e) {
+    if (!this.selected) return;
+    const t = new Set(e), s = [...new Set(this.selected.filter((n) => t.has(n)))];
+    if (s.length !== 0)
+      return s[Math.floor(Math.random() * s.length)];
+  },
+  setPropertyById(e, t, s) {
+    this.models[e] || this.initModel(e), this.$patch({
+      models: {
+        [e]: {
+          ...this.models[e],
+          // Spread existing properties
+          [t]: s
+          // Update the specific property
+        }
+      }
+    });
+  },
+  /**
+   * Set the state models and collection
+   * @param {*} entities
+   * @returns
+   */
+  setState(e) {
+    if (!e || !e) return;
+    this.collection && (this.collection = Object.keys(e).sort((s, n) => e[s].order - e[n].order).map((s) => parseInt(s, 10)));
+    const t = {};
+    Object.keys(e).forEach((s) => {
+      const n = e[s];
+      n.slug && (t[n.slug] = n.id);
+    }), this.$patch((s) => {
+      s.models = Object.assign({}, s.models, e), s.slugs = Object.assign({}, s.slugs, t);
+    });
+  },
+  toggleSelected(e) {
+    const t = [...this.selected];
+    if (t.includes(e)) {
+      if (t.length <= 1) return;
+      this.$patch({ selected: t.filter((s) => s !== e).sort() });
+      return;
+    }
+    t.push(e), this.$patch({ selected: t.sort() });
+  },
+  setSelected(e) {
+    this.$patch((t) => {
+      t.selected = e;
+    });
+  },
+  customReset() {
+    const e = [...Object.keys(this.models).map((t) => this.models[t].id)];
+    this.$patch({
+      selected: e
+    });
+  }
+}, ke = ({
+  storeId: e,
+  state: t = {},
+  getters: s = {},
+  actions: n = {}
+}) => ie(e, {
+  state: () => ({
+    ...tr,
+    ...t
+  }),
+  getters: {
+    ...hn,
+    ...s
+  },
+  actions: {
+    ...pn,
+    ...n
+  }
+});
+function Le(e) {
+  return e.length ? typeof Intl < "u" && Intl.ListFormat ? new Intl.ListFormat("en-GB", {
+    style: "long",
+    type: "conjunction"
+  }).format(e) : e.length === 1 ? e[0] : e.length === 2 ? `${e[0]} and ${e[1]}` : `${e.slice(0, -1).join(", ")} and ${e[e.length - 1]}` : "";
+}
+const sr = {}, nr = {
+  src(e) {
+    return (t) => {
+      const s = this.propertyById(t, "slug");
+      if (s)
+        return `undefined/pose-generator/camera-angles/camera-${s}.webp`;
+    };
+  },
+  caption(e) {
+    return Le(e.selected.map((t) => e.models[t].name));
+  }
+}, or = {}, pe = ke({
+  storeId: "pg-cameras",
+  state: sr,
+  getters: nr,
+  actions: or
+}), je = 100, Ge = 100, Ye = 100, ge = ie("pg-adjustments", {
+  state: () => ({
+    brightness: je,
+    contrast: Ge,
+    saturate: Ye
+  }),
+  getters: {
+    brightnessChanged: (e) => e.brightness !== je,
+    contrastChanged: (e) => e.contrast !== Ge,
+    saturateChanged: (e) => e.saturate !== Ye,
+    changed(e) {
+      return this.brightnessChanged || this.contrastChanged || this.saturateChanged;
+    },
+    caption(e) {
+      const t = [];
+      return e.brightness !== je && t.push("Brightness"), e.contrast !== Ge && t.push("Contrast"), e.saturate !== Ye && t.push("Saturation"), t.length === 0 && t.push("None"), Le(t);
+    }
+  },
+  actions: {
+    setValues(e) {
+      if (!e)
+        throw new Error(this.$id + " result must not be null");
+      this.$patch({
+        brightness: e.brightness || je,
+        contrast: e.contrast || Ge,
+        saturate: e.saturate || Ye
+      });
+    },
+    setBrightness(e) {
+      this.$patch({ brightness: e });
+    },
+    setContrast(e) {
+      this.$patch({ contrast: e });
+    },
+    setSaturate(e) {
+      this.$patch({ saturate: e });
+    },
+    resetBrightness() {
+      this.$patch({ brightness: je });
+    },
+    resetContrast() {
+      this.$patch({ contrast: Ge });
+    },
+    resetSaturate() {
+      this.$patch({ saturate: Ye });
+    },
+    customReset() {
+      this.$reset();
+    }
+  }
+}), { setSelected: rr } = pn;
+function Os(e, t = !0) {
+  if (!e) return t ? "0s" : "0 seconds";
+  const s = e === 1 ? "second" : "seconds";
+  if (e < 60)
+    return t ? `${e}s` : `${e} ${s}`;
+  const n = e / 60;
+  return t ? `${n}m` : `${n} ${n === 1 ? "minute" : "minutes"}`;
+}
+const Z = ie("pg-durations", {
+  state: () => ({
+    models: {},
+    collection: [],
+    slugs: {},
+    selected: 0
+  }),
+  getters: {
+    changed: (e) => e.selected !== 2,
+    seconds: (e) => {
+      const t = e.models[e.selected];
+      return t ? t.seconds : 0;
+    },
+    duration: (e) => {
+      const t = e.models[e.selected];
+      return t ? t.seconds : 0;
+    },
+    index(e) {
+      const t = e.selected;
+      return e.collection.findIndex((s) => String(s) === String(t));
+    },
+    title(e) {
+      return Os(e.duration, !1);
+    },
+    values(e) {
+      const t = e.models;
+      return e.collection.map((n, r) => ({
+        value: r,
+        label: Os(t[n].seconds)
+      })) || [];
+    },
+    ...hn
+  },
+  actions: {
+    customReset() {
+      this.$patch({
+        selected: 2
+      });
+    },
+    setSelectedByIndex(e) {
+      const t = this.models[this.collection[e]];
+      this.$patch((s) => {
+        s.selected = t.id;
+      });
+    },
+    setSelected: rr,
+    setState(e) {
+      if (!e)
+        throw new Error(this.$id + " entities must not be null");
+      this.collection && (this.collection = Object.entries(e).sort(([, s], [, n]) => Number(s.seconds) - Number(n.seconds)).map(([s]) => Number(s)));
+      const t = {};
+      Object.keys(e).forEach((s) => {
+        const n = e[s];
+        n.slug && (t[n.slug] = n.id);
+      }), this.$patch((s) => {
+        s.models = Object.assign({}, s.models, e), s.slugs = Object.assign({}, s.slugs, t);
+      });
+    }
+  }
+}), ir = void 0, ar = void 0;
+function Ke() {
+  return xo({ freeServer: ir, paidServer: ar });
+}
+const lr = {
+  uuid: void 0,
+  playSelected: 1
+}, cr = {
+  src(e) {
+    return (t) => {
+      const { getThumbnail: s } = Ke();
+      return s({ uuid: e.uuid, image: t });
+    };
+  },
+  caption(e) {
+    return Le(e.selected.map((t) => e.models[t].name));
+  },
+  playCaption(e) {
+    var t, s;
+    return ((s = (t = e.models) == null ? void 0 : t[e.playSelected]) == null ? void 0 : s.name) || "Normal";
+  }
+}, ur = {
+  getSrc(e, t) {
+    const { getThumbnail: s } = Ke();
+    return t = t || this.uuid, s({ uuid: t, image: e });
+  },
+  getModelsByIds(e = []) {
+    return e.map((t) => this.models[t]) || [];
+  },
+  getAccessKey(e) {
+    return this.appSkinsStore.accessKeys[e];
+  },
+  getSlugById(e) {
+    return this.propertyById(e, "slug", "normal");
+  },
+  customReset() {
+    const e = this.appAuthStore, t = k();
+    if (e && e.authenticated) {
+      const s = this.collection.filter(
+        (n) => !t.censored.includes(n)
+      );
+      this.$patch({
+        selected: s
+      });
+      return;
+    }
+    this.$patch({
+      selected: [1]
+    });
+  }
+}, V = ke({
+  storeId: "pg-skins",
+  state: lr,
+  getters: cr,
+  actions: ur
+}), dr = {
+  selected: 1,
+  playSelected: 1
+}, hr = {
+  src(e) {
+    return (t = "none") => {
+      const { getThumbnail: s } = Ke(), n = t === "negative" ? "000000" : "ffffff", r = V();
+      return s({
+        uuid: r.uuid,
+        image: "nude",
+        effect: t,
+        color: n
+      });
+    };
+  },
+  srcById(e) {
+    return (t) => {
+      const s = e.models[t];
+      if (s)
+        return this.src(s.slug);
+    };
+  },
+  slug(e) {
+    return (t) => {
+      const s = e.models[t];
+      if (s)
+        return s.slug;
+    };
+  },
+  caption(e) {
+    var t, s;
+    return ((s = (t = e.models) == null ? void 0 : t[e.selected]) == null ? void 0 : s.name) || "None";
+  },
+  playCaption(e) {
+    var t, s;
+    return ((s = (t = e.models) == null ? void 0 : t[e.playSelected]) == null ? void 0 : s.name) || "None";
+  },
+  name(e) {
+    return (t) => {
+      const s = e.models[t];
+      if (s)
+        return s.name;
+    };
+  }
+}, pr = {
+  setSelected(e, t = !1) {
+    if (t) {
+      this.$patch((s) => {
+        s.playSelected = e;
+      });
+      return;
+    }
+    this.$patch((s) => {
+      s.selected = e, s.playSelected = e;
+    });
+  },
+  getSlugById(e) {
+    return this.propertyById(e, "slug", "normal");
+  },
+  customReset() {
+    this.$patch({
+      selected: 1
+    });
+  }
+}, R = ke({
+  storeId: "pg-effects",
+  state: dr,
+  getters: hr,
+  actions: pr
+}), fr = {}, gr = {
+  caption(e) {
+    return Le(e.selected.map((t) => e.models[t].name));
+  }
+}, mr = {}, re = ke({
+  storeId: "pg-genders",
+  state: fr,
+  getters: gr,
+  actions: mr
+}), ks = 0, Ls = 20, Vs = 0, vr = !1, Ie = ie("pg-grid", {
+  state: () => ({
+    visible: vr,
+    spacing: Ls,
+    horizontal: ks,
+    vertical: Vs
+  }),
+  getters: {
+    changed: (e) => e.visible === !0,
+    caption(e) {
+      return e.visible ? "On" : "Off";
+    }
+  },
+  actions: {
+    setValues(e) {
+      if (!e)
+        throw new Error(this.$id + " result must not be null");
+      this.$patch({
+        visible: e.visible === 1,
+        spacing: e.spacing || Ls,
+        horizontal: e.horizontal || ks,
+        vertical: e.vertical || Vs
+      });
+    },
+    customReset() {
+      this.$reset();
+    },
+    hide() {
+      this.$patch({
+        visible: !1
+      });
+    },
+    show() {
+      this.$patch({
+        visible: !0
+      });
+    },
+    setSpacing(e) {
+      this.$patch({
+        spacing: e
+      });
+    },
+    setHorizontal(e) {
+      this.$patch({
+        horizontal: e
+      });
+    },
+    setVertical(e) {
+      this.$patch({
+        vertical: e
+      });
+    }
+  }
+}), yr = {}, Er = {
+  src(e) {
+    return (t) => {
+      const s = this.propertyById(t, "slug");
+      return s ? `undefined/pose-generator/light-direction/from-${s}.webp` : void 0;
+    };
+  },
+  caption(e) {
+    return Le(e.selected.map((t) => e.models[t].name));
+  }
+}, Sr = {}, ee = ke({
+  storeId: "pg-lights",
+  state: yr,
+  getters: Er,
+  actions: Sr
+});
+function Tr(e) {
+  return function() {
+    e = e + 1831565813 >>> 0;
+    let t = Math.imul(e ^ e >>> 15, e | 1);
+    return t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function Cr(e, t) {
+  const s = e.slice(), n = Tr(t ?? Date.now() & 4294967295);
+  for (let r = s.length - 1; r > 0; r--) {
+    const a = Math.floor(n() * (r + 1));
+    [s[r], s[a]] = [s[a], s[r]];
+  }
+  return s;
+}
+const Pe = ie("pg-poses", {
+  state: () => ({
+    models: /* @__PURE__ */ Object.create(null),
+    // { [id]: poseRow }
+    collection: [],
+    // sorted list of collection in the pool
+    seen: /* @__PURE__ */ new Set(),
+    // collection already shown
+    seed: Date.now() & 4294967295,
+    count: 0,
+    loading: !1
+    // guard concurrent fetches
+  }),
+  getters: {
+    // convenience getter
+    unseenIds(e) {
+      const s = k().filterData;
+      return e.collection.filter((n) => !e.seen.has(n)).filter((n) => this.candidates(s).includes(n));
+    },
+    unseenCount() {
+      return this.unseenIds.length;
+    }
+  },
+  actions: {
+    getModelById(e) {
+      return this.models[e] || null;
+    },
+    setCount(e) {
+      this.$patch({ count: e });
+    },
+    // payload shape: { entities: { poses: { [id]: {...} } } }
+    ingestNormalized(e) {
+      e = e || {}, this.models = { ...e, ...this.models };
+      for (const s of Object.keys(e)) {
+        const n = this.models[s];
+        n.skin_ids = Array.isArray(n.skin_ids) ? n.skin_ids : [], n.camera_id = n.camera_id || Number(n.camera_id), n.gender_ids = Array.isArray(n.gender_ids) ? n.gender_ids : [], n._skinSet = new Set(n.skin_ids), n._gendSet = new Set(n.gender_ids);
+      }
+      const t = new Set(this.collection);
+      for (const s of Object.keys(e)) t.add(+s);
+      this.collection = Array.from(t).sort((s, n) => s - n);
+    },
+    // build candidate collection: OR within a facet, AND across facets
+    candidates(e = {}) {
+      const t = new Set(e.skins || []), s = new Set(e.cameras || []), n = new Set(e.genders || []), r = [];
+      for (let a = 0; a < this.collection.length; a++) {
+        const c = this.collection[a], d = this.models[c];
+        if (!d) continue;
+        const u = !t.size || [...t].some((v) => d._skinSet.has(v)), f = !s.size || d.camera_id != null && s.has(d.camera_id), g = !n.size || [...n].some((v) => d._gendSet.has(v));
+        u && f && g && r.push(c);
+      }
+      return r;
+    },
+    // get n random collection that haven’t been shown yet
+    randomTake(e, t = {}) {
+      var a;
+      const n = ((a = this.candidates) == null ? void 0 : a.call(this, t)).filter((c) => !this.seen.has(c));
+      return n.length ? Cr(n, this.seed).slice(0, e) : [];
+    },
+    async addToSeen(e) {
+      this.seen.add(parseInt(e)), await this.ensureUnseen({ minUnseen: 25 });
+    },
+    rowsFromIds(e) {
+      return e.map((t) => this.models[t]).filter(Boolean);
+    },
+    resetSeen() {
+      this.seen.clear();
+    },
+    reseed(e) {
+      this.seed = e ?? Date.now() & 4294967295;
+    },
+    async ensureUnseen({ minUnseen: e = 50, batch: t = 200 } = {}) {
+      const s = k();
+      if (s.filterData, this.unseenCount >= e || this.loading) return;
+      await (async () => {
+        try {
+          this.loading = !0, this.seen.size >= Math.floor(s.totalCount / 100) * 100 && (console.log("resetting seed"), this.reseed(), this.resetSeen()), this.appPoseGeneratorStore.fetch({}).then((r) => {
+            var a;
+            this.ingestNormalized((a = r == null ? void 0 : r.entities) == null ? void 0 : a.poses);
+          }).catch((r) => {
+            console.log(r);
+          });
+        } catch (r) {
+          console.error("ensureUnseen fetch failed", r);
+        } finally {
+          this.loading = !1;
+        }
+      })();
+    }
+  }
+}), _r = {}, br = {
+  caption(e) {
+    return Le(e.selected.map((t) => e.models[t].name));
+  }
+}, Ir = {
+  getRandom(e) {
+    const s = (c) => (c % 36 + 36) % 36, n = {
+      1: [[-4, 4]],
+      // front
+      2: [[5, 13]],
+      // right
+      3: [[14, 22]],
+      // back
+      4: [[23, 31]]
+      // left
+    }, r = [];
+    for (const c of this.selected) {
+      const d = n[c];
+      if (d)
+        for (const [u, f] of d)
+          for (let g = u; g <= f; g++)
+            r.push(s(e + g));
+    }
+    if (r.length === 0)
+      throw new Error("No valid frames for given positions.");
+    const a = Math.floor(Math.random() * r.length);
+    return r[a];
+  }
+}, fe = ke({
+  storeId: "pg-positions",
+  state: _r,
+  getters: br,
+  actions: Ir
+}), Us = {
+  entities: {
+    cameras: {
+      1: {
+        id: 1,
+        name: "Street Level",
+        slug: "default",
+        order: 1
+      },
+      2: {
+        id: 2,
+        name: "Bird's Eye",
+        slug: "down",
+        order: 2
+      },
+      3: {
+        id: 3,
+        name: "Worm's Eye",
+        slug: "up",
+        order: 3
+      }
+    },
+    durations: {
+      2: {
+        id: 2,
+        slug: "15-sec",
+        number: 15,
+        name: "sec",
+        seconds: 15,
+        title: "15 second poses"
+      },
+      3: {
+        id: 3,
+        slug: "30-sec",
+        number: 30,
+        name: "sec",
+        seconds: 30,
+        title: "30 second poses"
+      },
+      4: {
+        id: 4,
+        slug: "1-min",
+        number: 1,
+        name: "min",
+        seconds: 60,
+        title: "1 minute poses"
+      },
+      5: {
+        id: 5,
+        slug: "2-min",
+        number: 2,
+        name: "min",
+        seconds: 120,
+        title: "2 minute poses"
+      },
+      6: {
+        id: 6,
+        slug: "5-min",
+        number: 5,
+        name: "min",
+        seconds: 300,
+        title: "5 minute poses"
+      },
+      7: {
+        id: 7,
+        slug: "45-sec",
+        number: 45,
+        name: "sec",
+        seconds: 45,
+        title: "45 second poses"
+      }
+    },
+    effects: {
+      1: {
+        id: 1,
+        name: "None",
+        slug: "none"
+      },
+      2: {
+        id: 2,
+        name: "Silhouette",
+        slug: "silhouette"
+      },
+      3: {
+        id: 3,
+        name: "Negative",
+        slug: "negative"
+      }
+    },
+    lights: {
+      1: {
+        id: 1,
+        name: "Left",
+        slug: "left",
+        order: 1,
+        src: null
+      },
+      2: {
+        id: 2,
+        name: "Right",
+        slug: "right",
+        order: 2,
+        src: null
+      }
+    },
+    positions: {
+      1: {
+        id: 1,
+        name: "Front",
+        slug: "front",
+        order: 1,
+        src: null
+      },
+      2: {
+        id: 2,
+        name: "Right",
+        slug: "right",
+        order: 2,
+        src: null
+      },
+      3: {
+        id: 3,
+        name: "Back",
+        slug: "back",
+        order: 3,
+        src: null
+      },
+      4: {
+        id: 4,
+        name: "Left",
+        slug: "left",
+        order: 4,
+        src: null
+      }
+    },
+    sets: {
+      125: {
+        id: 125,
+        uuid: "adf56880-0380-497c-9966-c64e951af4ef",
+        name: "Why aren't there more Indian Superheros?",
+        slug: "why-arent-there-more-indian-superheros",
+        description: "There just aren't enough Indian super heros these days. ",
+        favoriteCount: 50,
+        genderIds: [110],
+        speciesIds: [1],
+        subjectIds: [50]
+      }
+    },
+    genders: {
+      110: {
+        id: 110,
+        name: "Male",
+        slug: "male",
+        parentId: 101
+      },
+      111: {
+        id: 111,
+        name: "Female",
+        slug: "female",
+        parentId: 101
+      }
+    },
+    skins: {
+      1: {
+        id: 1,
+        name: "Dressed",
+        slug: "normal",
+        order: 1
+      },
+      2: {
+        id: 2,
+        name: "Nude",
+        slug: "nude",
+        order: 2
+      },
+      3: {
+        id: 3,
+        name: "Muscle",
+        slug: "muscle",
+        order: 3
+      },
+      4: {
+        id: 4,
+        name: "Smooth",
+        slug: "smooth",
+        order: 4
+      },
+      5: {
+        id: 5,
+        name: "Loomis",
+        slug: "loomis",
+        order: 5
+      }
+    }
+  },
+  result: {
+    setUuid: "b22658f7-e757-4a7f-9071-89ccb7df966e"
+  }
+}, k = ie("pg", {
+  /**
+   *
+   * @property {number} active The filter or drawer that is currently active.
+   * @property {boolean} animate This property is a number.
+   * @property {Array} censored An array of censored state ids
+   * @property {boolean} loading
+   * @property {number} possibilities The number of possible poses with current filters.
+   * @property {boolean} show Is the tool being shown.
+   * @property {number} status The const values for OFF = 0, PLAYING = 1 and CLOSED = 2.
+   */
+  state: () => ({
+    animate: !1,
+    active: Yt,
+    playActive: Gt,
+    mobileActive: Me,
+    censored: [],
+    disable: !0,
+    filtering: !1,
+    loading: !1,
+    possibilities: 0,
+    totalCount: 0,
+    loadingSettings: !1,
+    firstLoad: !1
+  }),
+  getters: {
+    filterData(e) {
+      const t = ge(), s = pe(), n = Z(), r = R(), a = re(), c = Ie(), d = ee(), u = fe(), f = V(), g = c.visible === !0 ? 1 : 0;
+      return {
+        cameras: s.selected,
+        durations: n.selected,
+        genders: a.selected,
+        lights: d.selected,
+        effects: r.selected,
+        positions: u.selected,
+        skins: f.selected,
+        grid: [
+          g,
+          c.spacing,
+          c.horizontal,
+          c.vertical
+        ],
+        adjustments: [
+          t.brightness,
+          t.contrast,
+          t.saturate
+        ]
+      };
+    }
+  },
+  actions: {
+    init() {
+      const e = Us.entities, t = Us.result;
+      this.updateStatesFromEntities(e);
+      const s = V();
+      s.uuid = t.setUuid;
+    },
+    updateStatesFromEntities(e) {
+      const t = e, s = pe(), n = Z(), r = R(), a = re(), c = ee(), d = fe(), u = V();
+      s.setState(t.cameras), n.setState(t.durations), r.setState(t.effects), a.setState(t.genders), c.setState(t.lights), d.setState(t.positions), u.setState(t.skins);
+    },
+    updateSelectedFromResult(e) {
+      const t = e, s = ge(), n = pe(), r = Z(), a = R(), c = re(), d = Ie(), u = ee(), f = fe(), g = V();
+      s.setValues(t.adjustments), d.setValues(t.grid), r.setSelected(t.durations), a.setSelected(t.effects), n.setSelected(t.cameras), c.setSelected(t.genders), u.setSelected(t.lights), f.setSelected(t.positions), g.setSelected(t.skins), g.uuid = t.setUuid;
+    },
+    hasAccess(e) {
+      return this.appAccessStore.hasAccess(e);
+    },
+    block(e) {
+      return this.appPaywallStore.block(e);
+    },
+    fetch(e = {}) {
+      return this.disable = !0, this.loading = !0, new Promise((t, s) => {
+        this.appPoseGeneratorStore.fetch(e).then((n) => {
+          var a;
+          this.updateStatesFromEntities(n.entities), this.updateSelectedFromResult(n.result), this.totalCount = n.result.total_count, Pe().ingestNormalized((a = n == null ? void 0 : n.entities) == null ? void 0 : a.poses), this.firstLoad = !0, t(n);
+        }).catch((n) => {
+          s(n), console.log(n);
+        }).finally(() => {
+          this.disable = !1, this.loading = !1;
+        });
+      });
+    },
+    getMorePoses(e) {
+      this.loading = !0, this.appPoseGeneratorStore.getMorePoses(e).then((t) => {
+        this.loading = !1;
+      }).catch((t) => {
+      });
+    },
+    setSettings: rn(
+      function() {
+        console.log("setSettings"), this.internalSettings();
+      },
+      1500,
+      { trailing: !0, leading: !1 }
+    ),
+    internalSettings() {
+      this.loadingSettings || (console.log("internalSettings"), this.appPoseGeneratorStore.setSettings(this.filterData));
+    },
+    getSettings() {
+      this.loadingSettings = !0, this.appPoseGeneratorStore.getSettings().then((e) => {
+        this.loadingSettings = !1, this.updateSelectedFromResult(e.result);
+      }).catch((e) => {
+        this.loadingSettings = !1, console.error(e);
+      });
+    },
+    store(e) {
+      this.appPoseGeneratorStore.store(e);
+    },
+    isExpanded(e = [], t = !1) {
+      const s = t ? this.playActive : this.active;
+      return e = Array.isArray(e) ? e : [e], e.includes(s);
+    },
+    setActive(e, t = !1) {
+      if (t) {
+        if (this.playActive === e) return;
+        this.playActive = e;
+        return;
+      }
+      this.active !== e && (this.active = e);
+    },
+    customReset() {
+      const e = ge(), t = pe(), s = Z(), n = R(), r = re(), a = Ie(), c = ee(), d = fe(), u = V();
+      e.customReset(), t.customReset(), s.customReset(), n.customReset(), r.customReset(), a.customReset(), c.customReset(), d.customReset(), u.customReset();
+    }
+  }
+});
+function ht(e) {
+  if (!Array.isArray(e)) return [];
+  const t = /* @__PURE__ */ new Set();
+  for (let s = 0; s < e.length; s++) {
+    const n = Number(e[s]);
+    Number.isFinite(n) && t.add(n);
+  }
+  return Array.from(t).sort((s, n) => s - n);
+}
+function pt(e = {}) {
+  return {
+    cameras: ht(e.cameras),
+    genders: ht(e.genders),
+    skins: ht(e.skins),
+    species: ht(e.species),
+    // subjects intentionally NOT part of cache key; pass-through if you need to display it
+    subjects: e.subjects == null ? null : Number(e.subjects)
+  };
+}
+function ft(e) {
+  return JSON.stringify([e.cameras, e.genders, e.skins, e.species]);
+}
+const Pt = ie("pg-count", {
+  state: () => ({
+    // --- CACHE ---
+    // entries[key] = { count:number, ts:number }
+    entries: /* @__PURE__ */ Object.create(null),
+    order: [],
+    // insertion order for simple LRU eviction
+    ttlMs: 3600 * 1e3,
+    // 1 hour (set 0/false to disable)
+    maxEntries: 2e3,
+    // optional cap
+    // in-flight de-dup per key: key -> Promise<{count, key}>
+    inFlight: /* @__PURE__ */ Object.create(null),
+    // --- UI FACING / LAST REQUEST ---
+    count: null,
+    // latest displayed count (reactive)
+    loading: !1,
+    error: null,
+    // used to gate UI updates so stale responses don't overwrite newer ones
+    _lastKey: null,
+    _reqId: 0
+  }),
+  getters: {
+    // Fresh cached count for given filters (or null)
+    cachedCount: (e) => (t) => {
+      const s = ft(pt(t)), n = e.entries[s];
+      return !n || e.ttlMs && Date.now() - n.ts > e.ttlMs ? null : n.count;
+    },
+    filters() {
+      return this.getFilters();
+    },
+    adjustedCount(e) {
+      const t = ee(), s = fe(), n = t.selected.length, a = s.selected.length / 4;
+      return this.count * n * 36 * a;
+    }
+  },
+  actions: {
+    /* ----------------------- internal helpers ----------------------- */
+    _touchKey(e) {
+      const t = this.order.indexOf(e);
+      for (t !== -1 && this.order.splice(t, 1), this.order.push(e); this.order.length > this.maxEntries; ) {
+        const s = this.order.shift();
+        s && delete this.entries[s];
+      }
+    },
+    _upsert(e, t) {
+      this.entries[e] = { count: t, ts: Date.now() }, this._touchKey(e);
+    },
+    getFilters() {
+      const e = pe(), t = re(), s = V(), n = R(), r = ee();
+      return {
+        cameras: e.selected,
+        genders: t.selected,
+        skins: s.selected,
+        effects: n.selected,
+        lights: r.selected,
+        species: [1],
+        subjects: 1
+      };
+    },
+    /* ------------------- public cache-only API ---------------------- */
+    // Prime the cache for these filters (no UI updates). Returns the count.
+    async prefetch() {
+      const e = this.getFilters(), t = pt(e), s = ft(t), n = this.cachedCount(e);
+      return n ?? (this.inFlight[s] || (this.inFlight[s] = this.appPoseGeneratorStore.count(t).then((a) => {
+        const c = (a == null ? void 0 : a.result) ?? a;
+        if (typeof (c == null ? void 0 : c.count) != "number")
+          throw new Error("Server response missing numeric count");
+        return this._upsert(s, c.count), { key: s, count: c.count };
+      }).finally(() => {
+        delete this.inFlight[s];
+      })), (await this.inFlight[s]).count);
+    },
+    // Fetch for display: updates reactive `count/loading/error`,
+    // but uses a version gate so stale responses don't overwrite newer ones.
+    // Also caches every response.
+    async fetchForDisplay() {
+      const e = this.getFilters(), t = pt(e), s = ft(t);
+      this._lastKey = s;
+      const n = ++this._reqId;
+      this.loading = !0, this.error = null;
+      const r = this.entries[s] && (!this.ttlMs || Date.now() - this.entries[s].ts <= this.ttlMs) ? this.entries[s].count : null;
+      r !== null && (this.count = r);
+      try {
+        const a = await this.prefetch(e);
+        n === this._reqId && s === this._lastKey && (this.count = a);
+      } catch (a) {
+        n === this._reqId && s === this._lastKey && (this.error = (a == null ? void 0 : a.message) || String(a));
+      } finally {
+        n === this._reqId && s === this._lastKey && (this.loading = !1);
+      }
+    },
+    // Convenience: get a number right away. Returns cache if fresh, else hits server and returns fresh.
+    // Does NOT touch display state (no loading/error/count changes).
+    async get() {
+      const e = this.getFilters(), t = this.cachedCount(e);
+      return t ?? this.prefetch(e);
+    },
+    // cache maintenance
+    invalidate(e) {
+      const t = ft(pt(e));
+      if (this.entries[t]) {
+        delete this.entries[t];
+        const s = this.order.indexOf(t);
+        s !== -1 && this.order.splice(s, 1);
+      }
+    },
+    clearAll() {
+      this.entries = /* @__PURE__ */ Object.create(null), this.order = [], this.inFlight = /* @__PURE__ */ Object.create(null), this.count = null, this.error = null, this.loading = !1, this._lastKey = null, this._reqId = 0;
+    },
+    configure({ ttlMs: e, maxEntries: t } = {}) {
+      typeof e == "number" && (this.ttlMs = e), typeof t == "number" && (this.maxEntries = t);
+    }
+  }
+}), Et = 0, Wt = 1, Pr = 2, fn = 3, Xt = 4, gn = 5, xr = {
+  /**
+   * Load the image and update the status of the
+   * @param context
+   * @param { String } url The url of the image
+   * @param { Function } success On load callback
+   * @param { Function } fail On fail callback
+   */
+  loadImage({ url: e, callback: t = null }) {
+    if (typeof Image > "u")
+      throw t && typeof t == "function" && t(e, Wt), new Error("Image() constructor does not exist.");
+    t && typeof t == "function" && t(e, Pr);
+    let s = new Image();
+    s.onabort = function(n) {
+      t && typeof t == "function" && t(e, fn), this.onerror = this.onabort = this.onload = null;
+    }, s.onerror = function(n) {
+      t && typeof t == "function" && t(e, Wt), this.onerror = this.onabort = this.onload = null;
+    }, s.onload = function(n) {
+      t && typeof t == "function" && t(e, gn), this.onerror = this.onabort = this.onload = null;
+    }, s.src = e, t && typeof t == "function" && t(e, Xt);
+  }
+};
+function wr(e, t) {
+  return Object.values(e).find((s) => s.src === t);
+}
+function Dr({
+  poseId: e,
+  index: t,
+  skinId: s,
+  effectId: n,
+  lightDirection: r
+}) {
+  const a = R(), d = V().getSlugById(s), u = a.getSlugById(n);
+  return `/figure-drawing-poses/${e}/${d}/${u}/${t}/${r === 1 ? 1 : 0}`;
+}
+function mn(e, t = "lg") {
+  if (!e) return;
+  const { getPoseSmall: s, getPoseLarge: n } = Ke(), r = We(e);
+  return r.size = t, vn(r);
+}
+function vn({
+  poseId: e,
+  index: t,
+  skinId: s,
+  effectId: n,
+  size: r = "lg"
+}) {
+  const { getPoseSmall: a, getPoseLarge: c } = Ke(), d = Pe(), u = R(), f = V(), g = d.getModelById(e), v = f.getSlugById(s), C = u.getSlugById(n), _ = n === 3 ? "000000" : "ffffff";
+  return r === "lg" ? c({
+    uuid: g.uuid,
+    skin: v,
+    effect: C,
+    color: _,
+    index: t
+  }) : a({
+    uuid: g.uuid,
+    skin: v,
+    effect: C,
+    color: _,
+    index: t
+  });
+}
+function $t(e) {
+  const t = e.split(".");
+  return {
+    id: e,
+    src: mn(e),
+    status: Et,
+    flipped: t[2] === 1
+  };
+}
+function Mr(e) {
+  const t = Pe(), s = ee(), n = R(), r = V(), a = fe(), c = t.models[e];
+  return [
+    e,
+    a.getRandom(c.index),
+    s.random,
+    r.getRandom(c.skin_ids),
+    n.selected
+  ].join(".");
+}
+function We(e) {
+  if (!e) return;
+  const t = e.split(".").map((s) => parseInt(s));
+  return {
+    poseId: t[0],
+    index: t[1],
+    lightDirection: t[2],
+    skinId: t[3],
+    effectId: t[4]
+  };
+}
+const X = ie("pg-history", {
+  state: () => ({
+    failed: 0,
+    history: [],
+    index: 0,
+    models: {},
+    queue: [],
+    successful: 0,
+    urls: {}
+  }),
+  getters: {
+    playSrc(e) {
+      const t = R(), s = V(), n = this.history[this.index];
+      if (!n) return;
+      const r = We(n);
+      return r.effectId = t.playSelected, r.skinId = s.playSelected, vn(r);
+    },
+    previewSrc(e) {
+      return mn(e.queue[0], "sm");
+    },
+    view360Path(e) {
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      if (!t) return;
+      const s = R(), n = V(), r = We(t);
+      return r.effectId = s.playSelected, r.skinId = n.playSelected, Dr(r);
+    },
+    previewFlipped(e) {
+      const t = e.queue[0];
+      if (!t) return;
+      const s = t.split(".").map((n) => parseInt(n));
+      return s[2] && s[2] === 1;
+    },
+    previousDisabled(e) {
+      return e.index === 0;
+    },
+    nextDisabled(e) {
+      return e.index >= e.history.length + e.queue.length - 2;
+    },
+    current(e) {
+      var s;
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      return t != null ? (s = e.models) == null ? void 0 : s[t] : void 0;
+    },
+    currentEffect(e) {
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      if (!t) return 1;
+      const s = t.split(".");
+      return t ? parseInt(s[4]) : 1;
+    },
+    currentId(e) {
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      if (!t) return;
+      const s = t.split(".");
+      return t ? parseInt(s[0]) : void 0;
+    },
+    currentSrc(e) {
+      var s, n;
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      return t != null ? (n = (s = e.models) == null ? void 0 : s[t]) == null ? void 0 : n.src : void 0;
+    },
+    currentFlipped(e) {
+      var s, n;
+      const t = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0;
+      return t != null ? (n = (s = e.models) == null ? void 0 : s[t]) == null ? void 0 : n.flipped : !1;
+    },
+    prevSrc(e) {
+      var s, n;
+      const t = e.index > 0 ? e.history[e.index - 1] : void 0;
+      return t != null ? (n = (s = e.models) == null ? void 0 : s[t]) == null ? void 0 : n.src : void 0;
+    },
+    nextSrc(e) {
+      var s, n;
+      const t = e.index < e.history.length - 1 ? e.history[e.index + 1] : e.queue[0];
+      return t != null ? (n = (s = e.models) == null ? void 0 : s[t]) == null ? void 0 : n.src : void 0;
+    },
+    // optional: return both ids and srcs at once
+    neighbors(e) {
+      const t = e.index > 0 ? e.history[e.index - 1] : void 0, s = e.index >= 0 && e.index < e.history.length ? e.history[e.index] : void 0, n = e.index < e.history.length - 1 ? e.history[e.index + 1] : e.queue[0], r = (a) => {
+        var c, d;
+        return a != null ? (d = (c = e.models) == null ? void 0 : c[a]) == null ? void 0 : d.src : void 0;
+      };
+      return {
+        prev: { id: t, src: r(t) },
+        current: { id: s, src: r(s) },
+        next: { id: n, src: r(n) }
+      };
+    }
+  },
+  actions: {
+    ...xr,
+    init() {
+    },
+    resetQueue() {
+      this.queue = [];
+    },
+    loadQueue() {
+      const e = Pt(), t = Pe(), s = e.filters, n = t.randomTake(20, s), r = [];
+      if (n.forEach((d) => {
+        try {
+          const u = Mr(d);
+          r.push(u);
+        } catch (u) {
+          console.error("error", u);
+        }
+      }), this.queue = [...r], r.length === 0) return;
+      const a = r[0];
+      this.models[a] || (this.models[a] = $t(a));
+      const c = this.models[a];
+      c.status === Et && this.loadImage({
+        url: c.src,
+        callback: this.updateStatus
+      });
+    },
+    updateQueue() {
+      this.resetQueue(), this.loadQueue();
+    },
+    next() {
+      if (this.queue.length < 5 && this.loadQueue(), this._preloadQueue(5), this.index < this.history.length - 1) {
+        this.index++;
+        return;
+      }
+      const e = R(), t = Pe(), s = V(), n = k(), r = Z(), a = this.queue.shift();
+      if (a == null) return;
+      this.models[a] || (this.models[a] = $t(a));
+      const c = this.models[a];
+      (c.status === Et || c.status === Xt) && this.loadImage({
+        url: c.src,
+        callback: this.updateStatus
+      });
+      const { poseId: d, index: u, lightDirection: f, skinId: g, effectId: v } = We(a);
+      a.split("."), t.addToSeen(d), this.history.push(a), this.queue.shift(), this.index = this.history.length - 1, n.store({
+        poseId: d,
+        index: u,
+        lightDirection: f,
+        skinId: g,
+        effectId: v,
+        seconds: r.seconds
+      }), s.playSelected = g, e.playSelected = v, this.queue.length < 5 && this.loadQueue(), this._preloadQueue(5);
+    },
+    reset() {
+      this.$patch({
+        index: 0,
+        history: []
+      });
+    },
+    // next2() {
+    //   // keep queue filled & preloaded
+    //   if (this.queue.length < 5) this.loadQueue()
+    //   this._preloadQueue(5)
+    //   const current = this.queue.shift()
+    //   if (current != null) this.history.push(current)
+    // },
+    previous() {
+      if (this.index === 0) return;
+      const e = V(), t = R(), s = this.index - 1;
+      this.index = s;
+      const n = this.history[s], { skinId: r, effectId: a } = We(n);
+      t.playSelected = a, e.playSelected = r;
+    },
+    updateStatus(e, t) {
+      const s = wr(this.models, e);
+      s && (this.models[s.id].status = t);
+    },
+    _preloadQueue(e = 5) {
+      const t = this.queue.slice(0, e);
+      for (const s of t) {
+        this.models[s] || (this.models[s] = $t(s));
+        const n = this.models[s], r = n.status;
+        if ((r === Et || r === Xt) && this.loadImage({
+          url: n.src,
+          callback: this.updateStatus
+        }), r === Wt || r === fn) {
+          delete this.models[s];
+          const a = this.queue.indexOf(s);
+          a !== -1 && this.queue.splice(a, 1);
+        }
+      }
+      this.queue.length < 5 && this.loadQueue();
+    }
+  }
+}), Rs = 0, Ct = 1, zt = 2, he = ie("pg-timer", {
+  state: () => ({
+    status: Ct,
+    interval: 0,
+    intervalDelay: 25,
+    seconds: 0,
+    milliseconds: 0
+  }),
+  getters: {
+    formatted(e) {
+      const s = Z().duration, n = s - e.seconds;
+      let r = Math.floor(n / 60), a = n - r * 60;
+      return a = a >= 0 ? a : 59, r === 1 && a === 0 && s === 60 && (r = 0, a = 60), a = "0" + a, (s > 61 ? r + ":" : "") + a.substr(-2);
+    },
+    playing(e) {
+      return e.status === zt;
+    },
+    paused(e) {
+      return e.status === Rs;
+    }
+  },
+  actions: {
+    /**
+     * Pause the timer - stop the interval without resetting seconds and milliseconds
+     * @param context
+     */
+    pause() {
+      clearInterval(this.interval), this.$patch({
+        interval: 0,
+        status: Rs
+      });
+    },
+    restart() {
+      this.resetTimer(), this.start();
+    },
+    /**
+     * Reset the timer - stop the interval and set seconds and milliseconds to 0
+     * @param context
+     */
+    resetTimer() {
+      this.$patch({
+        seconds: 0,
+        milliseconds: 0
+      });
+    },
+    /**
+     * Stop the timer - Clear interval and reset time
+     * @param context
+     */
+    stop() {
+      clearInterval(this.interval), this.resetTimer(), this.$patch({
+        interval: 0,
+        status: Ct
+      });
+    },
+    /**
+     * Start the timer if it isn't already running
+     * @param context
+     */
+    start() {
+      if (this.status !== zt) {
+        clearInterval(this.interval), this.$patch({
+          interval: 0
+        });
+        const e = setInterval(this._tick, this.intervalDelay);
+        this.$patch({
+          interval: e,
+          status: zt
+        });
+      }
+    },
+    /**
+     * Timer interval callback
+     * @param context
+     */
+    _tick() {
+      const e = Z(), t = Te(), s = e.duration, n = this.milliseconds + this.intervalDelay, r = Math.round(n / 1e3);
+      if (n === s * 1e3) {
+        this.resetTimer(), t.next();
+        return;
+      }
+      this.$patch({
+        seconds: r,
+        milliseconds: n
+      });
+    }
+  }
+}), Bs = 0, gt = 1, Ar = 2, Te = ie("pg-controls", {
+  state: () => ({
+    timer: !0,
+    next: !0,
+    show: !1,
+    status: Bs
+  }),
+  getters: {
+    /**
+     * Is next disabled.
+     * If we are at the end of history and the next item in the queue is not loaded
+     * @param state
+     * @param getters
+     */
+    nextDisabled(e) {
+      return X().nextDisabled;
+    },
+    /**
+     * Is the the previous button disabled.
+     * If we are at the beginning of history then yes
+     * @param state
+     * @returns {boolean}
+     */
+    previousDisabled(e) {
+      return X().previousDisabled;
+    }
+  },
+  actions: {
+    /**
+     * Open the pose generator tool, reset history and start playing from queue
+     */
+    open() {
+      const e = he(), t = X(), s = k();
+      e.resetTimer(), t.next(), e.start(), this.$patch({ show: !0, status: gt }), s.$patch({ active: Me, playActive: Me });
+    },
+    /**
+     * Close the pose generator tool
+     */
+    close() {
+      const e = he(), t = X(), s = k();
+      e.stop(), this.show = !1, this.status = Bs, t.reset(), s.$patch({ active: Me, playActive: Me });
+    },
+    /**
+     * Check if currently inside of history, if so increment history index
+     * if not load from the queue
+     */
+    next: rn(
+      function() {
+        X().next(), this.resetOrRestartTimer();
+      },
+      250,
+      { leading: !0, maxWait: 500 }
+    ),
+    /**
+     * Move to the previous pose in history if it exists
+     */
+    previous() {
+      const e = X();
+      e.index > 0 && (e.previous(), this.resetOrRestartTimer());
+    },
+    /**
+     *
+     */
+    pause() {
+      const e = he();
+      this.status = Ar, e.pause();
+    },
+    /**
+     *
+     */
+    play() {
+      const e = he();
+      this.status = gt, e.start();
+    },
+    /**
+     * Reset or restart the time based on the current play status
+     * @param getters
+     * @param dispatch
+     */
+    resetOrRestartTimer() {
+      const e = he();
+      if (e.playing === !0) {
+        e.restart();
+        return;
+      }
+      e.resetTimer();
+    },
+    startTimer() {
+      const e = he();
+      if (
+        // p !== null &&
+        e.status === Ct && this.show === !0 && this.status === gt
+      ) {
+        e.start();
+        return;
+      }
+      e.status === Ct && this.show === !0 && this.status === gt && this.startTimerLoop();
+    },
+    startTimerLoop() {
+      setTimeout(() => {
+        this.startTimer();
+      }, 250);
+    }
+  }
+}), $s = /* @__PURE__ */ Object.assign({ "../i18n/en-US/index.js": () => import("./index-BMl4y9AI.js") }), M = (e = "../i18n") => {
+  const t = It(), s = j({}), n = y(() => t.lang.isoName || "en-US"), r = async () => {
+    const a = `${e}/${n.value}/index.js`;
+    if ($s[a])
+      try {
+        const c = await $s[a]();
+        c.default && Object.assign(s.value, c.default);
+      } catch (c) {
+        console.error(`Error loading i18n for ${n.value}`, c);
+      }
+    else
+      console.error(`Module not found: ${a}`);
+  };
+  return Ne(
+    () => n.value,
+    () => {
+      r();
+    },
+    { immediate: !0 }
+  ), To(() => {
+    r();
+  }), { lang: s };
+}, ae = ({
+  tab: e = wo,
+  store: t,
+  options: s = [],
+  playMode: n = !1
+}) => {
+  const r = Po(), a = k(r), c = y({
+    get: () => a.isExpanded(s, n),
+    set: (f) => {
+      f && a.setActive(e, n);
+    }
+  }), d = y(() => t && t.changed);
+  return { click: () => a.setActive(e, n), expanded: c, selected: d };
+}, yn = T({
+  name: "PgDurationsTool",
+  setup(e, { slots: t, emit: s }) {
+    const n = k(), r = Z(), { loading: a } = S(n), { collectedModels: c, values: d } = S(r), u = y({
+      get: () => r.index,
+      set: (g) => r.setSelectedByIndex(g)
+    });
+    function f() {
+      const g = {
+        class: "pg-durations-tool col full-width",
+        color: "lt-grey",
+        disable: a.value,
+        modelValue: u.value,
+        "onUpdate:modelValue": (v) => u.value = v,
+        markers: !0,
+        markerLabels: d.value,
+        min: 0,
+        max: d.value.length - 1,
+        noTrack: !0
+      };
+      return [
+        h("div", { class: "q-mx-lg q-mt-sm q-mb-lg" }, [
+          h(Oo, g, {
+            // single label slot, Quasar passes { index, label }
+            "marker-label": ({ marker: v }) => {
+              const C = { ...v.style, cursor: "default" };
+              return h(
+                "div",
+                {
+                  class: [
+                    v.classes,
+                    {
+                      "pg-durations-tool__is-active": v.value === u.value
+                    }
+                    // add class for current selection
+                  ],
+                  onClick: () => u.value = v.value,
+                  style: C
+                },
+                v.label
+              );
+            }
+          })
+        ])
+      ];
+    }
+    return () => f();
+  }
+}), Nr = T({
+  name: "PgDurationsExpansion",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = Z(), { title: a } = S(r), { expanded: c } = ae({
+      options: Yt,
+      tab: Yt
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.duration;
+    });
+    function u() {
+      const f = {
+        class: "pg-durations-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: cn
+      };
+      return h(me, f, () => h(yn));
+    }
+    return () => u();
+  }
+}), Or = T({
+  name: "PgSkinsToolButton",
+  props: {
+    id: Number,
+    slug: String,
+    playMode: Boolean,
+    uuid: String
+  },
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = V(), r = k(), { selected: a, playSelected: c } = S(n), { loading: d } = S(r), u = y(() => n.getSrc(e.slug, e.uuid)), f = y(() => n.getAccessKey(e.slug)), g = y(() => n.propertyById(e.id, "name")), v = (I) => {
+      if (e.playMode) {
+        n.playSelected = I;
+        return;
+      }
+      n.toggleSelected(I);
+    }, C = y(
+      () => e.playMode ? c.value === e.id : a.value.includes(e.id)
+    ), _ = (I) => r.block(I), D = y(() => r.hasAccess(f.value));
+    function P() {
+      const I = {
+        circle: !0,
+        size: e.playMode ? "sm" : "lg",
+        type: e.playMode ? "radio" : "checkbox",
+        label: g.value,
+        access: f.value,
+        image: u.value,
+        onClick: () => v(e.id),
+        disable: d.value,
+        selected: C.value,
+        hasAccess: D.value,
+        onBlockAccess: _
+      };
+      return h(Qe, I);
+    }
+    return () => P();
+  }
+}), ts = T({
+  name: "PgSkinsTool",
+  props: {
+    noWrap: Boolean,
+    length: Number,
+    playMode: Boolean,
+    desktop: Boolean
+  },
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = V(), r = Pe(), a = X(), { currentId: c } = S(a), d = y(() => {
+      if (e.playMode) {
+        const g = r.getModelById(c.value);
+        return n.getModelsByIds(g == null ? void 0 : g.skin_ids);
+      }
+      return n.collectedModels;
+    }), u = y(() => {
+      if (e.playMode) {
+        const g = r.getModelById(c.value);
+        return g == null ? void 0 : g.set_uuid;
+      }
+    });
+    y(() => e.playMode ? "col-6" : (e.desktop, ""));
+    function f() {
+      y(() => ({
+        "pg-skins-tool row flex justify-center": !0,
+        "q-pa-xs": e.playMode
+      })).value, d.value.length;
+      const v = [];
+      return d.value.forEach((C) => {
+        const _ = {
+          id: C.id,
+          key: C.id,
+          playMode: e.playMode,
+          slug: C.slug,
+          class: "q-ma-xs"
+        };
+        u.value && (_.uuid = u.value), v.push(h(Or, _));
+      }), h(an, {}, () => v);
+    }
+    return () => f();
+  }
+}), kr = "M9.49816 16.125C8.73787 16.125 8.11581 16.7437 8.11581 17.5V39.5C8.11581 40.2563 8.73787 40.875 9.49816 40.875H31.6158C32.3761 40.875 32.9982 40.2563 32.9982 39.5V17.5C32.9982 16.7437 32.3761 16.125 31.6158 16.125H9.49816ZM3.96875 17.5C3.96875 14.4664 6.44835 12 9.49816 12H31.6158C34.6656 12 37.1452 14.4664 37.1452 17.5V39.5C37.1452 42.5336 34.6656 45 31.6158 45H9.49816C6.44835 45 3.96875 42.5336 3.96875 39.5V17.5ZM47.6511 16.5375C48.014 16.2711 48.446 16.125 48.8952 16.125C50.0443 16.125 50.9688 17.0445 50.9688 18.1875V38.8125C50.9688 39.9555 50.0443 40.875 48.8952 40.875C48.446 40.875 48.014 40.7289 47.6511 40.4625L41.2923 35.7188V30.5625L46.8217 34.6875V22.3125L41.2923 26.4375V21.2812L47.6511 16.5375zM21.6892 29.2971C20.618 29.3471 19.7271 29.4371 19.0165 29.567C18.3059 29.687 17.7384 29.8469 17.3142 30.0469C16.9006 30.2468 16.6036 30.4767 16.4233 30.7366C16.2536 30.9866 16.1688 31.2615 16.1688 31.5614C16.1688 32.1612 16.3438 32.5861 16.6937 32.836C17.0544 33.0859 17.5528 33.2109 18.1892 33.2109C18.921 33.2109 19.5521 33.0909 20.0824 32.851C20.6233 32.6011 21.1589 32.2162 21.6892 31.6963V29.2971ZM12.7483 22.4442C13.7134 21.6245 14.7794 21.0147 15.946 20.6148C17.1127 20.2049 18.3748 20 19.7324 20C20.7081 20 21.5778 20.15 22.3415 20.4499C23.1157 20.7498 23.768 21.1696 24.2983 21.7095C24.8392 22.2393 25.2528 22.8741 25.5392 23.6139C25.8256 24.3536 25.9687 25.1634 25.9687 26.0431V35.7601H23.9642C23.5506 35.7601 23.2324 35.7051 23.0097 35.5951C22.7975 35.4852 22.6225 35.2552 22.4847 34.9053L22.1347 33.9157C21.721 34.2555 21.318 34.5555 20.9256 34.8154C20.5437 35.0753 20.146 35.2952 19.7324 35.4752C19.3188 35.6451 18.8733 35.7751 18.396 35.865C17.9294 35.955 17.4044 36 16.821 36C16.0998 36 15.4422 35.91 14.8483 35.7301C14.2544 35.5501 13.74 35.2852 13.3051 34.9353C12.8809 34.5754 12.5521 34.1306 12.3187 33.6007C12.0854 33.0709 11.9688 32.4611 11.9688 31.7713C11.9688 31.2015 12.1225 30.6317 12.4301 30.0619C12.7377 29.492 13.2627 28.9772 14.0051 28.5173C14.7581 28.0475 15.7551 27.6626 16.996 27.3627C18.2475 27.0528 19.8119 26.8778 21.6892 26.8379V26.0431C21.6892 25.0734 21.4718 24.3636 21.0369 23.9138C20.6021 23.4539 19.9763 23.224 19.1597 23.224C18.5551 23.224 18.0513 23.294 17.6483 23.4339C17.2453 23.5639 16.89 23.7088 16.5824 23.8688C16.2854 24.0187 16.0044 24.1637 15.7392 24.3037C15.4741 24.4336 15.1665 24.4986 14.8165 24.4986C14.5089 24.4986 14.2491 24.4286 14.0369 24.2887C13.8354 24.1387 13.6657 23.9638 13.5278 23.7638L12.7483 22.4442Z|0 0 56 56", Lr = "M40.3077 8.63218C39.2846 8.63218 38.4615 7.8225 38.4615 6.81609C38.4615 5.80967 39.2846 5 40.3077 5H50.1538C51.1769 5 52 5.80967 52 6.81609V16.5019C52 17.5083 51.1769 18.318 50.1538 18.318C49.1308 18.318 48.3077 17.5083 48.3077 16.5019V11.1974L42.5462 16.8651C44.6 19.2033 45.8462 22.2453 45.8462 25.5823C45.8462 32.9375 39.7846 38.9003 32.3077 38.9003C29.5846 38.9003 27.0462 38.1058 24.9231 36.7437C23.2846 37.7955 21.4077 38.5068 19.3769 38.7717C19.3769 38.8095 19.3846 38.8549 19.3846 38.8927V42.5249H23.0769C24.1 42.5249 24.9231 43.3346 24.9231 44.341C24.9231 45.3474 24.1 46.1571 23.0769 46.1571H19.3846V49.1839C19.3846 50.1903 18.5615 51 17.5385 51C16.5154 51 15.6923 50.1903 15.6923 49.1839V46.1571H12C10.9769 46.1571 10.1538 45.3474 10.1538 44.341C10.1538 43.3346 10.9769 42.5249 12 42.5249H15.6923V38.8927C15.6923 38.8549 15.6923 38.8095 15.7 38.7717C9.09231 37.8863 4 32.317 4 25.5748C4 18.2196 10.0615 12.2568 17.5385 12.2568C20.2615 12.2568 22.8 13.0513 24.9231 14.4134C27.0462 13.0513 29.5846 12.2568 32.3077 12.2568C35.0615 12.2568 37.6308 13.0665 39.7692 14.4588L45.7 8.63218H40.3077ZM22 16.9483C20.6615 16.2749 19.1462 15.8965 17.5385 15.8965C12.1 15.8965 7.69231 20.2324 7.69231 25.5823C7.69231 30.9322 12.1 35.2681 17.5385 35.2681C19.1462 35.2681 20.6615 34.8898 22 34.2163C19.9846 31.8932 18.7692 28.874 18.7692 25.5823C18.7692 22.2907 19.9846 19.2714 22 16.9483ZM24.9231 31.9916C26.4538 30.2815 27.3846 28.0416 27.3846 25.5823C27.3846 23.123 26.4538 20.8832 24.9231 19.1731C23.3923 20.8832 22.4615 23.123 22.4615 25.5823C22.4615 28.0416 23.3923 30.2815 24.9231 31.9916ZM27.8462 34.2239C29.1846 34.8974 30.7 35.2757 32.3077 35.2757C37.7462 35.2757 42.1538 30.9398 42.1538 25.5899C42.1538 20.24 37.7462 15.8965 32.3077 15.8965C30.7 15.8965 29.1846 16.2749 27.8462 16.9483C29.8615 19.2714 31.0769 22.2907 31.0769 25.5823C31.0769 28.874 29.8615 31.8932 27.8462 34.2163V34.2239Z|0 0 56 56", Vr = "M38.35 22.875C38.35 25.65 37.2719 28.1648 35.5109 30.0365C33.98 31.6553 32.2838 33.9389 31.68 36.75H24.32C23.7162 33.9316 22.02 31.6553 20.4891 30.0365C18.7281 28.1648 17.65 25.65 17.65 22.875C17.65 17.1299 22.2859 12.4688 28 12.4688C33.7141 12.4688 38.35 17.1299 38.35 22.875ZM34.9 38.8963C34.9 36.4176 36.3159 34.2207 38.0122 32.4213C40.3625 29.9354 41.8 26.575 41.8 22.875C41.8 15.2148 35.6187 9 28 9C20.3812 9 14.2 15.2148 14.2 22.875C14.2 26.575 15.6375 29.9354 17.9878 32.4213C19.6841 34.2207 21.1 36.4176 21.1 38.8963V40.2188C21.1 43.4129 23.6731 46 26.85 46H29.15C32.3269 46 34.9 43.4129 34.9 40.2188V38.8963ZM27.425 19.4062C28.3809 19.4062 29.15 18.633 29.15 17.6719C29.15 16.7107 28.3809 15.9375 27.425 15.9375C23.9319 15.9375 21.1 18.7848 21.1 22.2969C21.1 23.258 21.8691 24.0312 22.825 24.0312C23.7809 24.0312 24.55 23.258 24.55 22.2969C24.55 20.6998 25.8366 19.4062 27.425 19.4062ZM9.21906 10.915C8.36375 10.4887 7.32875 10.8355 6.90469 11.6883C6.48062 12.541 6.82562 13.5889 7.68094 14.0225L9.98094 15.1787C10.8363 15.6051 11.8712 15.2582 12.2953 14.4055C12.7194 13.5527 12.3744 12.5049 11.5262 12.0785L9.22625 10.9223L9.21906 10.915ZM48.3191 14.0152C49.1744 13.5889 49.5194 12.5482 49.0881 11.6883C48.6569 10.8283 47.6291 10.4814 46.7738 10.915L44.4738 12.0713C43.6184 12.4977 43.2734 13.5383 43.7047 14.3982C44.1359 15.2582 45.1637 15.6051 46.0191 15.1715L48.3191 14.0152ZM6.725 21.1406C5.76906 21.1406 5 21.9139 5 22.875C5 23.8361 5.76906 24.6094 6.725 24.6094H9.025C9.98094 24.6094 10.75 23.8361 10.75 22.875C10.75 21.9139 9.98094 21.1406 9.025 21.1406H6.725ZM46.975 21.1406C46.0191 21.1406 45.25 21.9139 45.25 22.875C45.25 23.8361 46.0191 24.6094 46.975 24.6094H49.275C50.2309 24.6094 51 23.8361 51 22.875C51 21.9139 50.2309 21.1406 49.275 21.1406H46.975ZM11.5191 33.6787C12.3744 33.2523 12.7194 32.2117 12.2881 31.3518C11.8569 30.4918 10.8291 30.1449 9.97375 30.5785L7.67375 31.7348C6.81844 32.1611 6.47344 33.2018 6.90469 34.0617C7.33594 34.9217 8.36375 35.2686 9.21906 34.835L11.5191 33.6787ZM46.0191 30.5785C45.1637 30.1521 44.1287 30.499 43.7047 31.3518C43.2806 32.2045 43.6256 33.2523 44.4738 33.6787L46.7738 34.835C47.6291 35.2613 48.6641 34.9145 49.0881 34.0617C49.5122 33.209 49.1672 32.1611 48.3191 31.7348L46.0191 30.5785Z|0 0 56 56", Ur = "M9.49816 16.125C8.73787 16.125 8.11581 16.7437 8.11581 17.5V39.5C8.11581 40.2563 8.73787 40.875 9.49816 40.875H31.6158C32.3761 40.875 32.9982 40.2563 32.9982 39.5V17.5C32.9982 16.7437 32.3761 16.125 31.6158 16.125H9.49816ZM3.96875 17.5C3.96875 14.4664 6.44835 12 9.49816 12H31.6158C34.6656 12 37.1452 14.4664 37.1452 17.5V39.5C37.1452 42.5336 34.6656 45 31.6158 45H9.49816C6.44835 45 3.96875 42.5336 3.96875 39.5V17.5ZM47.6511 16.5375C48.014 16.2711 48.446 16.125 48.8952 16.125C50.0443 16.125 50.9688 17.0445 50.9688 18.1875V38.8125C50.9688 39.9555 50.0443 40.875 48.8952 40.875C48.446 40.875 48.014 40.7289 47.6511 40.4625L41.2923 35.7188V30.5625L46.8217 34.6875V22.3125L41.2923 26.4375V21.2812L47.6511 16.5375zM20.9919 20C22.1874 20 23.2747 20.1858 24.2538 20.5574C25.2328 20.9291 26.0728 21.4614 26.7736 22.1544C27.4744 22.8374 28.0155 23.6711 28.3968 24.6554C28.7781 25.6397 28.9688 26.7495 28.9688 27.9849C28.9688 29.2203 28.7781 30.3352 28.3968 31.3296C28.0155 32.3139 27.4744 33.1525 26.7736 33.8456C26.0728 34.5386 25.2328 35.0709 24.2538 35.4426C23.2747 35.8142 22.1874 36 20.9919 36C19.7861 36 18.6886 35.8142 17.6992 35.4426C16.7201 35.0709 15.8802 34.5386 15.1794 33.8456C14.4786 33.1525 13.9324 32.3139 13.5407 31.3296C13.1594 30.3352 12.9688 29.2203 12.9688 27.9849C12.9688 26.7495 13.1594 25.6397 13.5407 24.6554C13.9324 23.6711 14.4786 22.8374 15.1794 22.1544C15.8802 21.4614 16.7201 20.9291 17.6992 20.5574C18.6886 20.1858 19.7861 20 20.9919 20ZM20.9919 32.8814C22.208 32.8814 23.1098 32.4746 23.6973 31.661C24.2847 30.8374 24.5784 29.6171 24.5784 28C24.5784 26.393 24.2847 25.1827 23.6973 24.3691C23.1098 23.5455 22.208 23.1337 20.9919 23.1337C19.7449 23.1337 18.8277 23.5455 18.2402 24.3691C17.6528 25.1827 17.3591 26.393 17.3591 28C17.3591 29.6171 17.6528 30.8374 18.2402 31.661C18.8277 32.4746 19.7449 32.8814 20.9919 32.8814Z|0 0 56 56", Rr = "M17.2632 11.643C17.8471 11.1836 18.5626 10.9375 19.3028 10.9375H19.6811C20.5694 14.7027 23.9578 17.5 28.0041 17.5C32.0505 17.5 35.4389 14.7027 36.3271 10.9375H36.7054C37.4456 10.9375 38.1611 11.1836 38.745 11.643L48.4003 19.2473L44.4527 25.3832L40.1514 22.9961C39.5428 22.6598 38.7944 22.668 38.194 23.0207C37.5936 23.3734 37.2153 24.0215 37.2153 24.7188V44.4062C37.2153 44.7672 36.9192 45.0625 36.5574 45.0625H19.4509C19.089 45.0625 18.7929 44.7672 18.7929 44.4062V24.7188C18.7929 24.0215 18.4228 23.3734 17.8224 23.0207C17.2221 22.668 16.4737 22.6598 15.8651 22.9961L11.5555 25.3832L7.60788 19.2473L17.2632 11.643ZM19.3028 7C17.6744 7 16.0953 7.54961 14.8206 8.55039L3.75069 17.2703C2.95294 17.902 2.76378 19.0258 3.3148 19.8789L9.23629 29.0664C9.79554 29.9359 10.9469 30.223 11.8516 29.7227L14.8453 28.0656V44.4062C14.8453 46.941 16.9096 49 19.4509 49H36.5574C39.0987 49 41.163 46.941 41.163 44.4062V28.0656L44.1484 29.7227C45.0613 30.223 46.2045 29.9359 46.7637 29.0664L52.6852 19.8789C53.2362 19.0258 53.0471 17.8938 52.2493 17.2703L41.1876 8.55039C39.9129 7.54961 38.3338 7 36.7054 7H19.3028ZM23.8426 10.9375H32.1656C31.4254 12.4879 29.8381 13.5625 28.0041 13.5625C26.1701 13.5625 24.5828 12.4879 23.8426 10.9375Z|0 0 56 56", Br = "M14.0004 46C12.8959 45.9999 12.0004 45.1045 12.0004 44L12.0004 12C12.0004 10.8955 12.8959 10.0001 14.0004 10C15.105 10 16.0004 10.8954 16.0004 12L16.0004 44C16.0004 45.1046 15.105 46 14.0004 46zM43.4145 44.9707C42.6334 45.7515 41.3673 45.7517 40.5863 44.9707L23.6156 28L40.5863 11.0293C41.3673 10.2486 42.6334 10.2487 43.4145 11.0293C44.1955 11.8103 44.1955 13.0774 43.4145 13.8584L29.2738 28.001L43.4145 42.1426C44.1955 42.9236 44.1955 44.1897 43.4145 44.9707Z|0 0 56 56", $r = "M41.9998 10C43.1043 10.0001 43.9998 10.8955 43.9998 12V44C43.9998 45.1045 43.1043 45.9999 41.9998 46C40.8953 46 39.9998 45.1046 39.9998 44V12C39.9998 10.8954 40.8953 10 41.9998 10zM12.5858 11.0293C13.3668 10.2485 14.6329 10.2483 15.4139 11.0293L32.3846 28L15.4139 44.9707C14.633 45.7514 13.3668 45.7513 12.5858 44.9707C11.8047 44.1897 11.8047 42.9226 12.5858 42.1416L26.7264 27.999L12.5858 13.8574C11.8047 13.0764 11.8047 11.8103 12.5858 11.0293Z|0 0 56 56", En = T({
+  name: "PgSkinsExpansion",
+  props: { playMode: Boolean },
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = V(), { expanded: a } = ae({
+      options: Gt,
+      tab: Gt,
+      playMode: e.playMode
+    }), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.skins;
+    });
+    function d() {
+      const u = y(
+        () => e.playMode ? r.playCaption : r.caption
+      ), f = {
+        class: "pg-skins-expansion",
+        modelValue: a.value,
+        "onUpdate:modelValue": (v) => a.value = v,
+        label: c.value,
+        caption: u.value,
+        icon: Rr
+      }, g = {
+        playMode: e.playMode
+      };
+      return h(me, f, () => h(ts, g));
+    }
+    return () => d();
+  }
+}), zr = T({
+  name: "PgEffectsToolButton",
+  props: {
+    id: { type: Number, required: !0 },
+    playMode: Boolean
+  },
+  setup(e, { slots: t, emit: s }) {
+    const n = R(), r = k(), { loading: a } = S(r), c = () => n.setSelected(e.id, e.playMode), d = y(() => e.playMode ? n.playSelected : n.selected);
+    function u() {
+      const f = {
+        class: "pg-effects-tool-button",
+        label: n.name(e.id),
+        image: n.srcById(e.id),
+        selected: d.value === e.id,
+        circle: !0,
+        size: e.playMode ? "sm" : "lg",
+        type: "radio",
+        onClick: c
+      };
+      return h(Qe, f);
+    }
+    return () => u();
+  }
+}), Sn = T({
+  name: "PgEffectsTool",
+  props: {
+    modelValue: { type: Number, default: 0 },
+    "onUpdate:modelValue": [Function, Array],
+    label: { type: String, required: !1 },
+    playMode: Boolean
+  },
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = R(), { collection: r } = S(n);
+    function a() {
+      const d = {
+        class: y(() => ({
+          "pg-effects-tool": !0
+        })).value
+      }, u = [];
+      return r.value.forEach((f) => {
+        u.push(
+          h(zr, {
+            id: f,
+            playMode: e.playMode,
+            class: "q-ma-xs"
+          })
+        );
+      }), h(an, d, u);
+    }
+    return () => a();
+  }
+}), Tn = T({
+  name: "PgEffectsExpansion",
+  props: { playMode: Boolean },
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = R(), { expanded: a } = ae({
+      options: St,
+      tab: St,
+      playMode: e.playMode
+    }), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.effects;
+    });
+    function d() {
+      const u = y(
+        () => e.playMode ? r.playCaption : r.caption
+      ), f = {
+        class: "pg-effects-expansion",
+        modelValue: a.value,
+        "onUpdate:modelValue": (v) => a.value = v,
+        label: c.value,
+        caption: u.value,
+        icon: un
+      }, g = {
+        playMode: e.playMode
+      };
+      return h(me, f, () => h(Sn, g));
+    }
+    return () => d();
+  }
+}), Hr = {
+  __name: "PgCameraAnglesToolButton",
+  props: {
+    id: Number
+  },
+  setup(e) {
+    const t = e, s = pe(), n = k(), { selected: r } = S(s), { loading: a } = S(n), c = y(() => r.value.includes(t.id)), d = y(() => s.propertyById(t.id, "name")), u = y(() => s.src(t.id)), f = y(() => {
+      switch (t.id) {
+        case 2:
+          return "cad";
+        case 3:
+          return "cau";
+        default:
+          return "can";
+      }
+    }), g = (_) => n.block(_), v = y(() => n.hasAccess(f.value)), C = (_) => s.toggleSelected(_);
+    return (_, D) => (O(), _t(A(Qe), {
+      size: "lg",
+      type: "checkbox",
+      access: f.value,
+      onClick: D[0] || (D[0] = (P) => C(e.id)),
+      image: u.value,
+      label: d.value,
+      selected: c.value,
+      disable: A(a),
+      "has-access": v.value,
+      onBlockAccess: g
+    }, null, 8, ["access", "image", "label", "selected", "disable", "has-access"]));
+  }
+}, Fr = { class: "pg-cameras-tool row q-col-gutter-sm flex justify-center" }, Cn = {
+  __name: "PgCameraAnglesTool",
+  setup(e) {
+    const t = pe(), { collection: s } = S(t);
+    return (n, r) => (O(), $("div", Fr, [
+      (O(!0), $(Xe, null, Ze(A(s), (a) => (O(), $("div", {
+        class: "",
+        key: a
+      }, [
+        B(Hr, { id: a }, null, 8, ["id"])
+      ]))), 128))
+    ]));
+  }
+}, qr = T({
+  name: "PgCamerasExpansion",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = pe(), { caption: a } = S(r), { expanded: c } = ae({
+      options: Ps,
+      tab: Ps
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.angle;
+    });
+    function u() {
+      const f = {
+        class: "pg-cameras-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: kr
+      };
+      return h(me, f, () => h(Cn));
+    }
+    return () => u();
+  }
+}), jr = {
+  __name: "PgLightsToolButton",
+  props: { id: Number },
+  setup(e) {
+    const t = e, s = ee(), n = k(), { selected: r } = S(s), { loading: a } = S(n), c = y(() => r.value.includes(t.id)), d = y(() => s.propertyById(t.id, "name")), u = y(() => s.src(t.id)), f = y(() => t.id === 1 ? "ldl" : "ldr"), g = y(() => n.hasAccess(f.value)), v = (_) => n.block(_), C = (_) => s.toggleSelected(_);
+    return (_, D) => (O(), _t(A(Qe), {
+      size: "lg",
+      type: "checkbox",
+      onClick: D[0] || (D[0] = (P) => C(e.id)),
+      image: u.value,
+      label: d.value,
+      selected: c.value,
+      access: f.value,
+      disable: A(a),
+      "has-access": g.value,
+      onBlockAccess: v
+    }, null, 8, ["image", "label", "selected", "access", "disable", "has-access"]));
+  }
+}, Gr = { class: "pg-lights-tool row q-col-gutter-sm flex justify-center" }, _n = {
+  __name: "PgLightsTool",
+  setup(e) {
+    const t = ee(), { collection: s } = S(t);
+    return (n, r) => (O(), $("div", Gr, [
+      (O(!0), $(Xe, null, Ze(A(s), (a) => (O(), $("div", {
+        class: "",
+        key: a
+      }, [
+        B(jr, { id: a }, null, 8, ["id"])
+      ]))), 128))
+    ]));
+  }
+}, Yr = T({
+  name: "PgLightsExpansion",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = ee(), { caption: a } = S(r), { expanded: c } = ae({
+      options: xs,
+      tab: xs
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.light;
+    });
+    function u() {
+      const f = {
+        class: "pg-lights-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: Vr
+      };
+      return h(me, f, () => h(_n));
+    }
+    return () => u();
+  }
+}), Wr = T({
+  name: "PgGendersToolButton",
+  props: {
+    id: Number,
+    compact: Boolean
+  },
+  setup(e, { slots: t, emit: s }) {
+    const n = re(), r = k(), { selected: a } = S(n), { loading: c } = S(r), d = y(() => e.id === 111 ? "lmf" : "lmm"), u = y(() => n.propertyById(e.id, "name")), f = y(() => n.propertyById(e.id, "slug")), g = y(() => a.value.includes(e.id)), v = y(() => r.hasAccess(d.value));
+    function C() {
+      const _ = {
+        size: e.compact ? "sm" : "lg",
+        type: "checkbox",
+        access: d.value,
+        onClick: () => n.toggleSelected(e.id),
+        icon: `f_${f.value}`,
+        label: u.value,
+        selected: g.value,
+        disable: c.value,
+        hasAccess: v.value,
+        onBlockAccess: (D) => r.block(D)
+      };
+      return h(Qe, _);
+    }
+    return () => C();
+  }
+}), bn = T({
+  name: "PgGendersTool",
+  props: {
+    compact: Boolean
+  },
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = re(), { collection: r } = S(n);
+    function a() {
+      const c = {
+        class: "pg-genders-tool row q-col-gutter-sm flex justify-center"
+      }, d = [];
+      return r.value.forEach((u) => {
+        const f = {
+          key: u,
+          id: u,
+          compact: e.compact
+        };
+        d.push(
+          h("div", { class: "" }, [h(Wr, f)])
+        );
+      }), h("div", c, d);
+    }
+    return () => a();
+  }
+}), Xr = T({
+  name: "PgEffectsExpansion",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = re(), { caption: a } = S(r), { expanded: c } = ae({
+      options: Tt,
+      tab: Tt
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.gender;
+    });
+    function u() {
+      const f = {
+        class: "pg-effects-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: Lr
+      };
+      return h(me, f, () => h(bn, { desktop: !1 }));
+    }
+    return () => u();
+  }
+}), In = T({
+  name: "PgGridTool",
+  setup(e, { slots: t, emit: s }) {
+    const n = Ie(), { visible: r } = S(n), a = y({
+      get: () => n.spacing,
+      set: (g) => n.setSpacing(g)
+    }), c = y({
+      get: () => n.horizontal,
+      set: (g) => n.setHorizontal(g)
+    }), d = y({
+      get: () => n.vertical,
+      set: (g) => n.setVertical(g)
+    }), u = (g) => g ? n.show() : n.hide();
+    function f() {
+      const g = {
+        class: "pg-grid-tool",
+        lines: a.value,
+        "onUpdate:lines": (v) => a.value = v,
+        visible: r.value,
+        "onUpdate:visible": (v) => r.value = v,
+        horizontal: c.value,
+        "onUpdate:horizontal": (v) => c.value = v,
+        vertical: d.value,
+        "onUpdate:vertical": (v) => d.value = v,
+        onToggle: u
+      };
+      return h($o, g);
+    }
+    return () => f();
+  }
+}), Pn = T({
+  name: "PgLightsExpansion",
+  props: {
+    playMode: Boolean
+  },
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = Ie(), { caption: a } = S(r), { expanded: c } = ae({
+      options: ws,
+      tab: ws,
+      playMode: e.playMode
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.grid;
+    });
+    function u() {
+      const f = {
+        class: "pg-grid-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: "f_grid"
+      };
+      return h(me, f, () => h(In));
+    }
+    return () => u();
+  }
+}), Zr = { class: "quarters overlay" }, Qr = ["onClick", "onMouseover", "onMouseleave"], Kr = { class: "quarters borders" }, Jr = { class: "quickpose-angle" }, ei = ["src"], zs = "cps", xn = {
+  __name: "PgPosePositionTool",
+  setup(e) {
+    const t = fe(), s = re(), n = k(), { selected: r, collectedModels: a } = S(t), { collectedModels: c } = S(s), { loading: d } = S(n), u = j(null), f = y(() => {
+      const P = c.value;
+      return P.length === 2 ? Math.floor(Math.random() * 2) === 1 ? v("male") : v("female") : P.includes(110) ? v("male") : v("female");
+    }), g = y(() => n.hasAccess(zs)), v = (P) => `https://static.figurosity.com/pose-generator/position/model-${P}.webp`, C = (P) => u.value = P, _ = (P) => u.value = null, D = (P) => {
+      if (!d.value) {
+        if (g.value) {
+          t.toggleSelected(P);
+          return;
+        }
+        n.block(zs);
+      }
+    };
+    return (P, I) => (O(), $("div", {
+      class: mt(["c-pose-position", { disabled: A(d) }])
+    }, [
+      De("div", Zr, [
+        (O(!0), $(Xe, null, Ze(A(a), (b) => (O(), $("div", {
+          class: mt(["quarter", b.slug]),
+          key: b.id,
+          onClick: (x) => D(b.id),
+          onMouseover: (x) => C(b.slug),
+          onMouseleave: (x) => _(b.slug)
+        }, null, 42, Qr))), 128))
+      ]),
+      De("div", Kr, [
+        (O(!0), $(Xe, null, Ze(A(a), (b) => (O(), $("div", {
+          class: mt([
+            "quarter",
+            b.slug + (A(r).includes(b.id) ? " active" : "") + (u.value === b.slug ? " hover" : "")
+          ]),
+          key: b.id,
+          ref_for: !0,
+          ref: b.slug
+        }, [
+          De("span", null, Co(b.name), 1)
+        ], 2))), 128))
+      ]),
+      De("div", Jr, [
+        De("img", {
+          src: f.value,
+          class: ""
+        }, null, 8, ei)
+      ])
+    ], 2));
+  }
+}, ti = T({
+  name: "PgEffectsExpansion",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = fe(), { caption: a } = S(r), { expanded: c } = ae({
+      options: Ds,
+      tab: Ds
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.position;
+    });
+    function u() {
+      const f = {
+        class: "pg-position-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: Ur
+      };
+      return h(me, f, () => h(xn));
+    }
+    return () => u();
+  }
+}), wn = T({
+  name: "PgBrightnessTool",
+  props: {
+    noIcons: Boolean
+  },
+  emits: ["update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = ge(), r = y({
+      get: () => n.brightness,
+      set: (c) => n.setBrightness(c)
+    });
+    function a() {
+      const c = {
+        class: "pg-brightness-tool",
+        modelValue: r.value,
+        "onUpdate:modelValue": (d) => r.value = d,
+        noicons: !1,
+        dark: !1
+      };
+      return h(es, c);
+    }
+    return () => a();
+  }
+}), Dn = T({
+  name: "PgBrightnessTool",
+  emits: ["update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = ge(), r = y({
+      get: () => n.contrast,
+      set: (c) => n.setContrast(c)
+    });
+    function a() {
+      const c = {
+        class: "pg-contrast-tool",
+        modelValue: r.value,
+        "onUpdate:modelValue": (d) => r.value = d,
+        type: "contrast"
+      };
+      return h(es, c);
+    }
+    return () => a();
+  }
+}), Mn = T({
+  name: "PgBrightnessTool",
+  emits: ["update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = ge(), r = y({
+      get: () => n.saturate,
+      set: (c) => n.setSaturate(c)
+    });
+    function a() {
+      const c = {
+        class: "pg-saturate-tool",
+        modelValue: r.value,
+        "onUpdate:modelValue": (d) => r.value = d,
+        type: "saturate"
+      };
+      return h(es, c);
+    }
+    return () => a();
+  }
+}), An = T({
+  name: "PgEffectsExpansion",
+  props: {
+    playMode: Boolean
+  },
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = ge(), { caption: a } = S(r), { expanded: c } = ae({
+      options: Ms,
+      tab: Ms,
+      playMode: e.playMode
+    }), d = y(() => {
+      var f;
+      return (f = n.value.pg) == null ? void 0 : f.tools.adjustment;
+    });
+    function u() {
+      const f = {
+        class: "pg-adjustments-expansion",
+        modelValue: c.value,
+        "onUpdate:modelValue": (g) => c.value = g,
+        label: d.value,
+        caption: a.value,
+        icon: dn
+      };
+      return h(me, f, () => [
+        h(wn),
+        h(Dn),
+        h(Mn)
+      ]);
+    }
+    return () => u();
+  }
+}), si = T({
+  name: "PgExpansions",
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      return h("div", {
+        class: "pg-expansions"
+      }, [
+        h(Nr),
+        h(J),
+        h(En),
+        h(J),
+        h(Tn),
+        h(J),
+        h(qr),
+        h(J),
+        h(Xr),
+        h(J),
+        h(ti),
+        h(J),
+        h(Pn),
+        h(J),
+        h(Yr),
+        h(J),
+        h(An)
+      ]);
+    }
+    return () => n();
+  }
+}), ve = T({
+  name: "PgCard",
+  props: {
+    label: String,
+    caption: String,
+    icon: String,
+    count: Number
+  },
+  setup(e, { slots: t, emit: s }) {
+    y(() => e.count ? {
+      width: e.count * 110 + "px",
+      maxWidth: e.count * 110 + "px"
+    } : {
+      width: "100%"
+    });
+    function n() {
+      const r = {
+        class: "pg-card",
+        "data-cy": "pg-card-" + Do(e.label)
+        // style: style.value,
+      };
+      return h("div", r, [
+        h(
+          ko,
+          { flat: !0, bordered: !0 },
+          {
+            default: () => [
+              h(Lo, {}, () => [
+                h(As, { avatar: !0 }, () => [
+                  h(Vo, { name: e.icon, size: "36px" })
+                ]),
+                h(As, {}, () => [
+                  h(Ns, { class: "pg-card-label" }, () => e.label),
+                  h(
+                    Ns,
+                    { class: "pg-card-caption", caption: !0 },
+                    () => e.caption
+                  )
+                ])
+              ]),
+              h(Uo, null, {
+                default: () => t.default ? t.default() : []
+              })
+            ]
+          }
+        )
+      ]);
+    }
+    return () => n();
+  }
+}), ni = T({
+  name: "PgDurationCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = Z(), { title: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.duration;
+    });
+    function d() {
+      const u = {
+        class: "pg-duration-card",
+        label: c.value,
+        caption: a.value,
+        icon: cn
+      };
+      return h(ve, u, () => h(yn, {}));
+    }
+    return () => d();
+  }
+}), oi = T({
+  name: "PgSkinsCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = V(), a = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.skins;
+    }), c = y(() => r.caption);
+    function d() {
+      const u = {
+        class: "pg-skins-card",
+        label: a.value,
+        caption: c.value,
+        icon: jo
+      };
+      return h(ve, u, {
+        default: () => h(ts, { desktop: !0 })
+      });
+    }
+    return () => d();
+  }
+}), ri = T({
+  name: "PgEffectsCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = R(), a = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.effects;
+    }), c = y(() => r.caption);
+    function d() {
+      const u = {
+        class: "pg-skins-card",
+        label: a.value,
+        caption: c.value,
+        icon: un
+      };
+      return h(ve, u, () => [h(Sn, { desktop: !0 })]);
+    }
+    return () => d();
+  }
+}), ii = T({
+  name: "PgCameraAnglesCard",
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = pe(), { caption: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.angle;
+    });
+    function d() {
+      const u = {
+        class: "pg-cameras-card",
+        label: c.value,
+        caption: a.value,
+        icon: Go
+      };
+      return h(ve, u, () => [h(Cn)]);
+    }
+    return () => d();
+  }
+}), ai = T({
+  name: "PgLightsCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = ee(), { caption: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.light;
+    });
+    function d() {
+      const u = {
+        class: "pg-lights-card",
+        label: c.value,
+        caption: a.value,
+        icon: Yo
+      };
+      return h(ve, u, {
+        default: () => h(_n, { desktop: !0 })
+      });
+    }
+    return () => d();
+  }
+}), li = T({
+  name: "PgGendersCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = re(), { caption: a } = S(r);
+    ae({
+      options: Tt,
+      tab: Tt
+    });
+    const c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.gender;
+    });
+    function d() {
+      const u = {
+        class: "pg-genders-card",
+        label: c.value,
+        caption: a.value,
+        icon: Wo
+      };
+      return h(ve, u, () => [h(bn)]);
+    }
+    return () => d();
+  }
+}), ci = T({
+  name: "PgPosePositionCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = fe(), { caption: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.position;
+    });
+    function d() {
+      const u = {
+        class: "pg-pose-position-card",
+        label: c.value,
+        caption: a.value,
+        icon: Xo
+      };
+      return h(ve, u, {
+        default: () => h(xn)
+      });
+    }
+    return () => d();
+  }
+}), ui = T({
+  name: "PgGridCard",
+  props: {
+    modelValue: { type: Number, default: 0 },
+    "onUpdate:modelValue": [Function, Array],
+    label: { type: String, required: !1 }
+  },
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = Ie(), { caption: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.grid;
+    });
+    function d() {
+      const u = {
+        class: "pg-grid-card",
+        label: c.value,
+        caption: a.value,
+        icon: Zo
+      };
+      return h(ve, u, { default: () => h(In) });
+    }
+    return () => d();
+  }
+}), di = T({
+  name: "PgAdjustmentsTool",
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      return h("div", {
+        class: "pg-adjustments-tool"
+      }, [
+        h(wn),
+        h(Dn),
+        h(Mn)
+      ]);
+    }
+    return () => n();
+  }
+}), hi = T({
+  name: "PgAdjustmentsCard",
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = ge(), { caption: a } = S(r), c = y(() => {
+      var u;
+      return (u = n.value.pg) == null ? void 0 : u.tools.adjustment;
+    });
+    function d() {
+      const u = {
+        class: "pg-adjustments-card",
+        label: c.value,
+        caption: a.value,
+        icon: dn
+      };
+      return h(ve, u, () => [h(di)]);
+    }
+    return () => d();
+  }
+}), Nn = T({
+  name: "PgOverviewContent",
+  props: {
+    size: { default: "lg", type: String }
+  },
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = y(
+      () => n.value && n.value.pg ? n.value.pg.overview.title : "s"
+    ), a = y(
+      () => n.value && n.value.pg ? n.value.pg.overview.heading : ""
+    );
+    function c() {
+      const u = {
+        class: y(() => ({
+          "pg-overview-content": !0
+        })).value
+      }, f = {}, g = { class: "text-subheading" };
+      return h("div", u, [
+        h("h1", f, r.value),
+        h("div", g, a.value)
+      ]);
+    }
+    return () => c();
+  }
+}), pi = T({
+  name: "PgCards",
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      return h("div", {
+        class: "pg-cards col q-col-gutter-md q-pa-md",
+        style: "max-width: 1024px;width: 100%;margin: auto;"
+      }, [
+        h("div", { class: "row q-col-gutter-md" }, [
+          h("div", { class: "col-7" }, h(Nn)),
+          h("div", { class: "col-5" }, [h(ni)])
+        ]),
+        h("div", { class: "row q-col-gutter-md" }, [
+          h(oi, { class: "col-7" }),
+          h(ri, { class: "col-5" })
+        ]),
+        h("div", { class: "row q-col-gutter-md" }, [
+          h(ii, { class: "col-6" }),
+          h(ai, { class: "col-3" }),
+          h(li, { class: "col-3" })
+        ]),
+        h("div", { class: "row q-col-gutter-md" }, [
+          h(ci, { class: "col-4" }),
+          h(ui, { class: "col-4" }),
+          h(hi, { class: "col-4" })
+        ])
+      ]);
+    }
+    return () => n();
+  }
+}), fi = T({
+  name: "PgAnimatedCount",
+  emits: ["click", "update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = Pt(), r = k(), { filtering: a } = S(r), { lang: c } = M(), d = y(() => {
+      var g;
+      return (g = c.value.pg) == null ? void 0 : g.possibilities.title;
+    }), { adjustedCount: u } = S(n);
+    function f() {
+      const g = {
+        class: "pg-animated-count q-pa-sm",
+        style: "font-weight: 900;color: #979797;font-size: 18px;"
+      }, v = {
+        total: u.value,
+        loading: a.value,
+        class: ""
+      };
+      return h("div", g, [
+        h(zo, v),
+        h("span", {}, " " + d.value)
+      ]);
+    }
+    return () => f();
+  }
+}), gi = T({
+  name: "PgBottomButtons",
+  setup(e, { slots: t, emit: s }) {
+    const n = Te(), r = Pt(), a = k(), c = (I) => a.customReset(), d = (I) => n.open(), {
+      filters: u,
+      adjustedCount: f,
+      loading: g,
+      error: v
+    } = S(r), { lang: C } = M(), _ = y(() => {
+      var I;
+      return (I = C.value.pg) == null ? void 0 : I.overview.startLabel;
+    }), D = y(() => {
+      var I;
+      return (I = C.value.pg) == null ? void 0 : I.overview.resetLabel;
+    });
+    Ne(
+      () => u.value,
+      () => {
+        r.fetchForDisplay();
+      },
+      { immediate: !0 }
+    );
+    function P() {
+      const I = {
+        class: "pg-buttons q-col-gutter-sm q-pa-md row"
+      }, b = {
+        class: "q-px-lg",
+        size: "md",
+        color: "primary",
+        rounded: !0,
+        unelevated: !0
+      }, x = {
+        ...b,
+        label: _.value,
+        onClick: d,
+        disabled: g.value,
+        "data-cy": "pg-button-start"
+      }, F = {
+        ...b,
+        label: D.value,
+        outline: !0,
+        onClick: c,
+        disabled: g.value,
+        "data-cy": "pg-button-reset"
+      };
+      return h("div", I, [
+        h("div", { class: "col col-sm-auto text-center" }, [
+          h(Oe, F)
+        ]),
+        h("div", { class: "col col-sm-auto text-center" }, [
+          h(Oe, x)
+        ])
+      ]);
+    }
+    return () => P();
+  }
+}), On = T({
+  name: "PgGridOverlay",
+  setup(e, { slots: t, emit: s }) {
+    const n = It(), r = on(), a = Ie(), {
+      visible: c,
+      spacing: d,
+      horizontal: u,
+      vertical: f
+    } = S(a), g = j({
+      width: 0,
+      height: 0
+    }), v = y(() => {
+      const I = g.value;
+      return I.width < I.height ? I.width : I.height;
+    }), C = y(() => {
+      const I = v.value;
+      return { width: I, height: I };
+    }), _ = y(() => {
+      const I = g.value, b = I.width, x = I.height;
+      let F = 0, le = 0;
+      return b > x && (le = (b - x) / 2), x > b && (F = (x - b) / 2), { top: F, left: le };
+    }), D = (I) => {
+      g.value = I;
+    };
+    bt(() => {
+      console.log("Ext bus exists?", !!r, "id:", r && r.__bus_id), r.$on("resize", D), r.$emit("resize", {
+        width: window.innerWidth,
+        height: window.innerHeight
+      }), g.value = { width: n.screen.width, height: n.screen.height };
+    }), Jt(() => r.$off("resize"));
+    function P() {
+      const I = {
+        class: "pg-grid-overlay",
+        style: "z-index: 8",
+        visible: c.value,
+        lines: d.value,
+        offsetX: u.value / 100,
+        offsetY: f.value / 100,
+        imagePoint: _.value,
+        imageSize: C.value,
+        viewportSize: g.value
+      };
+      return h(Ho, I);
+    }
+    return () => P();
+  }
+}), mi = T({
+  name: "PgOverviewButtons",
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      const r = {
+        class: "pg-overview-buttons col-auto bg-white"
+      }, a = {
+        class: "col-sm-6 col-12 column justify-center"
+      }, c = {
+        class: "col-sm-6 col-12"
+      };
+      return h(
+        "div",
+        r,
+        h(
+          "div",
+          {
+            class: "row",
+            style: "max-width: 1024px; margin: auto;"
+          },
+          [
+            h("div", a, h(fi)),
+            h("div", c, h(gi))
+          ]
+        )
+      );
+    }
+    return () => n();
+  }
+}), vi = { class: "column pg-overview full-width q-pt-lg" }, yi = {
+  __name: "PgOverview",
+  setup(e) {
+    return (t, s) => (O(), $("div", vi, [
+      B(A(On)),
+      B(A(pi), { class: "col full-height gt-sm" }),
+      B(A(Nn), {
+        class: "lt-md",
+        style: { height: "200px" }
+      }),
+      B(A(si), {
+        class: "lt-md",
+        style: { "z-index": "9" }
+      }),
+      B(A(mi))
+    ]));
+  }
+}, Ei = T({
+  name: "PgExitButton",
+  props: {
+    show: {
+      type: Boolean,
+      default: !0
+    }
+  },
+  setup(e, { slots: t, emit: s }) {
+    const n = Te(), { lang: r } = M(), a = y(() => {
+      var u;
+      return (u = r.value.pg) == null ? void 0 : u.buttons.exit.title;
+    }), c = (u) => u.preventDefault();
+    function d() {
+      const u = {
+        style: "z-index: 1800; transform: translate(0, 0)",
+        position: "top-right",
+        offset: [18, 18]
+      }, f = {
+        class: "pg-button-exit",
+        "data-cy": "pg-button-exit",
+        label: a.value,
+        icon: Qo,
+        onClick: n.close,
+        color: "primary",
+        onKeyup: c,
+        rounded: !0,
+        unelevated: !0,
+        outline: !0,
+        style: "background-color: #fff!important"
+      };
+      return h(
+        qt,
+        { name: "fade" },
+        () => vt(
+          h(Ro, u, () => [h(Oe, f)]),
+          [[yt, e.show]]
+        )
+      );
+    }
+    return () => d();
+  }
+}), ss = T({
+  name: "PgBaseButton",
+  props: {
+    type: String,
+    disable: Boolean,
+    icon: String,
+    outline: Boolean
+  },
+  emits: ["click"],
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      const r = {
+        class: `pg-base-button pg-${e.type}-button`,
+        onClick: () => s("click"),
+        disabled: e.disable,
+        icon: e.icon,
+        outline: e.outline,
+        unelevated: !0,
+        flat: !e.outline,
+        round: !0
+      };
+      return h("div", {}, [
+        h(Oe, r, { default: () => {
+          var a;
+          return (a = t.default) == null ? void 0 : a.call(t);
+        } })
+      ]);
+    }
+    return () => n();
+  }
+}), Si = T({
+  name: "PgNextButton",
+  setup(e, { slots: t, emit: s }) {
+    const n = Te(), { nextDisabled: r } = S(n);
+    function a() {
+      const c = {
+        type: "next",
+        icon: $r,
+        onClick: n.next,
+        disable: r.value
+      };
+      return h(ss, c);
+    }
+    return () => a();
+  }
+}), Ti = T({
+  name: "PgNextButton",
+  setup(e, { slots: t, emit: s }) {
+    const n = he(), r = Z(), { milliseconds: a } = S(n), { duration: c } = S(r), d = Te(), { playing: u } = S(n), f = y(() => u.value ? Ko : Jo), g = () => u.value ? d.pause() : d.play();
+    function v() {
+      const C = {
+        type: "play",
+        icon: f.value,
+        outline: !0,
+        onClick: g
+      }, _ = {
+        class: "pg-timer-progress",
+        min: 0,
+        max: (c.value - 1) * 1e3,
+        value: a.value,
+        size: "42px",
+        color: "primary",
+        thickness: 0.2,
+        instantFeedback: !0
+      };
+      return h(ss, C, () => [h(Bo, _)]);
+    }
+    return () => v();
+  }
+}), Ci = T({
+  name: "PgPreviousButton",
+  setup(e, { slots: t, emit: s }) {
+    const n = Te(), { previousDisabled: r } = S(n);
+    function a() {
+      const c = {
+        type: "previous",
+        icon: Br,
+        onClick: n.previous,
+        disable: r.value
+      };
+      return h(ss, c);
+    }
+    return () => a();
+  }
+}), _i = T({
+  name: "PgTimer",
+  setup(e, { slots: t, emit: s }) {
+    const n = he(), r = Z(), { formatted: a, milliseconds: c } = S(n), { duration: d } = S(r), u = y(() => {
+      let C = d.value * 1e3 - 300, _ = d.value * 1e3 - 600;
+      return c.value < C && c.value > _;
+    }), f = y(() => {
+      let C = 40;
+      return d.value > 60 && (C = 65), d.value >= 600 && (C = 85), { width: `${C}px` };
+    }), g = y(() => ({
+      "pg-timer-seconds": !0,
+      flash: u.value
+    }));
+    function v() {
+      const C = {
+        class: g.value,
+        style: f.value
+      };
+      return h("div", C, a.value);
+    }
+    return () => v();
+  }
+}), kn = T({
+  name: "PgControls",
+  props: { center: Boolean },
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      const r = {
+        class: "pg-controls row q-gutter-xs position-relative"
+      };
+      e.center && (r.class = r.class + " justify-center");
+      const a = [];
+      return a.push(h(Ci)), a.push(h(Ti)), a.push(h(Si)), a.push(h(_i)), h("div", r, a);
+    }
+    return () => n();
+  }
+}), Ln = T({
+  name: "PgView360",
+  setup(e, { slots: t, emit: s }) {
+    const n = X(), { lang: r } = M(), a = y(() => {
+      var d;
+      return (d = r.value.pg) == null ? void 0 : d.buttons.view360.title;
+    });
+    function c() {
+      const { view360Path: d } = S(n), u = {
+        class: "pg-view360",
+        "data-cy": "pg-button-view360",
+        label: a.value,
+        to: d.value,
+        rounded: !0,
+        outline: !0,
+        color: "primary"
+      };
+      return h(Oe, u);
+    }
+    return () => c();
+  }
+}), Vn = T({
+  name: "PgPlayExpansions",
+  setup(e, { slots: t, emit: s }) {
+    const n = It();
+    function r() {
+      const a = j(n.platform.is.desktop), c = {
+        class: "pg-play-expansions"
+      }, d = [];
+      return a.value && (d.push(h(En, { playMode: !0 })), d.push(h(J))), d.push(h(Tn, { playMode: !0 })), d.push(h(J)), d.push(h(Pn, { playMode: !0 })), d.push(h(J)), d.push(h(An, { playMode: !0 })), a.value && d.push(h("div", { class: "q-pa-lg" }, [h(Ln)])), h("div", c, d);
+    }
+    return () => r();
+  }
+}), bi = T({
+  name: "PgModalControls",
+  props: {
+    modelValue: Boolean,
+    "onUpdate:modelValue": [Function, Array]
+  },
+  emits: ["update:modelValue"],
+  setup(e, { slots: t, emit: s }) {
+    const n = y({
+      get: () => e.modelValue,
+      set: (a) => s("update:modelValue", a)
+    });
+    function r() {
+      const a = {
+        class: "pg-modal-controls",
+        modelValue: n.value,
+        topOffset: 80,
+        "onUpdate:modelValue": (c) => n.value = c
+      };
+      return h(Fo, a, {
+        default: () => h(kn),
+        expanded: () => h(Vn)
+      });
+    }
+    return () => r();
+  }
+}), Ii = ["src"], Pi = {
+  __name: "PgDisplayImage",
+  props: {
+    flipped: Boolean,
+    zIndex: Number
+  },
+  setup(e) {
+    const t = X(), s = on(), n = e, r = y(() => t.playSrc), a = j(null), c = y(() => {
+      const f = {
+        // ...filterStyle.value,
+        zIndex: n.zIndex + 2
+      };
+      if (a.value === null)
+        return f;
+      const g = a.value ? "auto" : "100%", v = a.value ? "100%" : "auto";
+      return {
+        ...f,
+        width: g,
+        height: v
+      };
+    }), d = (f) => {
+      a.value = f.width > f.height;
+    };
+    function u() {
+      const f = window, g = document, v = g.documentElement, C = g.getElementsByTagName("body")[0], _ = f.innerWidth || v.clientWidth || C.clientWidth, D = f.innerHeight || v.clientHeight || C.clientHeight;
+      d({ width: _, height: D });
+    }
+    return bt(() => {
+      u(), s.$on("resize", d);
+    }), Jt(() => s.$off("resize")), (f, g) => (O(), $("img", {
+      src: r.value,
+      class: mt(["pg-display-image", { "flip-horizontal": e.flipped }]),
+      style: nn(c.value)
+    }, null, 14, Ii));
+  }
+}, xi = {
+  __name: "PgDisplay",
+  setup(e) {
+    const t = ge(), s = X();
+    Pe();
+    const n = R(), { playSelected: r } = S(n), { brightness: a, contrast: c, saturate: d } = S(t), { filterStyle: u } = Mo({
+      brightness: a,
+      contrast: c,
+      saturate: d,
+      noTranslate: !0
+    }), f = y(() => ({
+      ...u.value,
+      backgroundColor: r.value === 3 ? "#000000" : "#ffffff"
+    })), { current: g } = S(s), v = j([]), C = j(1);
+    return Ne(
+      () => {
+        var _, D, P;
+        return [(_ = g.value) == null ? void 0 : _.id, (D = g.value) == null ? void 0 : D.src, (P = g.value) == null ? void 0 : P.status];
+      },
+      ([_, D, P], I, b) => {
+        if (!(P === gn && D)) return;
+        const x = _.split("."), F = _ ?? `${D}#${Date.now()}`;
+        v.value = [
+          ...v.value,
+          { key: F, src: D, zIndex: C.value, flipped: x[2] === "1" }
+        ], C.value++, v.value.length > 1 && (v.value = v.value.slice(-1));
+      },
+      { immediate: !0 }
+    ), (_, D) => (O(), $("div", {
+      class: "pg-display",
+      style: nn(f.value)
+    }, [
+      B(_o, { name: "pgfade" }, {
+        default: jt(() => [
+          (O(!0), $(Xe, null, Ze(v.value, (P, I) => (O(), _t(Pi, {
+            key: P.key,
+            zIndex: parseInt(P.zIndex),
+            flipped: P.flipped
+          }, null, 8, ["zIndex", "flipped"]))), 128))
+        ]),
+        _: 1
+      })
+    ], 4));
+  }
+};
+var Ht = { exports: {} };
+/*! Hammer.JS - v2.0.7 - 2016-04-22
+ * http://hammerjs.github.io/
+ *
+ * Copyright (c) 2016 Jorik Tangelder;
+ * Licensed under the MIT license */
+var Hs;
+function wi() {
+  return Hs || (Hs = 1, (function(e) {
+    (function(t, s, n, r) {
+      var a = ["", "webkit", "Moz", "MS", "ms", "o"], c = s.createElement("div"), d = "function", u = Math.round, f = Math.abs, g = Date.now;
+      function v(o, i, l) {
+        return setTimeout(F(o, l), i);
+      }
+      function C(o, i, l) {
+        return Array.isArray(o) ? (_(o, l[i], l), !0) : !1;
+      }
+      function _(o, i, l) {
+        var p;
+        if (o)
+          if (o.forEach)
+            o.forEach(i, l);
+          else if (o.length !== r)
+            for (p = 0; p < o.length; )
+              i.call(l, o[p], p, o), p++;
+          else
+            for (p in o)
+              o.hasOwnProperty(p) && i.call(l, o[p], p, o);
+      }
+      function D(o, i, l) {
+        var p = "DEPRECATED METHOD: " + i + `
+` + l + ` AT 
+`;
+        return function() {
+          var m = new Error("get-stack-trace"), E = m && m.stack ? m.stack.replace(/^[^\(]+?[\n$]/gm, "").replace(/^\s+at\s+/gm, "").replace(/^Object.<anonymous>\s*\(/gm, "{anonymous}()@") : "Unknown Stack Trace", w = t.console && (t.console.warn || t.console.log);
+          return w && w.call(t.console, p, E), o.apply(this, arguments);
+        };
+      }
+      var P;
+      typeof Object.assign != "function" ? P = function(i) {
+        if (i === r || i === null)
+          throw new TypeError("Cannot convert undefined or null to object");
+        for (var l = Object(i), p = 1; p < arguments.length; p++) {
+          var m = arguments[p];
+          if (m !== r && m !== null)
+            for (var E in m)
+              m.hasOwnProperty(E) && (l[E] = m[E]);
+        }
+        return l;
+      } : P = Object.assign;
+      var I = D(function(i, l, p) {
+        for (var m = Object.keys(l), E = 0; E < m.length; )
+          (!p || p && i[m[E]] === r) && (i[m[E]] = l[m[E]]), E++;
+        return i;
+      }, "extend", "Use `assign`."), b = D(function(i, l) {
+        return I(i, l, !0);
+      }, "merge", "Use `assign`.");
+      function x(o, i, l) {
+        var p = i.prototype, m;
+        m = o.prototype = Object.create(p), m.constructor = o, m._super = p, l && P(m, l);
+      }
+      function F(o, i) {
+        return function() {
+          return o.apply(i, arguments);
+        };
+      }
+      function le(o, i) {
+        return typeof o == d ? o.apply(i && i[0] || r, i) : o;
+      }
+      function Ve(o, i) {
+        return o === r ? i : o;
+      }
+      function ye(o, i, l) {
+        _(Je(i), function(p) {
+          o.addEventListener(p, l, !1);
+        });
+      }
+      function Q(o, i, l) {
+        _(Je(i), function(p) {
+          o.removeEventListener(p, l, !1);
+        });
+      }
+      function ce(o, i) {
+        for (; o; ) {
+          if (o == i)
+            return !0;
+          o = o.parentNode;
+        }
+        return !1;
+      }
+      function G(o, i) {
+        return o.indexOf(i) > -1;
+      }
+      function Je(o) {
+        return o.trim().split(/\s+/g);
+      }
+      function xe(o, i, l) {
+        if (o.indexOf && !l)
+          return o.indexOf(i);
+        for (var p = 0; p < o.length; ) {
+          if (l && o[p][l] == i || !l && o[p] === i)
+            return p;
+          p++;
+        }
+        return -1;
+      }
+      function et(o) {
+        return Array.prototype.slice.call(o, 0);
+      }
+      function os(o, i, l) {
+        for (var p = [], m = [], E = 0; E < o.length; ) {
+          var w = o[E][i];
+          xe(m, w) < 0 && p.push(o[E]), m[E] = w, E++;
+        }
+        return p = p.sort(function(U, H) {
+          return U[i] > H[i];
+        }), p;
+      }
+      function tt(o, i) {
+        for (var l, p, m = i[0].toUpperCase() + i.slice(1), E = 0; E < a.length; ) {
+          if (l = a[E], p = l ? l + m : i, p in o)
+            return p;
+          E++;
+        }
+        return r;
+      }
+      var Bn = 1;
+      function $n() {
+        return Bn++;
+      }
+      function rs(o) {
+        var i = o.ownerDocument || o;
+        return i.defaultView || i.parentWindow || t;
+      }
+      var zn = /mobile|tablet|ip(ad|hone|od)|android/i, is = "ontouchstart" in t, Hn = tt(t, "PointerEvent") !== r, Fn = is && zn.test(navigator.userAgent), Ue = "touch", qn = "pen", Dt = "mouse", jn = "kinect", Gn = 25, z = 1, Ce = 2, N = 4, q = 8, st = 1, Re = 2, Be = 4, $e = 8, ze = 16, te = Re | Be, _e = $e | ze, as = te | _e, ls = ["x", "y"], nt = ["clientX", "clientY"];
+      function Y(o, i) {
+        var l = this;
+        this.manager = o, this.callback = i, this.element = o.element, this.target = o.options.inputTarget, this.domHandler = function(p) {
+          le(o.options.enable, [o]) && l.handler(p);
+        }, this.init();
+      }
+      Y.prototype = {
+        /**
+         * should handle the inputEvent data and trigger the callback
+         * @virtual
+         */
+        handler: function() {
+        },
+        /**
+         * bind the events
+         */
+        init: function() {
+          this.evEl && ye(this.element, this.evEl, this.domHandler), this.evTarget && ye(this.target, this.evTarget, this.domHandler), this.evWin && ye(rs(this.element), this.evWin, this.domHandler);
+        },
+        /**
+         * unbind the events
+         */
+        destroy: function() {
+          this.evEl && Q(this.element, this.evEl, this.domHandler), this.evTarget && Q(this.target, this.evTarget, this.domHandler), this.evWin && Q(rs(this.element), this.evWin, this.domHandler);
+        }
+      };
+      function Yn(o) {
+        var i, l = o.options.inputClass;
+        return l ? i = l : Hn ? i = At : Fn ? i = it : is ? i = Nt : i = rt, new i(o, Wn);
+      }
+      function Wn(o, i, l) {
+        var p = l.pointers.length, m = l.changedPointers.length, E = i & z && p - m === 0, w = i & (N | q) && p - m === 0;
+        l.isFirst = !!E, l.isFinal = !!w, E && (o.session = {}), l.eventType = i, Xn(o, l), o.emit("hammer.input", l), o.recognize(l), o.session.prevInput = l;
+      }
+      function Xn(o, i) {
+        var l = o.session, p = i.pointers, m = p.length;
+        l.firstInput || (l.firstInput = cs(i)), m > 1 && !l.firstMultiple ? l.firstMultiple = cs(i) : m === 1 && (l.firstMultiple = !1);
+        var E = l.firstInput, w = l.firstMultiple, L = w ? w.center : E.center, U = i.center = us(p);
+        i.timeStamp = g(), i.deltaTime = i.timeStamp - E.timeStamp, i.angle = Mt(L, U), i.distance = ot(L, U), Zn(l, i), i.offsetDirection = hs(i.deltaX, i.deltaY);
+        var H = ds(i.deltaTime, i.deltaX, i.deltaY);
+        i.overallVelocityX = H.x, i.overallVelocityY = H.y, i.overallVelocity = f(H.x) > f(H.y) ? H.x : H.y, i.scale = w ? Jn(w.pointers, p) : 1, i.rotation = w ? Kn(w.pointers, p) : 0, i.maxPointers = l.prevInput ? i.pointers.length > l.prevInput.maxPointers ? i.pointers.length : l.prevInput.maxPointers : i.pointers.length, Qn(l, i);
+        var ne = o.element;
+        ce(i.srcEvent.target, ne) && (ne = i.srcEvent.target), i.target = ne;
+      }
+      function Zn(o, i) {
+        var l = i.center, p = o.offsetDelta || {}, m = o.prevDelta || {}, E = o.prevInput || {};
+        (i.eventType === z || E.eventType === N) && (m = o.prevDelta = {
+          x: E.deltaX || 0,
+          y: E.deltaY || 0
+        }, p = o.offsetDelta = {
+          x: l.x,
+          y: l.y
+        }), i.deltaX = m.x + (l.x - p.x), i.deltaY = m.y + (l.y - p.y);
+      }
+      function Qn(o, i) {
+        var l = o.lastInterval || i, p = i.timeStamp - l.timeStamp, m, E, w, L;
+        if (i.eventType != q && (p > Gn || l.velocity === r)) {
+          var U = i.deltaX - l.deltaX, H = i.deltaY - l.deltaY, ne = ds(p, U, H);
+          E = ne.x, w = ne.y, m = f(ne.x) > f(ne.y) ? ne.x : ne.y, L = hs(U, H), o.lastInterval = i;
+        } else
+          m = l.velocity, E = l.velocityX, w = l.velocityY, L = l.direction;
+        i.velocity = m, i.velocityX = E, i.velocityY = w, i.direction = L;
+      }
+      function cs(o) {
+        for (var i = [], l = 0; l < o.pointers.length; )
+          i[l] = {
+            clientX: u(o.pointers[l].clientX),
+            clientY: u(o.pointers[l].clientY)
+          }, l++;
+        return {
+          timeStamp: g(),
+          pointers: i,
+          center: us(i),
+          deltaX: o.deltaX,
+          deltaY: o.deltaY
+        };
+      }
+      function us(o) {
+        var i = o.length;
+        if (i === 1)
+          return {
+            x: u(o[0].clientX),
+            y: u(o[0].clientY)
+          };
+        for (var l = 0, p = 0, m = 0; m < i; )
+          l += o[m].clientX, p += o[m].clientY, m++;
+        return {
+          x: u(l / i),
+          y: u(p / i)
+        };
+      }
+      function ds(o, i, l) {
+        return {
+          x: i / o || 0,
+          y: l / o || 0
+        };
+      }
+      function hs(o, i) {
+        return o === i ? st : f(o) >= f(i) ? o < 0 ? Re : Be : i < 0 ? $e : ze;
+      }
+      function ot(o, i, l) {
+        l || (l = ls);
+        var p = i[l[0]] - o[l[0]], m = i[l[1]] - o[l[1]];
+        return Math.sqrt(p * p + m * m);
+      }
+      function Mt(o, i, l) {
+        l || (l = ls);
+        var p = i[l[0]] - o[l[0]], m = i[l[1]] - o[l[1]];
+        return Math.atan2(m, p) * 180 / Math.PI;
+      }
+      function Kn(o, i) {
+        return Mt(i[1], i[0], nt) + Mt(o[1], o[0], nt);
+      }
+      function Jn(o, i) {
+        return ot(i[0], i[1], nt) / ot(o[0], o[1], nt);
+      }
+      var eo = {
+        mousedown: z,
+        mousemove: Ce,
+        mouseup: N
+      }, to = "mousedown", so = "mousemove mouseup";
+      function rt() {
+        this.evEl = to, this.evWin = so, this.pressed = !1, Y.apply(this, arguments);
+      }
+      x(rt, Y, {
+        /**
+         * handle mouse events
+         * @param {Object} ev
+         */
+        handler: function(i) {
+          var l = eo[i.type];
+          l & z && i.button === 0 && (this.pressed = !0), l & Ce && i.which !== 1 && (l = N), this.pressed && (l & N && (this.pressed = !1), this.callback(this.manager, l, {
+            pointers: [i],
+            changedPointers: [i],
+            pointerType: Dt,
+            srcEvent: i
+          }));
+        }
+      });
+      var no = {
+        pointerdown: z,
+        pointermove: Ce,
+        pointerup: N,
+        pointercancel: q,
+        pointerout: q
+      }, oo = {
+        2: Ue,
+        3: qn,
+        4: Dt,
+        5: jn
+        // see https://twitter.com/jacobrossi/status/480596438489890816
+      }, ps = "pointerdown", fs = "pointermove pointerup pointercancel";
+      t.MSPointerEvent && !t.PointerEvent && (ps = "MSPointerDown", fs = "MSPointerMove MSPointerUp MSPointerCancel");
+      function At() {
+        this.evEl = ps, this.evWin = fs, Y.apply(this, arguments), this.store = this.manager.session.pointerEvents = [];
+      }
+      x(At, Y, {
+        /**
+         * handle mouse events
+         * @param {Object} ev
+         */
+        handler: function(i) {
+          var l = this.store, p = !1, m = i.type.toLowerCase().replace("ms", ""), E = no[m], w = oo[i.pointerType] || i.pointerType, L = w == Ue, U = xe(l, i.pointerId, "pointerId");
+          E & z && (i.button === 0 || L) ? U < 0 && (l.push(i), U = l.length - 1) : E & (N | q) && (p = !0), !(U < 0) && (l[U] = i, this.callback(this.manager, E, {
+            pointers: l,
+            changedPointers: [i],
+            pointerType: w,
+            srcEvent: i
+          }), p && l.splice(U, 1));
+        }
+      });
+      var ro = {
+        touchstart: z,
+        touchmove: Ce,
+        touchend: N,
+        touchcancel: q
+      }, io = "touchstart", ao = "touchstart touchmove touchend touchcancel";
+      function gs() {
+        this.evTarget = io, this.evWin = ao, this.started = !1, Y.apply(this, arguments);
+      }
+      x(gs, Y, {
+        handler: function(i) {
+          var l = ro[i.type];
+          if (l === z && (this.started = !0), !!this.started) {
+            var p = lo.call(this, i, l);
+            l & (N | q) && p[0].length - p[1].length === 0 && (this.started = !1), this.callback(this.manager, l, {
+              pointers: p[0],
+              changedPointers: p[1],
+              pointerType: Ue,
+              srcEvent: i
+            });
+          }
+        }
+      });
+      function lo(o, i) {
+        var l = et(o.touches), p = et(o.changedTouches);
+        return i & (N | q) && (l = os(l.concat(p), "identifier")), [l, p];
+      }
+      var co = {
+        touchstart: z,
+        touchmove: Ce,
+        touchend: N,
+        touchcancel: q
+      }, uo = "touchstart touchmove touchend touchcancel";
+      function it() {
+        this.evTarget = uo, this.targetIds = {}, Y.apply(this, arguments);
+      }
+      x(it, Y, {
+        handler: function(i) {
+          var l = co[i.type], p = ho.call(this, i, l);
+          p && this.callback(this.manager, l, {
+            pointers: p[0],
+            changedPointers: p[1],
+            pointerType: Ue,
+            srcEvent: i
+          });
+        }
+      });
+      function ho(o, i) {
+        var l = et(o.touches), p = this.targetIds;
+        if (i & (z | Ce) && l.length === 1)
+          return p[l[0].identifier] = !0, [l, l];
+        var m, E, w = et(o.changedTouches), L = [], U = this.target;
+        if (E = l.filter(function(H) {
+          return ce(H.target, U);
+        }), i === z)
+          for (m = 0; m < E.length; )
+            p[E[m].identifier] = !0, m++;
+        for (m = 0; m < w.length; )
+          p[w[m].identifier] && L.push(w[m]), i & (N | q) && delete p[w[m].identifier], m++;
+        if (L.length)
+          return [
+            // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
+            os(E.concat(L), "identifier"),
+            L
+          ];
+      }
+      var po = 2500, ms = 25;
+      function Nt() {
+        Y.apply(this, arguments);
+        var o = F(this.handler, this);
+        this.touch = new it(this.manager, o), this.mouse = new rt(this.manager, o), this.primaryTouch = null, this.lastTouches = [];
+      }
+      x(Nt, Y, {
+        /**
+         * handle mouse and touch events
+         * @param {Hammer} manager
+         * @param {String} inputEvent
+         * @param {Object} inputData
+         */
+        handler: function(i, l, p) {
+          var m = p.pointerType == Ue, E = p.pointerType == Dt;
+          if (!(E && p.sourceCapabilities && p.sourceCapabilities.firesTouchEvents)) {
+            if (m)
+              fo.call(this, l, p);
+            else if (E && go.call(this, p))
+              return;
+            this.callback(i, l, p);
+          }
+        },
+        /**
+         * remove the event listeners
+         */
+        destroy: function() {
+          this.touch.destroy(), this.mouse.destroy();
+        }
+      });
+      function fo(o, i) {
+        o & z ? (this.primaryTouch = i.changedPointers[0].identifier, vs.call(this, i)) : o & (N | q) && vs.call(this, i);
+      }
+      function vs(o) {
+        var i = o.changedPointers[0];
+        if (i.identifier === this.primaryTouch) {
+          var l = { x: i.clientX, y: i.clientY };
+          this.lastTouches.push(l);
+          var p = this.lastTouches, m = function() {
+            var E = p.indexOf(l);
+            E > -1 && p.splice(E, 1);
+          };
+          setTimeout(m, po);
+        }
+      }
+      function go(o) {
+        for (var i = o.srcEvent.clientX, l = o.srcEvent.clientY, p = 0; p < this.lastTouches.length; p++) {
+          var m = this.lastTouches[p], E = Math.abs(i - m.x), w = Math.abs(l - m.y);
+          if (E <= ms && w <= ms)
+            return !0;
+        }
+        return !1;
+      }
+      var ys = tt(c.style, "touchAction"), Es = ys !== r, Ss = "compute", Ts = "auto", Ot = "manipulation", be = "none", He = "pan-x", Fe = "pan-y", at = vo();
+      function kt(o, i) {
+        this.manager = o, this.set(i);
+      }
+      kt.prototype = {
+        /**
+         * set the touchAction value on the element or enable the polyfill
+         * @param {String} value
+         */
+        set: function(o) {
+          o == Ss && (o = this.compute()), Es && this.manager.element.style && at[o] && (this.manager.element.style[ys] = o), this.actions = o.toLowerCase().trim();
+        },
+        /**
+         * just re-set the touchAction value
+         */
+        update: function() {
+          this.set(this.manager.options.touchAction);
+        },
+        /**
+         * compute the value for the touchAction property based on the recognizer's settings
+         * @returns {String} value
+         */
+        compute: function() {
+          var o = [];
+          return _(this.manager.recognizers, function(i) {
+            le(i.options.enable, [i]) && (o = o.concat(i.getTouchAction()));
+          }), mo(o.join(" "));
+        },
+        /**
+         * this method is called on each input cycle and provides the preventing of the browser behavior
+         * @param {Object} input
+         */
+        preventDefaults: function(o) {
+          var i = o.srcEvent, l = o.offsetDirection;
+          if (this.manager.session.prevented) {
+            i.preventDefault();
+            return;
+          }
+          var p = this.actions, m = G(p, be) && !at[be], E = G(p, Fe) && !at[Fe], w = G(p, He) && !at[He];
+          if (m) {
+            var L = o.pointers.length === 1, U = o.distance < 2, H = o.deltaTime < 250;
+            if (L && U && H)
+              return;
+          }
+          if (!(w && E) && (m || E && l & te || w && l & _e))
+            return this.preventSrc(i);
+        },
+        /**
+         * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
+         * @param {Object} srcEvent
+         */
+        preventSrc: function(o) {
+          this.manager.session.prevented = !0, o.preventDefault();
+        }
+      };
+      function mo(o) {
+        if (G(o, be))
+          return be;
+        var i = G(o, He), l = G(o, Fe);
+        return i && l ? be : i || l ? i ? He : Fe : G(o, Ot) ? Ot : Ts;
+      }
+      function vo() {
+        if (!Es)
+          return !1;
+        var o = {}, i = t.CSS && t.CSS.supports;
+        return ["auto", "manipulation", "pan-y", "pan-x", "pan-x pan-y", "none"].forEach(function(l) {
+          o[l] = i ? t.CSS.supports("touch-action", l) : !0;
+        }), o;
+      }
+      var lt = 1, W = 2, we = 4, Ee = 8, ue = Ee, qe = 16, se = 32;
+      function de(o) {
+        this.options = P({}, this.defaults, o || {}), this.id = $n(), this.manager = null, this.options.enable = Ve(this.options.enable, !0), this.state = lt, this.simultaneous = {}, this.requireFail = [];
+      }
+      de.prototype = {
+        /**
+         * @virtual
+         * @type {Object}
+         */
+        defaults: {},
+        /**
+         * set options
+         * @param {Object} options
+         * @return {Recognizer}
+         */
+        set: function(o) {
+          return P(this.options, o), this.manager && this.manager.touchAction.update(), this;
+        },
+        /**
+         * recognize simultaneous with an other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        recognizeWith: function(o) {
+          if (C(o, "recognizeWith", this))
+            return this;
+          var i = this.simultaneous;
+          return o = ct(o, this), i[o.id] || (i[o.id] = o, o.recognizeWith(this)), this;
+        },
+        /**
+         * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        dropRecognizeWith: function(o) {
+          return C(o, "dropRecognizeWith", this) ? this : (o = ct(o, this), delete this.simultaneous[o.id], this);
+        },
+        /**
+         * recognizer can only run when an other is failing
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        requireFailure: function(o) {
+          if (C(o, "requireFailure", this))
+            return this;
+          var i = this.requireFail;
+          return o = ct(o, this), xe(i, o) === -1 && (i.push(o), o.requireFailure(this)), this;
+        },
+        /**
+         * drop the requireFailure link. it does not remove the link on the other recognizer.
+         * @param {Recognizer} otherRecognizer
+         * @returns {Recognizer} this
+         */
+        dropRequireFailure: function(o) {
+          if (C(o, "dropRequireFailure", this))
+            return this;
+          o = ct(o, this);
+          var i = xe(this.requireFail, o);
+          return i > -1 && this.requireFail.splice(i, 1), this;
+        },
+        /**
+         * has require failures boolean
+         * @returns {boolean}
+         */
+        hasRequireFailures: function() {
+          return this.requireFail.length > 0;
+        },
+        /**
+         * if the recognizer can recognize simultaneous with an other recognizer
+         * @param {Recognizer} otherRecognizer
+         * @returns {Boolean}
+         */
+        canRecognizeWith: function(o) {
+          return !!this.simultaneous[o.id];
+        },
+        /**
+         * You should use `tryEmit` instead of `emit` directly to check
+         * that all the needed recognizers has failed before emitting.
+         * @param {Object} input
+         */
+        emit: function(o) {
+          var i = this, l = this.state;
+          function p(m) {
+            i.manager.emit(m, o);
+          }
+          l < Ee && p(i.options.event + Cs(l)), p(i.options.event), o.additionalEvent && p(o.additionalEvent), l >= Ee && p(i.options.event + Cs(l));
+        },
+        /**
+         * Check that all the require failure recognizers has failed,
+         * if true, it emits a gesture event,
+         * otherwise, setup the state to FAILED.
+         * @param {Object} input
+         */
+        tryEmit: function(o) {
+          if (this.canEmit())
+            return this.emit(o);
+          this.state = se;
+        },
+        /**
+         * can we emit?
+         * @returns {boolean}
+         */
+        canEmit: function() {
+          for (var o = 0; o < this.requireFail.length; ) {
+            if (!(this.requireFail[o].state & (se | lt)))
+              return !1;
+            o++;
+          }
+          return !0;
+        },
+        /**
+         * update the recognizer
+         * @param {Object} inputData
+         */
+        recognize: function(o) {
+          var i = P({}, o);
+          if (!le(this.options.enable, [this, i])) {
+            this.reset(), this.state = se;
+            return;
+          }
+          this.state & (ue | qe | se) && (this.state = lt), this.state = this.process(i), this.state & (W | we | Ee | qe) && this.tryEmit(i);
+        },
+        /**
+         * return the state of the recognizer
+         * the actual recognizing happens in this method
+         * @virtual
+         * @param {Object} inputData
+         * @returns {Const} STATE
+         */
+        process: function(o) {
+        },
+        // jshint ignore:line
+        /**
+         * return the preferred touch-action
+         * @virtual
+         * @returns {Array}
+         */
+        getTouchAction: function() {
+        },
+        /**
+         * called when the gesture isn't allowed to recognize
+         * like when another is being recognized or it is disabled
+         * @virtual
+         */
+        reset: function() {
+        }
+      };
+      function Cs(o) {
+        return o & qe ? "cancel" : o & Ee ? "end" : o & we ? "move" : o & W ? "start" : "";
+      }
+      function _s(o) {
+        return o == ze ? "down" : o == $e ? "up" : o == Re ? "left" : o == Be ? "right" : "";
+      }
+      function ct(o, i) {
+        var l = i.manager;
+        return l ? l.get(o) : o;
+      }
+      function K() {
+        de.apply(this, arguments);
+      }
+      x(K, de, {
+        /**
+         * @namespace
+         * @memberof AttrRecognizer
+         */
+        defaults: {
+          /**
+           * @type {Number}
+           * @default 1
+           */
+          pointers: 1
+        },
+        /**
+         * Used to check if it the recognizer receives valid input, like input.distance > 10.
+         * @memberof AttrRecognizer
+         * @param {Object} input
+         * @returns {Boolean} recognized
+         */
+        attrTest: function(o) {
+          var i = this.options.pointers;
+          return i === 0 || o.pointers.length === i;
+        },
+        /**
+         * Process the input and return the state for the recognizer
+         * @memberof AttrRecognizer
+         * @param {Object} input
+         * @returns {*} State
+         */
+        process: function(o) {
+          var i = this.state, l = o.eventType, p = i & (W | we), m = this.attrTest(o);
+          return p && (l & q || !m) ? i | qe : p || m ? l & N ? i | Ee : i & W ? i | we : W : se;
+        }
+      });
+      function ut() {
+        K.apply(this, arguments), this.pX = null, this.pY = null;
+      }
+      x(ut, K, {
+        /**
+         * @namespace
+         * @memberof PanRecognizer
+         */
+        defaults: {
+          event: "pan",
+          threshold: 10,
+          pointers: 1,
+          direction: as
+        },
+        getTouchAction: function() {
+          var o = this.options.direction, i = [];
+          return o & te && i.push(Fe), o & _e && i.push(He), i;
+        },
+        directionTest: function(o) {
+          var i = this.options, l = !0, p = o.distance, m = o.direction, E = o.deltaX, w = o.deltaY;
+          return m & i.direction || (i.direction & te ? (m = E === 0 ? st : E < 0 ? Re : Be, l = E != this.pX, p = Math.abs(o.deltaX)) : (m = w === 0 ? st : w < 0 ? $e : ze, l = w != this.pY, p = Math.abs(o.deltaY))), o.direction = m, l && p > i.threshold && m & i.direction;
+        },
+        attrTest: function(o) {
+          return K.prototype.attrTest.call(this, o) && (this.state & W || !(this.state & W) && this.directionTest(o));
+        },
+        emit: function(o) {
+          this.pX = o.deltaX, this.pY = o.deltaY;
+          var i = _s(o.direction);
+          i && (o.additionalEvent = this.options.event + i), this._super.emit.call(this, o);
+        }
+      });
+      function Lt() {
+        K.apply(this, arguments);
+      }
+      x(Lt, K, {
+        /**
+         * @namespace
+         * @memberof PinchRecognizer
+         */
+        defaults: {
+          event: "pinch",
+          threshold: 0,
+          pointers: 2
+        },
+        getTouchAction: function() {
+          return [be];
+        },
+        attrTest: function(o) {
+          return this._super.attrTest.call(this, o) && (Math.abs(o.scale - 1) > this.options.threshold || this.state & W);
+        },
+        emit: function(o) {
+          if (o.scale !== 1) {
+            var i = o.scale < 1 ? "in" : "out";
+            o.additionalEvent = this.options.event + i;
+          }
+          this._super.emit.call(this, o);
+        }
+      });
+      function Vt() {
+        de.apply(this, arguments), this._timer = null, this._input = null;
+      }
+      x(Vt, de, {
+        /**
+         * @namespace
+         * @memberof PressRecognizer
+         */
+        defaults: {
+          event: "press",
+          pointers: 1,
+          time: 251,
+          // minimal time of the pointer to be pressed
+          threshold: 9
+          // a minimal movement is ok, but keep it low
+        },
+        getTouchAction: function() {
+          return [Ts];
+        },
+        process: function(o) {
+          var i = this.options, l = o.pointers.length === i.pointers, p = o.distance < i.threshold, m = o.deltaTime > i.time;
+          if (this._input = o, !p || !l || o.eventType & (N | q) && !m)
+            this.reset();
+          else if (o.eventType & z)
+            this.reset(), this._timer = v(function() {
+              this.state = ue, this.tryEmit();
+            }, i.time, this);
+          else if (o.eventType & N)
+            return ue;
+          return se;
+        },
+        reset: function() {
+          clearTimeout(this._timer);
+        },
+        emit: function(o) {
+          this.state === ue && (o && o.eventType & N ? this.manager.emit(this.options.event + "up", o) : (this._input.timeStamp = g(), this.manager.emit(this.options.event, this._input)));
+        }
+      });
+      function Ut() {
+        K.apply(this, arguments);
+      }
+      x(Ut, K, {
+        /**
+         * @namespace
+         * @memberof RotateRecognizer
+         */
+        defaults: {
+          event: "rotate",
+          threshold: 0,
+          pointers: 2
+        },
+        getTouchAction: function() {
+          return [be];
+        },
+        attrTest: function(o) {
+          return this._super.attrTest.call(this, o) && (Math.abs(o.rotation) > this.options.threshold || this.state & W);
+        }
+      });
+      function Rt() {
+        K.apply(this, arguments);
+      }
+      x(Rt, K, {
+        /**
+         * @namespace
+         * @memberof SwipeRecognizer
+         */
+        defaults: {
+          event: "swipe",
+          threshold: 10,
+          velocity: 0.3,
+          direction: te | _e,
+          pointers: 1
+        },
+        getTouchAction: function() {
+          return ut.prototype.getTouchAction.call(this);
+        },
+        attrTest: function(o) {
+          var i = this.options.direction, l;
+          return i & (te | _e) ? l = o.overallVelocity : i & te ? l = o.overallVelocityX : i & _e && (l = o.overallVelocityY), this._super.attrTest.call(this, o) && i & o.offsetDirection && o.distance > this.options.threshold && o.maxPointers == this.options.pointers && f(l) > this.options.velocity && o.eventType & N;
+        },
+        emit: function(o) {
+          var i = _s(o.offsetDirection);
+          i && this.manager.emit(this.options.event + i, o), this.manager.emit(this.options.event, o);
+        }
+      });
+      function dt() {
+        de.apply(this, arguments), this.pTime = !1, this.pCenter = !1, this._timer = null, this._input = null, this.count = 0;
+      }
+      x(dt, de, {
+        /**
+         * @namespace
+         * @memberof PinchRecognizer
+         */
+        defaults: {
+          event: "tap",
+          pointers: 1,
+          taps: 1,
+          interval: 300,
+          // max time between the multi-tap taps
+          time: 250,
+          // max time of the pointer to be down (like finger on the screen)
+          threshold: 9,
+          // a minimal movement is ok, but keep it low
+          posThreshold: 10
+          // a multi-tap can be a bit off the initial position
+        },
+        getTouchAction: function() {
+          return [Ot];
+        },
+        process: function(o) {
+          var i = this.options, l = o.pointers.length === i.pointers, p = o.distance < i.threshold, m = o.deltaTime < i.time;
+          if (this.reset(), o.eventType & z && this.count === 0)
+            return this.failTimeout();
+          if (p && m && l) {
+            if (o.eventType != N)
+              return this.failTimeout();
+            var E = this.pTime ? o.timeStamp - this.pTime < i.interval : !0, w = !this.pCenter || ot(this.pCenter, o.center) < i.posThreshold;
+            this.pTime = o.timeStamp, this.pCenter = o.center, !w || !E ? this.count = 1 : this.count += 1, this._input = o;
+            var L = this.count % i.taps;
+            if (L === 0)
+              return this.hasRequireFailures() ? (this._timer = v(function() {
+                this.state = ue, this.tryEmit();
+              }, i.interval, this), W) : ue;
+          }
+          return se;
+        },
+        failTimeout: function() {
+          return this._timer = v(function() {
+            this.state = se;
+          }, this.options.interval, this), se;
+        },
+        reset: function() {
+          clearTimeout(this._timer);
+        },
+        emit: function() {
+          this.state == ue && (this._input.tapCount = this.count, this.manager.emit(this.options.event, this._input));
+        }
+      });
+      function Se(o, i) {
+        return i = i || {}, i.recognizers = Ve(i.recognizers, Se.defaults.preset), new Bt(o, i);
+      }
+      Se.VERSION = "2.0.7", Se.defaults = {
+        /**
+         * set if DOM events are being triggered.
+         * But this is slower and unused by simple implementations, so disabled by default.
+         * @type {Boolean}
+         * @default false
+         */
+        domEvents: !1,
+        /**
+         * The value for the touchAction property/fallback.
+         * When set to `compute` it will magically set the correct value based on the added recognizers.
+         * @type {String}
+         * @default compute
+         */
+        touchAction: Ss,
+        /**
+         * @type {Boolean}
+         * @default true
+         */
+        enable: !0,
+        /**
+         * EXPERIMENTAL FEATURE -- can be removed/changed
+         * Change the parent input target element.
+         * If Null, then it is being set the to main element.
+         * @type {Null|EventTarget}
+         * @default null
+         */
+        inputTarget: null,
+        /**
+         * force an input class
+         * @type {Null|Function}
+         * @default null
+         */
+        inputClass: null,
+        /**
+         * Default recognizer setup when calling `Hammer()`
+         * When creating a new Manager these will be skipped.
+         * @type {Array}
+         */
+        preset: [
+          // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
+          [Ut, { enable: !1 }],
+          [Lt, { enable: !1 }, ["rotate"]],
+          [Rt, { direction: te }],
+          [ut, { direction: te }, ["swipe"]],
+          [dt],
+          [dt, { event: "doubletap", taps: 2 }, ["tap"]],
+          [Vt]
+        ],
+        /**
+         * Some CSS properties can be used to improve the working of Hammer.
+         * Add them to this method and they will be set when creating a new Manager.
+         * @namespace
+         */
+        cssProps: {
+          /**
+           * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userSelect: "none",
+          /**
+           * Disable the Windows Phone grippers when pressing an element.
+           * @type {String}
+           * @default 'none'
+           */
+          touchSelect: "none",
+          /**
+           * Disables the default callout shown when you touch and hold a touch target.
+           * On iOS, when you touch and hold a touch target such as a link, Safari displays
+           * a callout containing information about the link. This property allows you to disable that callout.
+           * @type {String}
+           * @default 'none'
+           */
+          touchCallout: "none",
+          /**
+           * Specifies whether zooming is enabled. Used by IE10>
+           * @type {String}
+           * @default 'none'
+           */
+          contentZooming: "none",
+          /**
+           * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
+           * @type {String}
+           * @default 'none'
+           */
+          userDrag: "none",
+          /**
+           * Overrides the highlight color shown when the user taps a link or a JavaScript
+           * clickable element in iOS. This property obeys the alpha value, if specified.
+           * @type {String}
+           * @default 'rgba(0,0,0,0)'
+           */
+          tapHighlightColor: "rgba(0,0,0,0)"
+        }
+      };
+      var yo = 1, bs = 2;
+      function Bt(o, i) {
+        this.options = P({}, Se.defaults, i || {}), this.options.inputTarget = this.options.inputTarget || o, this.handlers = {}, this.session = {}, this.recognizers = [], this.oldCssProps = {}, this.element = o, this.input = Yn(this), this.touchAction = new kt(this, this.options.touchAction), Is(this, !0), _(this.options.recognizers, function(l) {
+          var p = this.add(new l[0](l[1]));
+          l[2] && p.recognizeWith(l[2]), l[3] && p.requireFailure(l[3]);
+        }, this);
+      }
+      Bt.prototype = {
+        /**
+         * set options
+         * @param {Object} options
+         * @returns {Manager}
+         */
+        set: function(o) {
+          return P(this.options, o), o.touchAction && this.touchAction.update(), o.inputTarget && (this.input.destroy(), this.input.target = o.inputTarget, this.input.init()), this;
+        },
+        /**
+         * stop recognizing for this session.
+         * This session will be discarded, when a new [input]start event is fired.
+         * When forced, the recognizer cycle is stopped immediately.
+         * @param {Boolean} [force]
+         */
+        stop: function(o) {
+          this.session.stopped = o ? bs : yo;
+        },
+        /**
+         * run the recognizers!
+         * called by the inputHandler function on every movement of the pointers (touches)
+         * it walks through all the recognizers and tries to detect the gesture that is being made
+         * @param {Object} inputData
+         */
+        recognize: function(o) {
+          var i = this.session;
+          if (!i.stopped) {
+            this.touchAction.preventDefaults(o);
+            var l, p = this.recognizers, m = i.curRecognizer;
+            (!m || m && m.state & ue) && (m = i.curRecognizer = null);
+            for (var E = 0; E < p.length; )
+              l = p[E], i.stopped !== bs && // 1
+              (!m || l == m || // 2
+              l.canRecognizeWith(m)) ? l.recognize(o) : l.reset(), !m && l.state & (W | we | Ee) && (m = i.curRecognizer = l), E++;
+          }
+        },
+        /**
+         * get a recognizer by its event name.
+         * @param {Recognizer|String} recognizer
+         * @returns {Recognizer|Null}
+         */
+        get: function(o) {
+          if (o instanceof de)
+            return o;
+          for (var i = this.recognizers, l = 0; l < i.length; l++)
+            if (i[l].options.event == o)
+              return i[l];
+          return null;
+        },
+        /**
+         * add a recognizer to the manager
+         * existing recognizers with the same event name will be removed
+         * @param {Recognizer} recognizer
+         * @returns {Recognizer|Manager}
+         */
+        add: function(o) {
+          if (C(o, "add", this))
+            return this;
+          var i = this.get(o.options.event);
+          return i && this.remove(i), this.recognizers.push(o), o.manager = this, this.touchAction.update(), o;
+        },
+        /**
+         * remove a recognizer by name or instance
+         * @param {Recognizer|String} recognizer
+         * @returns {Manager}
+         */
+        remove: function(o) {
+          if (C(o, "remove", this))
+            return this;
+          if (o = this.get(o), o) {
+            var i = this.recognizers, l = xe(i, o);
+            l !== -1 && (i.splice(l, 1), this.touchAction.update());
+          }
+          return this;
+        },
+        /**
+         * bind event
+         * @param {String} events
+         * @param {Function} handler
+         * @returns {EventEmitter} this
+         */
+        on: function(o, i) {
+          if (o !== r && i !== r) {
+            var l = this.handlers;
+            return _(Je(o), function(p) {
+              l[p] = l[p] || [], l[p].push(i);
+            }), this;
+          }
+        },
+        /**
+         * unbind event, leave emit blank to remove all handlers
+         * @param {String} events
+         * @param {Function} [handler]
+         * @returns {EventEmitter} this
+         */
+        off: function(o, i) {
+          if (o !== r) {
+            var l = this.handlers;
+            return _(Je(o), function(p) {
+              i ? l[p] && l[p].splice(xe(l[p], i), 1) : delete l[p];
+            }), this;
+          }
+        },
+        /**
+         * emit event to the listeners
+         * @param {String} event
+         * @param {Object} data
+         */
+        emit: function(o, i) {
+          this.options.domEvents && Eo(o, i);
+          var l = this.handlers[o] && this.handlers[o].slice();
+          if (!(!l || !l.length)) {
+            i.type = o, i.preventDefault = function() {
+              i.srcEvent.preventDefault();
+            };
+            for (var p = 0; p < l.length; )
+              l[p](i), p++;
+          }
+        },
+        /**
+         * destroy the manager and unbinds all events
+         * it doesn't unbind dom events, that is the user own responsibility
+         */
+        destroy: function() {
+          this.element && Is(this, !1), this.handlers = {}, this.session = {}, this.input.destroy(), this.element = null;
+        }
+      };
+      function Is(o, i) {
+        var l = o.element;
+        if (l.style) {
+          var p;
+          _(o.options.cssProps, function(m, E) {
+            p = tt(l.style, E), i ? (o.oldCssProps[p] = l.style[p], l.style[p] = m) : l.style[p] = o.oldCssProps[p] || "";
+          }), i || (o.oldCssProps = {});
+        }
+      }
+      function Eo(o, i) {
+        var l = s.createEvent("Event");
+        l.initEvent(o, !0, !0), l.gesture = i, i.target.dispatchEvent(l);
+      }
+      P(Se, {
+        INPUT_START: z,
+        INPUT_MOVE: Ce,
+        INPUT_END: N,
+        INPUT_CANCEL: q,
+        STATE_POSSIBLE: lt,
+        STATE_BEGAN: W,
+        STATE_CHANGED: we,
+        STATE_ENDED: Ee,
+        STATE_RECOGNIZED: ue,
+        STATE_CANCELLED: qe,
+        STATE_FAILED: se,
+        DIRECTION_NONE: st,
+        DIRECTION_LEFT: Re,
+        DIRECTION_RIGHT: Be,
+        DIRECTION_UP: $e,
+        DIRECTION_DOWN: ze,
+        DIRECTION_HORIZONTAL: te,
+        DIRECTION_VERTICAL: _e,
+        DIRECTION_ALL: as,
+        Manager: Bt,
+        Input: Y,
+        TouchAction: kt,
+        TouchInput: it,
+        MouseInput: rt,
+        PointerEventInput: At,
+        TouchMouseInput: Nt,
+        SingleTouchInput: gs,
+        Recognizer: de,
+        AttrRecognizer: K,
+        Tap: dt,
+        Pan: ut,
+        Swipe: Rt,
+        Pinch: Lt,
+        Rotate: Ut,
+        Press: Vt,
+        on: ye,
+        off: Q,
+        each: _,
+        merge: b,
+        extend: I,
+        assign: P,
+        inherit: x,
+        bindFn: F,
+        prefixed: tt
+      });
+      var So = typeof t < "u" ? t : typeof self < "u" ? self : {};
+      So.Hammer = Se, e.exports ? e.exports = Se : t[n] = Se;
+    })(window, document, "Hammer");
+  })(Ht)), Ht.exports;
+}
+var xt = wi();
+const oe = /* @__PURE__ */ er({
+  __proto__: null
+}, [xt]), Un = 1, Rn = 2, Zt = 4, Di = {
+  mousedown: Un,
+  mousemove: Rn,
+  mouseup: Zt
+};
+function Mi(e, t) {
+  for (let s = 0; s < e.length; s++)
+    if (t(e[s]))
+      return !0;
+  return !1;
+}
+function Ai(e) {
+  const t = e.prototype.handler;
+  e.prototype.handler = function(n) {
+    const r = this.store;
+    n.button > 0 && n.type === "pointerdown" && (Mi(r, (a) => a.pointerId === n.pointerId) || r.push(n)), t.call(this, n);
+  };
+}
+function Ni(e) {
+  e.prototype.handler = function(s) {
+    let n = Di[s.type];
+    n & Un && s.button >= 0 && (this.pressed = !0), n & Rn && s.buttons === 0 && (n = Zt), this.pressed && (n & Zt && (this.pressed = !1), this.callback(this.manager, n, {
+      pointers: [s],
+      changedPointers: [s],
+      pointerType: "mouse",
+      srcEvent: s
+    }));
+  };
+}
+Ai(xt.PointerEventInput);
+Ni(xt.MouseInput);
+const Oi = xt.Manager;
+class wt {
+  constructor(t, s, n) {
+    this.element = t, this.callback = s, this.options = { enable: !0, ...n };
+  }
+}
+const ki = oe ? [
+  [oe.Pan, { event: "tripan", pointers: 3, threshold: 0, enable: !1 }],
+  [oe.Rotate, { enable: !1 }],
+  [oe.Pinch, { enable: !1 }],
+  [oe.Swipe, { enable: !1 }],
+  [oe.Pan, { threshold: 0, enable: !1 }],
+  [oe.Press, { enable: !1 }],
+  [oe.Tap, { event: "doubletap", taps: 2, enable: !1 }],
+  // TODO - rename to 'tap' and 'singletap' in the next major release
+  [oe.Tap, { event: "anytap", enable: !1 }],
+  [oe.Tap, { enable: !1 }]
+] : null, Fs = {
+  tripan: ["rotate", "pinch", "pan"],
+  rotate: ["pinch"],
+  pinch: ["pan"],
+  pan: ["press", "doubletap", "anytap", "tap"],
+  doubletap: ["anytap"],
+  anytap: ["tap"]
+}, Li = {
+  doubletap: ["tap"]
+}, Vi = {
+  pointerdown: "pointerdown",
+  pointermove: "pointermove",
+  pointerup: "pointerup",
+  touchstart: "pointerdown",
+  touchmove: "pointermove",
+  touchend: "pointerup",
+  mousedown: "pointerdown",
+  mousemove: "pointermove",
+  mouseup: "pointerup"
+}, ns = {
+  KEY_EVENTS: ["keydown", "keyup"],
+  MOUSE_EVENTS: ["mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "mouseleave"],
+  WHEEL_EVENTS: [
+    // Chrome, Safari
+    "wheel",
+    // IE
+    "mousewheel"
+  ]
+}, Ui = {
+  tap: "tap",
+  anytap: "anytap",
+  doubletap: "doubletap",
+  press: "press",
+  pinch: "pinch",
+  pinchin: "pinch",
+  pinchout: "pinch",
+  pinchstart: "pinch",
+  pinchmove: "pinch",
+  pinchend: "pinch",
+  pinchcancel: "pinch",
+  rotate: "rotate",
+  rotatestart: "rotate",
+  rotatemove: "rotate",
+  rotateend: "rotate",
+  rotatecancel: "rotate",
+  tripan: "tripan",
+  tripanstart: "tripan",
+  tripanmove: "tripan",
+  tripanup: "tripan",
+  tripandown: "tripan",
+  tripanleft: "tripan",
+  tripanright: "tripan",
+  tripanend: "tripan",
+  tripancancel: "tripan",
+  pan: "pan",
+  panstart: "pan",
+  panmove: "pan",
+  panup: "pan",
+  pandown: "pan",
+  panleft: "pan",
+  panright: "pan",
+  panend: "pan",
+  pancancel: "pan",
+  swipe: "swipe",
+  swipeleft: "swipe",
+  swiperight: "swipe",
+  swipeup: "swipe",
+  swipedown: "swipe"
+}, qs = {
+  click: "tap",
+  anyclick: "anytap",
+  dblclick: "doubletap",
+  mousedown: "pointerdown",
+  mousemove: "pointermove",
+  mouseup: "pointerup",
+  mouseover: "pointerover",
+  mouseout: "pointerout",
+  mouseleave: "pointerleave"
+}, Ri = typeof navigator < "u" && navigator.userAgent ? navigator.userAgent.toLowerCase() : "", Ae = typeof window < "u" ? window : global;
+let Qt = !1;
+try {
+  const e = {
+    // This function will be called when the browser
+    // attempts to access the passive property.
+    get passive() {
+      return Qt = !0, !0;
+    }
+  };
+  Ae.addEventListener("test", null, e), Ae.removeEventListener("test", null);
+} catch {
+  Qt = !1;
+}
+const Bi = Ri.indexOf("firefox") !== -1, { WHEEL_EVENTS: $i } = ns, js = "wheel", Gs = 4.000244140625, zi = 40, Hi = 0.25;
+class Fi extends wt {
+  constructor(t, s, n) {
+    super(t, s, n), this.handleEvent = (r) => {
+      if (!this.options.enable)
+        return;
+      let a = r.deltaY;
+      Ae.WheelEvent && (Bi && r.deltaMode === Ae.WheelEvent.DOM_DELTA_PIXEL && (a /= Ae.devicePixelRatio), r.deltaMode === Ae.WheelEvent.DOM_DELTA_LINE && (a *= zi)), a !== 0 && a % Gs === 0 && (a = Math.floor(a / Gs)), r.shiftKey && a && (a = a * Hi), this.callback({
+        type: js,
+        center: {
+          x: r.clientX,
+          y: r.clientY
+        },
+        delta: -a,
+        srcEvent: r,
+        pointerType: "mouse",
+        target: r.target
+      });
+    }, this.events = (this.options.events || []).concat($i), this.events.forEach((r) => t.addEventListener(r, this.handleEvent, Qt ? { passive: !1 } : !1));
+  }
+  destroy() {
+    this.events.forEach((t) => this.element.removeEventListener(t, this.handleEvent));
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(t, s) {
+    t === js && (this.options.enable = s);
+  }
+}
+const { MOUSE_EVENTS: qi } = ns, Ys = "pointermove", Ws = "pointerover", Xs = "pointerout", Zs = "pointerenter", Qs = "pointerleave";
+class ji extends wt {
+  constructor(t, s, n) {
+    super(t, s, n), this.handleEvent = (a) => {
+      this.handleOverEvent(a), this.handleOutEvent(a), this.handleEnterEvent(a), this.handleLeaveEvent(a), this.handleMoveEvent(a);
+    }, this.pressed = !1;
+    const { enable: r } = this.options;
+    this.enableMoveEvent = r, this.enableLeaveEvent = r, this.enableEnterEvent = r, this.enableOutEvent = r, this.enableOverEvent = r, this.events = (this.options.events || []).concat(qi), this.events.forEach((a) => t.addEventListener(a, this.handleEvent));
+  }
+  destroy() {
+    this.events.forEach((t) => this.element.removeEventListener(t, this.handleEvent));
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(t, s) {
+    t === Ys && (this.enableMoveEvent = s), t === Ws && (this.enableOverEvent = s), t === Xs && (this.enableOutEvent = s), t === Zs && (this.enableEnterEvent = s), t === Qs && (this.enableLeaveEvent = s);
+  }
+  handleOverEvent(t) {
+    this.enableOverEvent && t.type === "mouseover" && this._emit(Ws, t);
+  }
+  handleOutEvent(t) {
+    this.enableOutEvent && t.type === "mouseout" && this._emit(Xs, t);
+  }
+  handleEnterEvent(t) {
+    this.enableEnterEvent && t.type === "mouseenter" && this._emit(Zs, t);
+  }
+  handleLeaveEvent(t) {
+    this.enableLeaveEvent && t.type === "mouseleave" && this._emit(Qs, t);
+  }
+  handleMoveEvent(t) {
+    if (this.enableMoveEvent)
+      switch (t.type) {
+        case "mousedown":
+          t.button >= 0 && (this.pressed = !0);
+          break;
+        case "mousemove":
+          t.buttons === 0 && (this.pressed = !1), this.pressed || this._emit(Ys, t);
+          break;
+        case "mouseup":
+          this.pressed = !1;
+          break;
+      }
+  }
+  _emit(t, s) {
+    this.callback({
+      type: t,
+      center: {
+        x: s.clientX,
+        y: s.clientY
+      },
+      srcEvent: s,
+      pointerType: "mouse",
+      target: s.target
+    });
+  }
+}
+const { KEY_EVENTS: Gi } = ns, Ks = "keydown", Js = "keyup";
+class Yi extends wt {
+  constructor(t, s, n) {
+    super(t, s, n), this.handleEvent = (r) => {
+      const a = r.target || r.srcElement;
+      a.tagName === "INPUT" && a.type === "text" || a.tagName === "TEXTAREA" || (this.enableDownEvent && r.type === "keydown" && this.callback({
+        type: Ks,
+        srcEvent: r,
+        key: r.key,
+        target: r.target
+      }), this.enableUpEvent && r.type === "keyup" && this.callback({
+        type: Js,
+        srcEvent: r,
+        key: r.key,
+        target: r.target
+      }));
+    }, this.enableDownEvent = this.options.enable, this.enableUpEvent = this.options.enable, this.events = (this.options.events || []).concat(Gi), t.tabIndex = this.options.tabIndex || 0, t.style.outline = "none", this.events.forEach((r) => t.addEventListener(r, this.handleEvent));
+  }
+  destroy() {
+    this.events.forEach((t) => this.element.removeEventListener(t, this.handleEvent));
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(t, s) {
+    t === Ks && (this.enableDownEvent = s), t === Js && (this.enableUpEvent = s);
+  }
+}
+const en = "contextmenu";
+class Wi extends wt {
+  constructor(t, s, n) {
+    super(t, s, n), this.handleEvent = (r) => {
+      this.options.enable && this.callback({
+        type: en,
+        center: {
+          x: r.clientX,
+          y: r.clientY
+        },
+        srcEvent: r,
+        pointerType: "mouse",
+        target: r.target
+      });
+    }, t.addEventListener("contextmenu", this.handleEvent);
+  }
+  destroy() {
+    this.element.removeEventListener("contextmenu", this.handleEvent);
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(t, s) {
+    t === en && (this.options.enable = s);
+  }
+}
+const tn = 1, Kt = 2, sn = 4, Xi = {
+  pointerdown: tn,
+  pointermove: Kt,
+  pointerup: sn,
+  mousedown: tn,
+  mousemove: Kt,
+  mouseup: sn
+}, Zi = 0, Qi = 1, Ki = 2, Ji = 1, ea = 2, ta = 4;
+function sa(e) {
+  const t = Xi[e.srcEvent.type];
+  if (!t)
+    return null;
+  const { buttons: s, button: n } = e.srcEvent;
+  let r = !1, a = !1, c = !1;
+  return t === Kt ? (r = !!(s & Ji), a = !!(s & ta), c = !!(s & ea)) : (r = n === Zi, a = n === Qi, c = n === Ki), { leftButton: r, middleButton: a, rightButton: c };
+}
+function na(e, t) {
+  const s = e.center;
+  if (!s)
+    return null;
+  const n = t.getBoundingClientRect(), r = n.width / t.offsetWidth || 1, a = n.height / t.offsetHeight || 1, c = {
+    x: (s.x - n.left - t.clientLeft) / r,
+    y: (s.y - n.top - t.clientTop) / a
+  };
+  return { center: s, offsetCenter: c };
+}
+const Ft = {
+  srcElement: "root",
+  priority: 0
+};
+class oa {
+  constructor(t) {
+    this.handleEvent = (s) => {
+      if (this.isEmpty())
+        return;
+      const n = this._normalizeEvent(s);
+      let r = s.srcEvent.target;
+      for (; r && r !== n.rootElement; ) {
+        if (this._emit(n, r), n.handled)
+          return;
+        r = r.parentNode;
+      }
+      this._emit(n, "root");
+    }, this.eventManager = t, this.handlers = [], this.handlersByElement = /* @__PURE__ */ new Map(), this._active = !1;
+  }
+  // Returns true if there are no non-passive handlers
+  isEmpty() {
+    return !this._active;
+  }
+  add(t, s, n, r = !1, a = !1) {
+    const { handlers: c, handlersByElement: d } = this;
+    let u = Ft;
+    typeof n == "string" || n && n.addEventListener ? u = { ...Ft, srcElement: n } : n && (u = { ...Ft, ...n });
+    let f = d.get(u.srcElement);
+    f || (f = [], d.set(u.srcElement, f));
+    const g = {
+      type: t,
+      handler: s,
+      srcElement: u.srcElement,
+      priority: u.priority
+    };
+    r && (g.once = !0), a && (g.passive = !0), c.push(g), this._active = this._active || !g.passive;
+    let v = f.length - 1;
+    for (; v >= 0 && !(f[v].priority >= g.priority); )
+      v--;
+    f.splice(v + 1, 0, g);
+  }
+  remove(t, s) {
+    const { handlers: n, handlersByElement: r } = this;
+    for (let a = n.length - 1; a >= 0; a--) {
+      const c = n[a];
+      if (c.type === t && c.handler === s) {
+        n.splice(a, 1);
+        const d = r.get(c.srcElement);
+        d.splice(d.indexOf(c), 1), d.length === 0 && r.delete(c.srcElement);
+      }
+    }
+    this._active = n.some((a) => !a.passive);
+  }
+  /**
+   * Invoke handlers on a particular element
+   */
+  _emit(t, s) {
+    const n = this.handlersByElement.get(s);
+    if (n) {
+      let r = !1;
+      const a = () => {
+        t.handled = !0;
+      }, c = () => {
+        t.handled = !0, r = !0;
+      }, d = [];
+      for (let u = 0; u < n.length; u++) {
+        const { type: f, handler: g, once: v } = n[u];
+        if (g({
+          ...t,
+          // @ts-ignore
+          type: f,
+          stopPropagation: a,
+          stopImmediatePropagation: c
+        }), v && d.push(n[u]), r)
+          break;
+      }
+      for (let u = 0; u < d.length; u++) {
+        const { type: f, handler: g } = d[u];
+        this.remove(f, g);
+      }
+    }
+  }
+  /**
+   * Normalizes hammerjs and custom events to have predictable fields.
+   */
+  _normalizeEvent(t) {
+    const s = this.eventManager.getElement();
+    return {
+      ...t,
+      ...sa(t),
+      ...na(t, s),
+      preventDefault: () => {
+        t.srcEvent.preventDefault();
+      },
+      stopImmediatePropagation: null,
+      stopPropagation: null,
+      handled: !1,
+      rootElement: s
+    };
+  }
+}
+const ra = {
+  // event handlers
+  events: null,
+  // custom recognizers
+  recognizers: null,
+  recognizerOptions: {},
+  // Manager class
+  Manager: Oi,
+  // allow browser default touch action
+  // https://github.com/uber/react-map-gl/issues/506
+  touchAction: "none",
+  tabIndex: 0
+};
+class ia {
+  constructor(t = null, s) {
+    this._onBasicInput = (r) => {
+      const { srcEvent: a } = r, c = Vi[a.type];
+      c && this.manager.emit(c, r);
+    }, this._onOtherEvent = (r) => {
+      this.manager.emit(r.type, r);
+    }, this.options = { ...ra, ...s }, this.events = /* @__PURE__ */ new Map(), this.setElement(t);
+    const { events: n } = this.options;
+    n && this.on(n);
+  }
+  getElement() {
+    return this.element;
+  }
+  setElement(t) {
+    if (this.element && this.destroy(), this.element = t, !t)
+      return;
+    const { options: s } = this, n = s.Manager;
+    this.manager = new n(t, {
+      touchAction: s.touchAction,
+      recognizers: s.recognizers || ki
+    }).on("hammer.input", this._onBasicInput), s.recognizers || Object.keys(Fs).forEach((r) => {
+      const a = this.manager.get(r);
+      a && Fs[r].forEach((c) => {
+        a.recognizeWith(c);
+      });
+    });
+    for (const r in s.recognizerOptions) {
+      const a = this.manager.get(r);
+      if (a) {
+        const c = s.recognizerOptions[r];
+        delete c.enable, a.set(c);
+      }
+    }
+    this.wheelInput = new Fi(t, this._onOtherEvent, {
+      enable: !1
+    }), this.moveInput = new ji(t, this._onOtherEvent, {
+      enable: !1
+    }), this.keyInput = new Yi(t, this._onOtherEvent, {
+      enable: !1,
+      tabIndex: s.tabIndex
+    }), this.contextmenuInput = new Wi(t, this._onOtherEvent, {
+      enable: !1
+    });
+    for (const [r, a] of this.events)
+      a.isEmpty() || (this._toggleRecognizer(a.recognizerName, !0), this.manager.on(r, a.handleEvent));
+  }
+  // Tear down internal event management implementations.
+  destroy() {
+    this.element && (this.wheelInput.destroy(), this.moveInput.destroy(), this.keyInput.destroy(), this.contextmenuInput.destroy(), this.manager.destroy(), this.wheelInput = null, this.moveInput = null, this.keyInput = null, this.contextmenuInput = null, this.manager = null, this.element = null);
+  }
+  /** Register an event handler function to be called on `event` */
+  on(t, s, n) {
+    this._addEventHandler(t, s, n, !1);
+  }
+  once(t, s, n) {
+    this._addEventHandler(t, s, n, !0);
+  }
+  watch(t, s, n) {
+    this._addEventHandler(t, s, n, !1, !0);
+  }
+  off(t, s) {
+    this._removeEventHandler(t, s);
+  }
+  /*
+   * Enable/disable recognizer for the given event
+   */
+  _toggleRecognizer(t, s) {
+    const { manager: n } = this;
+    if (!n)
+      return;
+    const r = n.get(t);
+    if (r && r.options.enable !== s) {
+      r.set({ enable: s });
+      const a = Li[t];
+      a && !this.options.recognizers && a.forEach((c) => {
+        const d = n.get(c);
+        s ? (d.requireFailure(t), r.dropRequireFailure(c)) : d.dropRequireFailure(t);
+      });
+    }
+    this.wheelInput.enableEventType(t, s), this.moveInput.enableEventType(t, s), this.keyInput.enableEventType(t, s), this.contextmenuInput.enableEventType(t, s);
+  }
+  /**
+   * Process the event registration for a single event + handler.
+   */
+  _addEventHandler(t, s, n, r, a) {
+    if (typeof t != "string") {
+      n = s;
+      for (const g in t)
+        this._addEventHandler(g, t[g], n, r, a);
+      return;
+    }
+    const { manager: c, events: d } = this, u = qs[t] || t;
+    let f = d.get(u);
+    f || (f = new oa(this), d.set(u, f), f.recognizerName = Ui[u] || u, c && c.on(u, f.handleEvent)), f.add(t, s, n, r, a), f.isEmpty() || this._toggleRecognizer(f.recognizerName, !0);
+  }
+  /**
+   * Process the event deregistration for a single event + handler.
+   */
+  _removeEventHandler(t, s) {
+    if (typeof t != "string") {
+      for (const c in t)
+        this._removeEventHandler(c, t[c]);
+      return;
+    }
+    const { events: n } = this, r = qs[t] || t, a = n.get(r);
+    if (a && (a.remove(t, s), a.isEmpty())) {
+      const { recognizerName: c } = a;
+      let d = !1;
+      for (const u of n.values())
+        if (u.recognizerName === c && !u.isEmpty()) {
+          d = !0;
+          break;
+        }
+      d || this._toggleRecognizer(c, !1);
+    }
+  }
+}
+const aa = {
+  __name: "PgInteractionDetector",
+  setup(e) {
+    const t = he(), s = Te(), n = j(null), r = j([]), a = j("ended"), c = j(0);
+    let d;
+    const { playing: u } = S(t), f = () => s.previous(), g = () => s.next(), v = () => s.close(), C = () => u.value ? s.pause() : s.play(), _ = (b) => b.reduce((x, F) => x + F, 0) / b.length, D = (b) => Math.abs(_(b)), P = (b) => {
+      const x = b.srcEvent.keyCode;
+      if (x === 27 || (b.ctrlKey || b.altKey) && x === 87) {
+        v();
+        return;
+      }
+      if (x === 32) {
+        C();
+        return;
+      }
+      if (x === 13 || x === 9 || x === 39) {
+        g();
+        return;
+      }
+      if (x === 37) {
+        f();
+        return;
+      }
+    }, I = (b) => {
+      if (!(b && (b.wheelDelta || b.deltaX))) return;
+      const F = b.deltaX, le = b.deltaY, Ve = 2;
+      if ((le > Ve || le < -Ve) && F === 0 || b.ctrlKey)
+        return;
+      b.preventDefault();
+      const ye = b.wheelDeltaX, Q = Q.value, ce = D(r.value);
+      if (Q.value = ce, r.value.push(ye), r.value.length > 6 && r.value.shift(), Math.abs(ye) < 80)
+        return;
+      const G = D(r.value);
+      if (a.value === "ended" && ce < G && Q < G && Q < ce) {
+        if (a.value = "started", c.value = Date.now(), ye > 0) {
+          ce();
+          return;
+        }
+        g();
+        return;
+      }
+      a.value === "started" && G < ce && G < Q && ce < Q && (a.value = "ended");
+    };
+    return bt(() => {
+      d = new ia(n.value, {
+        recognizers: [
+          // RecognizerClass, [options], [recognizeWith, ...], [requireFailure, ...]
+          [Hammer.Pinch],
+          // [Hammer.DoubleTab],
+          [Hammer.Tap],
+          // [Hammer.Pan, { pointers: 0 }],
+          [Hammer.Swipe, { direction: Hammer.DIRECTION_HORIZONTAL }]
+        ]
+      }), d.on({
+        swipeleft: g,
+        swiperight: f,
+        // pinchmove: onPinchMove,
+        // pinchin: onPinchIn,
+        pinchout: v,
+        wheel: I,
+        // keyup: onKeyUp,
+        keydown: P,
+        doubletap: v,
+        tap: C
+        // pointerdown: togglePlay,
+      });
+    }), Jt(() => {
+      d && d.destroy();
+    }), (b, x) => (O(), $("div", {
+      class: "pg-interaction-detector",
+      ref_key: "detector",
+      ref: n
+    }, null, 512));
+  }
+}, la = T({
+  name: "PgAdvancedButton",
+  setup(e, { slots: t, emit: s }) {
+    const n = k(), { lang: r } = M(), a = y(() => {
+      var u;
+      return (u = r.value.pg) == null ? void 0 : u.buttons.advanced.title;
+    }), c = () => n.mobileActive = St;
+    function d() {
+      const u = {
+        class: "pg-button-advanced",
+        "data-cy": "pg-button-advanced",
+        label: a.value,
+        onClick: c,
+        rounded: !0,
+        outline: !0,
+        color: "primary"
+      };
+      return h(Oe, u);
+    }
+    return () => d();
+  }
+}), ca = T({
+  name: "PgDefaultButtonRow",
+  setup(e, { slots: t, emit: s }) {
+    function n() {
+      return h("div", {
+        class: "pg-drawer-button-row q-pt-md q-pb-sm row"
+      }, [
+        h("div", { class: "col text-center" }, [h(Ln)]),
+        h("div", { class: "col text-center" }, [h(la)])
+      ]);
+    }
+    return () => n();
+  }
+}), ua = T({
+  name: "PgDefaultDrawer",
+  props: {},
+  emits: ["click"],
+  setup(e, { slots: t, emit: s }) {
+    return () => h(
+      ln,
+      { name: Me },
+      {
+        default: () => h(kn, { center: !0 }),
+        secondary: () => [
+          h(ts, { playMode: !0 }),
+          h(ca)
+        ]
+      }
+    );
+  }
+}), da = T({
+  name: "PgAdvancedDrawer",
+  props: {},
+  emits: ["click"],
+  setup(e, { slots: t, emit: s }) {
+    const { lang: n } = M(), r = y(() => {
+      var a;
+      return (a = n.value.pg) == null ? void 0 : a.buttons.advanced.title;
+    });
+    return () => h(
+      ln,
+      { class: "pg-effects-drawer", name: St, label: r.value },
+      {
+        default: () => h(Vn, { center: !0, playMode: !0 })
+      }
+    );
+  }
+}), ha = T({
+  name: "TsDrawers",
+  setup(e, { slots: t, emit: s }) {
+    const n = k(), { mobileActive: r } = S(n);
+    function a() {
+      return h(
+        qo,
+        {
+          modelValue: r.value,
+          "onUpdate:modelValue": (c) => r.value = c
+        },
+        () => [h(ua), h(da)]
+      );
+    }
+    return () => a();
+  }
+}), pa = { class: "pg-viewport full-height" }, fa = {
+  __name: "PgViewport",
+  props: {
+    modelValue: Boolean
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: t }) {
+    const s = It(), n = j(s.platform.is.desktop), r = j(s.platform.is.mobile), a = k();
+    X();
+    const { loading: c } = S(a), d = e, u = t;
+    j(!0);
+    const f = y({
+      get() {
+        return d.modelValue;
+      },
+      set(g) {
+        u("update:modelValue", g);
+      }
+    });
+    return (g, v) => (O(), _t(qt, { name: "fade" }, {
+      default: jt(() => [
+        vt(De("div", pa, [
+          B(aa),
+          B(A(On)),
+          B(xi),
+          B(qt, { name: "fade" }, {
+            default: jt(() => [
+              vt(B(A(Ao), { class: "loading-graphic" }, null, 512), [
+                [yt, A(c)]
+              ])
+            ]),
+            _: 1
+          }),
+          B(A(Ei)),
+          B(A(bi), {
+            class: "desktop-only",
+            modelValue: n.value,
+            "onUpdate:modelValue": v[0] || (v[0] = (C) => n.value = C)
+          }, null, 8, ["modelValue"]),
+          vt(B(A(ha), { class: "mobile-only" }, null, 512), [
+            [yt, r.value]
+          ])
+        ], 512), [
+          [yt, f.value]
+        ])
+      ]),
+      _: 1
+    }));
+  }
+}, _a = T({
+  name: "PoseGenerator",
+  options: { slug: "pose-generator" },
+  setup(e, { slots: t, emit: s }) {
+    const n = Io(), r = Symbol.for("user-auth"), a = bo(r), c = Pt(), d = Te(), u = X(), f = k(), { show: g } = S(d), { authenticated: v } = S(a), { filters: C } = S(c), { filterData: _ } = S(f);
+    let D = 0;
+    Ne(v, (I, b) => {
+      I === !1 && f.customReset(), I === !0 && b !== !0 && f.getSettings();
+    }), Ne(_, () => {
+      D++, u.updateQueue(), !(D < 3) && (console.log("watch filterData pgStore.setSettings()"), f.setSettings());
+    }), Ne(
+      () => n.fullPath,
+      () => {
+        d.pause();
+      },
+      { immediate: !0 }
+    ), No(), bt(() => {
+      f.init(), f.fetch().then(() => {
+        u.loadQueue();
+      }).catch(() => {
+      });
+    });
+    function P() {
+      const I = {
+        modelValue: g.value,
+        "onUpdate:show": (b) => g.value = b
+      };
+      return [
+        // overlay can now be absolutely positioned within the wrapper
+        // h(GridOverlay, { style: 'z-index: 5;' }),
+        h(yi),
+        h(fa, I)
+      ];
+    }
+    return () => P();
+  }
+});
+export {
+  _a as PoseGenerator,
+  k as usePgStore
+};