@golstats/gsc-game-data 1.0.325-alpha.0 → 1.0.325-alpha.2

package/dist/chunks/section-prominent-chalkboard-9f953d75.js

@@ -0,0 +1,2771 @@
+import { useCssVars, ref, computed, watch, openBlock, createElementBlock, createElementVNode, normalizeStyle, Fragment, renderList, normalizeClass, createCommentVNode, toDisplayString, pushScopeId, popScopeId, withDirectives, vShow, createBlock, createVNode, unref, mergeProps, createTextVNode } from "vue";
+import { e as emitter } from "./vendor-core-a1fbe4ec.js";
+import { _ as _export_sfc } from "./section-comparative-main-6aa6f890.js";
+import { GSCFilters, filtersTypes } from "@golstats/gsc-filters";
+import { GSCCheckbox } from "@golstats/gsc-checkbox";
+import { GSCRadioButton } from "@golstats/gsc-radio-button";
+import { p as playerPositions } from "./section-prominent-volumetric-7b2ffa59.js";
+import axios from "axios";
+const navigatorUserAgent = navigator.userAgent || navigator.vendor || window.opera;
+function areTwoArraysEquals(arr1, arr2) {
+  let flag = Array.isArray(arr1) && Array.isArray(arr2) ? arr1.length === arr2.length : false;
+  if (flag) {
+    for (let item of arr1) {
+      if (!arr2.includes(item)) {
+        flag = false;
+        break;
+      }
+    }
+  }
+  return flag;
+}
+function getPlayValueIndexesFromArray(playsValues) {
+  return playsValues.reduce((accumulator, valueName, index) => {
+    accumulator[valueName] = index;
+    return accumulator;
+  }, {});
+}
+function getTeamFilterOptions(currentFilterOptions, newFilterOptions, teamId) {
+  const filterAux = {
+    statistics: newFilterOptions.statistics.value || 0,
+    playingAs: [...newFilterOptions.playingAs],
+    matchResult: [...newFilterOptions.matchResult],
+    sections: newFilterOptions.firstHalf.concat(newFilterOptions.secondHalf),
+    requiresPlaysFiltering: newFilterOptions.requiresPlaysFiltering || true
+  };
+  filterAux.teamId = teamId;
+  return filterAux;
+}
+function toFixedTwoDigitsMax(number) {
+  return typeof number === "number" ? number.toFixed(2).replace(/\.0+$|0$/g, "") : number;
+}
+function getIsMobileOrTablet() {
+  return (
+    // eslint-disable-next-line max-len
+    /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(
+      navigatorUserAgent
+    ) || // eslint-disable-next-line max-len,no-useless-escape
+    /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(
+      navigatorUserAgent.substr(0, 4)
+    )
+  );
+}
+function getTeamLogoUrl(teamId) {
+  const baseUrl = {}.TEAM_LOGOS_URL || "https://golstatsimages.blob.core.windows.net/teams-80/";
+  return `${baseUrl}${teamId}.png`;
+}
+const _imports_0 = "/play-icn.svg";
+const ToggleButtons_vue_vue_type_style_index_0_scoped_8c3c29c6_lang = "";
+const _hoisted_1$a = { class: "toggle-buttons__background" };
+const _hoisted_2$a = ["onClick"];
+const _hoisted_3$a = {
+  key: 0,
+  class: "toggle-buttons__button__img"
+};
+const _hoisted_4$a = ["src"];
+const _sfc_main$b = {
+  __name: "ToggleButtons",
+  props: {
+    buttons: {
+      type: Array,
+      required: true
+    },
+    selectedButtonIndex: {
+      type: Number,
+      default: 0
+    },
+    height: {
+      type: String,
+      default: "29px"
+    },
+    width: {
+      type: String,
+      default: "100%"
+    },
+    fontSize: {
+      type: String,
+      default: "12px"
+    },
+    fontFamily: {
+      type: String,
+      default: "Poppins-Medium"
+    },
+    borderRadius: {
+      type: String,
+      default: "8px"
+    },
+    mainBackgroundColor: {
+      type: String,
+      default: "#364448"
+    },
+    mainBorderColor: {
+      type: String,
+      default: "#9AA1A3"
+    },
+    mainBorderWidth: {
+      type: String,
+      default: "0.5px"
+    },
+    activeBorderColor: {
+      type: String,
+      default: "#cbee6b"
+    },
+    activeBorderWidth: {
+      type: String,
+      default: "1px"
+    },
+    activeBackgroundColor: {
+      type: String,
+      default: "#2e3b46"
+    },
+    activeFontColor: {
+      type: String,
+      default: "#FFFFFF"
+    }
+  },
+  emits: ["change"],
+  setup(__props, { emit }) {
+    const props = __props;
+    useCssVars((_ctx) => ({
+      "64265112": __props.height,
+      "df19770a": __props.width,
+      "6caf15d1": __props.mainBackgroundColor,
+      "2d25df89": __props.borderRadius,
+      "21a281f6": __props.mainBorderWidth,
+      "208b8393": __props.mainBorderColor,
+      "94332204": __props.fontFamily,
+      "3e48121b": __props.fontSize,
+      "37a2dd49": __props.activeBorderWidth,
+      "368bdee6": __props.activeBorderColor,
+      "ecc8e0b8": __props.activeBackgroundColor,
+      "5528ac63": __props.activeFontColor
+    }));
+    const selectedButtonIndexLocal = ref(props.selectedButtonIndex);
+    const toggleButtonsStyle = computed(() => {
+      return {
+        "--grid-template-columns": `repeat(${props.buttons.length}, 1fr)`
+      };
+    });
+    watch(
+      () => props.selectedButtonIndex,
+      (newValue) => {
+        selectedButtonIndexLocal.value = newValue;
+      }
+    );
+    watch(selectedButtonIndexLocal, (newValue, oldValue) => {
+      if (newValue !== oldValue) {
+        emit("change", { index: newValue, button: props.buttons[newValue] });
+      }
+    });
+    function onClick(index) {
+      selectedButtonIndexLocal.value = index;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$a, [
+        createElementVNode("div", {
+          class: "toggle-buttons",
+          style: normalizeStyle(toggleButtonsStyle.value)
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.buttons, (button, index) => {
+            return openBlock(), createElementBlock("div", {
+              key: `b${index}`,
+              class: normalizeClass(["toggle-buttons__button", { active: selectedButtonIndexLocal.value === index, right: button.img && index > 0 }]),
+              onClick: ($event) => onClick(index)
+            }, [
+              button.img ? (openBlock(), createElementBlock("div", _hoisted_3$a, [
+                createElementVNode("img", {
+                  src: button.img,
+                  alt: ""
+                }, null, 8, _hoisted_4$a)
+              ])) : createCommentVNode("", true),
+              createElementVNode("div", null, toDisplayString(button.text || button), 1)
+            ], 10, _hoisted_2$a);
+          }), 128))
+        ], 4)
+      ]);
+    };
+  }
+};
+const ToggleButtons = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-8c3c29c6"]]);
+const TooltipChalkboard_vue_vue_type_style_index_0_scoped_b3a94cf2_lang = "";
+const _withScopeId$4 = (n) => (pushScopeId("data-v-b3a94cf2"), n = n(), popScopeId(), n);
+const _hoisted_1$9 = { class: "tooltip__content" };
+const _hoisted_2$9 = {
+  key: 0,
+  class: "tooltip__content__category"
+};
+const _hoisted_3$9 = { class: "tooltip__content__player" };
+const _hoisted_4$9 = { class: "tooltip__content__player__name" };
+const _hoisted_5$8 = { class: "tooltip__content__player__photo" };
+const _hoisted_6$8 = ["src"];
+const _hoisted_7$7 = { class: "tooltip__content__minute" };
+const _hoisted_8$4 = {
+  key: 1,
+  class: "tooltip__content__game"
+};
+const _hoisted_9$3 = /* @__PURE__ */ _withScopeId$4(() => /* @__PURE__ */ createElementVNode("div", { class: "tooltip__content__game__name" }, "Partido:", -1));
+const _hoisted_10$2 = { class: "tooltip__content__game__round-abbreviation" };
+const _hoisted_11$2 = { class: "tooltip__content__game__logo" };
+const _hoisted_12$1 = ["src"];
+const _hoisted_13$1 = /* @__PURE__ */ _withScopeId$4(() => /* @__PURE__ */ createElementVNode("div", { class: "tooltip__content__game__vs" }, "VS", -1));
+const _hoisted_14$1 = { class: "tooltip__content__game__logo" };
+const _hoisted_15$1 = ["src"];
+const _hoisted_16$1 = {
+  key: 2,
+  class: "tooltip__content__team"
+};
+const _hoisted_17$1 = /* @__PURE__ */ _withScopeId$4(() => /* @__PURE__ */ createElementVNode("div", { class: "tooltip__content__team__name" }, "Equipo:", -1));
+const _hoisted_18$1 = { class: "tooltip__content__team__logo" };
+const _hoisted_19$1 = ["src"];
+const _sfc_main$a = {
+  __name: "TooltipChalkboard",
+  props: {
+    event: {
+      type: Object,
+      default: () => ({})
+    },
+    position: {
+      type: Object,
+      default: () => ({ x: "0", y: "0" })
+    }
+  },
+  emits: ["close"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const style = computed(() => {
+      return {
+        "--top": props.position.y,
+        "--left": props.position.x
+      };
+    });
+    const playerName = computed(() => {
+      return `${props.event.player.player_name} ${props.event.player.player_lastname}`;
+    });
+    const minute = computed(() => {
+      const [minute2] = props.event.momentOfPlay.split(":");
+      return `${Number(minute2)}'`;
+    });
+    function onClickOverlay() {
+      emit("close");
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "tooltip",
+        onClick: onClickOverlay,
+        style: normalizeStyle(style.value)
+      }, [
+        createElementVNode("div", _hoisted_1$9, [
+          __props.event.categoryName ? (openBlock(), createElementBlock("div", _hoisted_2$9, toDisplayString(__props.event.categoryName), 1)) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_3$9, [
+            createElementVNode("div", _hoisted_4$9, toDisplayString(playerName.value), 1),
+            createElementVNode("div", _hoisted_5$8, [
+              createElementVNode("img", {
+                src: __props.event.player.photo,
+                alt: ""
+              }, null, 8, _hoisted_6$8)
+            ])
+          ]),
+          createElementVNode("div", _hoisted_7$7, "Minuto: " + toDisplayString(minute.value), 1),
+          __props.event.game ? (openBlock(), createElementBlock("div", _hoisted_8$4, [
+            _hoisted_9$3,
+            createElementVNode("div", _hoisted_10$2, toDisplayString(__props.event.game.roundAbbreviation), 1),
+            createElementVNode("div", _hoisted_11$2, [
+              createElementVNode("img", {
+                src: __props.event.game.homeTeam.logo,
+                alt: ""
+              }, null, 8, _hoisted_12$1)
+            ]),
+            _hoisted_13$1,
+            createElementVNode("div", _hoisted_14$1, [
+              createElementVNode("img", {
+                src: __props.event.game.awayTeam.logo,
+                alt: ""
+              }, null, 8, _hoisted_15$1)
+            ])
+          ])) : (openBlock(), createElementBlock("div", _hoisted_16$1, [
+            _hoisted_17$1,
+            createElementVNode("div", _hoisted_18$1, [
+              createElementVNode("img", {
+                src: __props.event.team.logo,
+                alt: ""
+              }, null, 8, _hoisted_19$1)
+            ])
+          ]))
+        ])
+      ], 4);
+    };
+  }
+};
+const Tooltip = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-b3a94cf2"]]);
+const _hoisted_1$8 = ["id"];
+const _hoisted_2$8 = ["fill"];
+const _hoisted_3$8 = ["id"];
+const _hoisted_4$8 = ["fill"];
+const _hoisted_5$7 = ["stroke-dasharray", "x1", "y1", "x2", "y2", "marker-end"];
+const _hoisted_6$7 = ["x", "y", "stroke-width", "fill", "stroke"];
+const _hoisted_7$6 = ["x", "y"];
+const _sfc_main$9 = {
+  __name: "EventConnection",
+  props: {
+    eventConnection: {
+      type: Object,
+      required: true
+    },
+    color: {
+      type: String,
+      required: true
+    },
+    isLastEvent: {
+      type: Boolean,
+      default: false
+    },
+    mainEventIdSelected: {
+      type: Number,
+      default: 0
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const connectionPath = computed(() => {
+      const connectionPath2 = [];
+      if (props.eventConnection.hasConnectionPath) {
+        const totalPaths = props.eventConnection.x1 === props.eventConnection.x2 && props.eventConnection.y1 === props.eventConnection.y2 ? 1 : 2;
+        let firstPointY = getFieldY(
+          props.eventConnection.previousEvent ? props.eventConnection.previousEvent.y3 : props.eventConnection.y1
+        );
+        const firstPointX = getFieldX(
+          props.eventConnection.previousEvent ? props.eventConnection.previousEvent.x3 : props.eventConnection.x1
+        );
+        let secondPointY = 0;
+        let secondPointX = 0;
+        if (totalPaths === 2) {
+          secondPointY = getFieldY(props.eventConnection.y2);
+          secondPointX = getFieldX(props.eventConnection.x2);
+        }
+        const thirdPointY = getFieldY(props.eventConnection.y3);
+        const thirdPointX = getFieldX(props.eventConnection.x3);
+        if (totalPaths === 1) {
+          connectionPath2.push({
+            x1: firstPointX,
+            y1: firstPointY,
+            x2: thirdPointX,
+            y2: thirdPointY
+          });
+        } else {
+          connectionPath2.push({
+            x1: firstPointX,
+            y1: firstPointY,
+            x2: secondPointX,
+            y2: secondPointY
+          });
+          connectionPath2.push({
+            x1: secondPointX,
+            y1: secondPointY,
+            x2: thirdPointX,
+            y2: thirdPointY
+          });
+        }
+      }
+      return connectionPath2;
+    });
+    const opacity = computed(() => {
+      return props.mainEventIdSelected !== 0 ? props.eventConnection.relatedPlayId === props.mainEventIdSelected ? 1 : 0.1 : 1;
+    });
+    const isVisible = computed(() => {
+      return props.mainEventIdSelected !== 0 ? props.eventConnection.relatedPlayId === props.mainEventIdSelected : true;
+    });
+    const y = computed(() => {
+      return getFieldY(
+        props.eventConnection.previousEvent ? props.eventConnection.previousEvent.y3 : props.eventConnection.y1
+      );
+    });
+    const x = computed(() => {
+      return getFieldX(
+        props.eventConnection.previousEvent ? props.eventConnection.previousEvent.x3 : props.eventConnection.x1
+      );
+    });
+    function getFieldY(y2) {
+      return (1 - y2) * 100;
+    }
+    function getFieldX(x2) {
+      return x2 * 100;
+    }
+    function onMouseOver(event) {
+      emitter.emit("mouse-over-event", {
+        mouseEvent: event,
+        eventConnection: props.eventConnection,
+        position: {
+          x: x.value,
+          y: y.value
+        }
+      });
+    }
+    function onMouseLeave() {
+      emitter.emit("mouse-leave-event", {
+        mainEventId: props.eventConnection.relatedPlayId,
+        eventId: props.eventConnection.playId
+      });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("defs", null, [
+          withDirectives(createElementVNode("marker", {
+            id: `a-${__props.eventConnection.playId}`,
+            markerWidth: "10",
+            markerHeight: "10",
+            refX: "0",
+            refY: "3",
+            orient: "auto",
+            markerUnits: "strokeWidth",
+            style: normalizeStyle({ opacity: opacity.value })
+          }, [
+            createElementVNode("path", {
+              d: "M0,0 L0,6 L9,3 z",
+              fill: __props.color
+            }, null, 8, _hoisted_2$8)
+          ], 12, _hoisted_1$8), [
+            [vShow, isVisible.value]
+          ]),
+          withDirectives(createElementVNode("marker", {
+            id: `b-${__props.eventConnection.playId}`,
+            markerWidth: "4",
+            markerHeight: "4",
+            refX: "2",
+            refY: "2",
+            orient: "auto",
+            markerUnits: "strokeWidth",
+            style: normalizeStyle({ opacity: opacity.value })
+          }, [
+            createElementVNode("circle", {
+              cx: "2",
+              cy: "2",
+              r: "2",
+              fill: __props.color
+            }, null, 8, _hoisted_4$8)
+          ], 12, _hoisted_3$8), [
+            [vShow, isVisible.value]
+          ])
+        ]),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(connectionPath.value, (path, i) => {
+          return openBlock(), createElementBlock(Fragment, null, [
+            path.x1 && path.y1 ? withDirectives((openBlock(), createElementBlock("line", {
+              key: `${__props.eventConnection.playId}-${i}`,
+              style: normalizeStyle({ stroke: __props.color, "stroke-width": 2, opacity: opacity.value }),
+              "stroke-dasharray": i === 0 && connectionPath.value.length === 2 ? "none" : "5,5",
+              x1: `${path.x1}%`,
+              y1: `${path.y1}%`,
+              x2: `${path.x2}%`,
+              y2: `${path.y2}%`,
+              "marker-start": "`url(`#b-${eventConnection.playId}`)`",
+              "marker-end": `url(${__props.isLastEvent && i === connectionPath.value.length - 1 ? `#a-${__props.eventConnection.playId}` : ""})`
+            }, null, 12, _hoisted_5$7)), [
+              [vShow, isVisible.value]
+            ]) : createCommentVNode("", true)
+          ], 64);
+        }), 256)),
+        withDirectives(createElementVNode("g", {
+          onMouseover: onMouseOver,
+          onMouseleave: onMouseLeave,
+          style: normalizeStyle({ cursor: "pointer", opacity: opacity.value })
+        }, [
+          createElementVNode("rect", {
+            x: `${x.value}%`,
+            y: `${y.value}%`,
+            transform: "translate(-14, -14)",
+            height: "28",
+            width: "28",
+            "stroke-width": __props.eventConnection.isMainPlay ? 2 : 1,
+            fill: __props.color,
+            stroke: __props.eventConnection.isMainPlay ? "#fff" : "#999",
+            style: normalizeStyle({ opacity: opacity.value }),
+            rx: "14",
+            ry: "14"
+          }, null, 12, _hoisted_6$7),
+          createElementVNode("text", {
+            x: `${x.value}%`,
+            y: `${y.value}%`,
+            "text-anchor": "middle",
+            "dominant-baseline": "middle",
+            dy: "1",
+            "font-size": "15",
+            fill: "#fff",
+            "font-family": "'Poppins-SemiBold', sans-serif",
+            style: normalizeStyle({ opacity: opacity.value })
+          }, toDisplayString(__props.eventConnection.player ? __props.eventConnection.player.jersey : ""), 13, _hoisted_7$6)
+        ], 36), [
+          [vShow, isVisible.value]
+        ])
+      ], 64);
+    };
+  }
+};
+const _sfc_main$8 = {
+  __name: "EventConnections",
+  props: {
+    eventConnections: {
+      type: Object,
+      required: true
+    },
+    mainEventIdSelected: {
+      type: Number,
+      default: 0
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const eventConnectionsToShow = computed(() => {
+      return props.eventConnections.getEventsConnectionsByEventType();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(true), createElementBlock(Fragment, null, renderList(eventConnectionsToShow.value, (eventConnection, index) => {
+        return openBlock(), createBlock(_sfc_main$9, {
+          key: eventConnection.id,
+          color: __props.eventConnections.getEventColor(eventConnection),
+          "is-last-event": index === eventConnectionsToShow.value.length - 1,
+          "event-connection": eventConnection,
+          "main-event-id-selected": __props.mainEventIdSelected
+        }, null, 8, ["color", "is-last-event", "event-connection", "main-event-id-selected"]);
+      }), 128);
+    };
+  }
+};
+const SoccerChalkboard_vue_vue_type_style_index_0_scoped_17190e13_lang = "";
+const _hoisted_1$7 = { class: "soccer-chalkboard" };
+const _hoisted_2$7 = {
+  id: "soccerChalkboardField",
+  class: "soccer-chalkboard__field"
+};
+const _hoisted_3$7 = ["src"];
+const _hoisted_4$7 = {
+  viewBox: "0 0 547 340",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _sfc_main$7 = {
+  __name: "SoccerChalkboard",
+  props: {
+    eventsConnections: {
+      type: Array,
+      default: () => []
+    },
+    listType: {
+      type: String,
+      default: "events"
+    },
+    playersSelected: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    },
+    teamsSelected: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    },
+    isAssistantZoneVisible: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const isMobileOrTablet = getIsMobileOrTablet();
+    const mouseLeaveTimeout = isMobileOrTablet ? 0 : 1e3;
+    emitter.on("mouse-over-time-event", (mainEventId) => {
+      setMainEventIdSelected(mainEventId);
+      setTimeout(() => {
+        setMainEventIdSelected(mainEventId);
+      }, mouseLeaveTimeout);
+    });
+    emitter.on("mouse-leave-time-event", (mainEventId) => {
+      setTimeout(() => {
+        if (mainEventIdSelected.value == mainEventId && !isTooltipVisible.value)
+          setMainEventIdSelected(0);
+      }, mouseLeaveTimeout);
+    });
+    emitter.on("mouse-over-event", (event) => {
+      onMouseOverEvent(event);
+    });
+    emitter.on("mouse-leave-event", (event) => {
+      setTimeout(() => {
+        if (event.eventId === eventIdShowingTooltip.value) {
+          onMouseLeaveEvent();
+        }
+      }, mouseLeaveTimeout);
+    });
+    const isTooltipVisible = ref(false);
+    const eventSelected = ref({});
+    const mainEventIdSelected = ref(0);
+    const eventIdShowingTooltip = ref(0);
+    const tooltipPosition = ref({ x: 0, y: 0 });
+    const fieldImgSrc = computed(() => {
+      return props.isAssistantZoneVisible ? "https://golstatsimages.blob.core.windows.net/todoelfut/pizarra.jpg" : "https://golstatsimages.blob.core.windows.net/todoelfut/field-green-posesion.jpg";
+    });
+    function setMainEventIdSelected(mainEventId) {
+      mainEventIdSelected.value = mainEventId;
+    }
+    function onCloseTooltip() {
+      isTooltipVisible.value = false;
+    }
+    function onMouseOverEvent(event) {
+      const tooltipMaxWidth = 170;
+      const soccerChalkboardField = document.getElementById("soccerChalkboardField");
+      if (soccerChalkboardField) {
+        const fieldRect = soccerChalkboardField.getBoundingClientRect();
+        const xInsideField = event.position.x / 100 * fieldRect.width + 14;
+        const yInsideField = event.position.y / 100 * fieldRect.height + 14;
+        const xAux = xInsideField + tooltipMaxWidth > fieldRect.width ? fieldRect.width - tooltipMaxWidth : xInsideField;
+        const yAux = yInsideField;
+        mainEventIdSelected.value = event.eventConnection.relatedPlayId;
+        eventIdShowingTooltip.value = event.eventConnection.playId;
+        eventSelected.value = event.eventConnection;
+        tooltipPosition.value = {
+          x: `${xAux}px`,
+          y: `${yAux}px`
+        };
+        isTooltipVisible.value = true;
+      }
+    }
+    function onMouseLeaveEvent() {
+      isTooltipVisible.value = false;
+      mainEventIdSelected.value = 0;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$7, [
+        createElementVNode("div", _hoisted_2$7, [
+          createElementVNode("img", {
+            src: fieldImgSrc.value,
+            alt: ""
+          }, null, 8, _hoisted_3$7),
+          (openBlock(), createElementBlock("svg", _hoisted_4$7, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.eventsConnections, (eventConnections, index) => {
+              return openBlock(), createElementBlock(Fragment, null, [
+                __props.listType === "events" && eventConnections.hasTeam(__props.teamsSelected) || __props.listType === "players" && eventConnections.hasPlayer(__props.playersSelected) ? (openBlock(), createBlock(_sfc_main$8, {
+                  key: index,
+                  "event-connections": eventConnections,
+                  "main-event-id-selected": mainEventIdSelected.value
+                }, null, 8, ["event-connections", "main-event-id-selected"])) : createCommentVNode("", true)
+              ], 64);
+            }), 256))
+          ]))
+        ]),
+        isTooltipVisible.value ? (openBlock(), createBlock(Tooltip, {
+          key: 0,
+          position: tooltipPosition.value,
+          event: eventSelected.value,
+          onClose: onCloseTooltip
+        }, null, 8, ["position", "event"])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+};
+const SoccerChalkboard = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-17190e13"]]);
+const EventsTimeLine_vue_vue_type_style_index_0_scoped_f70399b8_lang = "";
+const _withScopeId$3 = (n) => (pushScopeId("data-v-f70399b8"), n = n(), popScopeId(), n);
+const _hoisted_1$6 = { class: "events-timeline" };
+const _hoisted_2$6 = /* @__PURE__ */ _withScopeId$3(() => /* @__PURE__ */ createElementVNode("div", { class: "events-timeline__back-line" }, null, -1));
+const _hoisted_3$6 = ["onMouseover", "onMouseleave"];
+const _hoisted_4$6 = ["id"];
+const _hoisted_5$6 = /* @__PURE__ */ _withScopeId$3(() => /* @__PURE__ */ createElementVNode("path", {
+  "fill-rule": "evenodd",
+  "clip-rule": "evenodd",
+  d: "M3.77234 0.45166C2.11548 0.45166 0.772339 1.79481 0.772339 3.45166V14.4517C0.772339 16.1085 2.11548 17.4517 3.77234 17.4517H7.96294L10.2723 21.4517L12.5817 17.4517H16.7723C18.4292 17.4517 19.7723 16.1085 19.7723 14.4517V3.45166C19.7723 1.79481 18.4292 0.45166 16.7723 0.45166H3.77234Z"
+}, null, -1));
+const _hoisted_6$6 = [
+  _hoisted_5$6
+];
+const _hoisted_7$5 = ["fill"];
+const _hoisted_8$3 = ["mask"];
+const _hoisted_9$2 = ["stroke"];
+const _sfc_main$6 = {
+  __name: "EventsTimeLine",
+  props: {
+    eventsConnections: {
+      type: Array,
+      default: () => []
+    },
+    listType: {
+      type: String,
+      default: "events"
+    },
+    playersSelected: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    },
+    teamsSelected: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const gameTimes = ["0'", "45'", "90'"];
+    const eventsByTime = computed(() => {
+      return props.eventsConnections.reduce((acc, eventsConnection) => {
+        const eventTime = {
+          minute: `0'`,
+          left: "0%",
+          color: eventsConnection.getTeamColor(),
+          fontColor: eventsConnection.getTeamFontColor(),
+          playId: eventsConnection.mainPlay.playId,
+          playerId: eventsConnection.mainPlay.playerId,
+          teamId: eventsConnection.mainPlay.teamId,
+          relatedPlayId: eventsConnection.relatedPlayId
+        };
+        const [minutes] = eventsConnection.mainPlay.momentOfPlay.split(":");
+        const minutesNumber = parseInt(minutes);
+        if (minutesNumber >= 90) {
+          eventTime.minute = `${minutesNumber}'`;
+          eventTime.left = "100%";
+        } else {
+          eventTime.minute = `${minutesNumber}'`;
+          eventTime.left = `${minutesNumber / 90 * 100}%`;
+        }
+        acc.push(eventTime);
+        return acc;
+      }, []);
+    });
+    function onMouseOver(event) {
+      emitter.emit("mouse-over-time-event", event.playId);
+    }
+    function onMouseLeave(event) {
+      emitter.emit("mouse-leave-time-event", event.playId);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$6, [
+        (openBlock(), createElementBlock(Fragment, null, renderList(gameTimes, (gameTime, index) => {
+          return createElementVNode("div", {
+            class: "events-timeline__game-time",
+            key: index
+          }, toDisplayString(gameTime), 1);
+        }), 64)),
+        _hoisted_2$6,
+        (openBlock(true), createElementBlock(Fragment, null, renderList(eventsByTime.value, (eventMinute, index) => {
+          return openBlock(), createElementBlock(Fragment, null, [
+            __props.listType === "events" && __props.teamsSelected.has(eventMinute.teamId) || __props.listType === "players" && __props.playersSelected.has(eventMinute.playerId) ? (openBlock(), createElementBlock("svg", {
+              key: index,
+              width: "20",
+              height: "22",
+              viewBox: "0 0 20 22",
+              fill: "none",
+              xmlns: "http://www.w3.org/2000/svg",
+              style: normalizeStyle({ left: eventMinute.left, cursor: "pointer" }),
+              onMouseover: ($event) => onMouseOver(eventMinute),
+              onMouseleave: ($event) => onMouseLeave(eventMinute)
+            }, [
+              createElementVNode("mask", {
+                id: eventMinute.playId.toString(),
+                fill: "white"
+              }, _hoisted_6$6, 8, _hoisted_4$6),
+              createElementVNode("path", {
+                "fill-rule": "evenodd",
+                "clip-rule": "evenodd",
+                d: "M3.77234 0.45166C2.11548 0.45166 0.772339 1.79481 0.772339 3.45166V14.4517C0.772339 16.1085 2.11548 17.4517 3.77234 17.4517H7.96294L10.2723 21.4517L12.5817 17.4517H16.7723C18.4292 17.4517 19.7723 16.1085 19.7723 14.4517V3.45166C19.7723 1.79481 18.4292 0.45166 16.7723 0.45166H3.77234Z",
+                fill: eventMinute.color
+              }, null, 8, _hoisted_7$5),
+              createElementVNode("path", {
+                d: "M7.96294 17.4517L8.82896 16.9517L8.54029 16.4517H7.96294V17.4517ZM10.2723 21.4517L9.40631 21.9517L10.2723 23.4517L11.1384 21.9517L10.2723 21.4517ZM12.5817 17.4517V16.4517H12.0044L11.7157 16.9517L12.5817 17.4517ZM1.77234 3.45166C1.77234 2.34709 2.66777 1.45166 3.77234 1.45166V-0.54834C1.5632 -0.54834 -0.227661 1.24252 -0.227661 3.45166H1.77234ZM1.77234 14.4517V3.45166H-0.227661V14.4517H1.77234ZM3.77234 16.4517C2.66777 16.4517 1.77234 15.5562 1.77234 14.4517H-0.227661C-0.227661 16.6608 1.5632 18.4517 3.77234 18.4517V16.4517ZM7.96294 16.4517H3.77234V18.4517H7.96294V16.4517ZM7.09691 17.9517L9.40631 21.9517L11.1384 20.9517L8.82896 16.9517L7.09691 17.9517ZM11.1384 21.9517L13.4478 17.9517L11.7157 16.9517L9.40631 20.9517L11.1384 21.9517ZM16.7723 16.4517H12.5817V18.4517H16.7723V16.4517ZM18.7723 14.4517C18.7723 15.5562 17.8769 16.4517 16.7723 16.4517V18.4517C18.9815 18.4517 20.7723 16.6608 20.7723 14.4517H18.7723ZM18.7723 3.45166V14.4517H20.7723V3.45166H18.7723ZM16.7723 1.45166C17.8769 1.45166 18.7723 2.34709 18.7723 3.45166H20.7723C20.7723 1.24252 18.9815 -0.54834 16.7723 -0.54834V1.45166ZM3.77234 1.45166H16.7723V-0.54834H3.77234V1.45166Z",
+                fill: "#172531",
+                mask: `url(#${eventMinute.playId})`
+              }, null, 8, _hoisted_8$3),
+              createElementVNode("g", null, [
+                createElementVNode("text", {
+                  x: "50%",
+                  y: "8",
+                  "text-anchor": "middle",
+                  "dominant-baseline": "middle",
+                  dy: "1",
+                  "font-size": "9",
+                  "font-family": "Poppins-Light",
+                  stroke: eventMinute.fontColor,
+                  "stroke-width": "0.7"
+                }, toDisplayString(eventMinute.minute), 9, _hoisted_9$2)
+              ])
+            ], 44, _hoisted_3$6)) : createCommentVNode("", true)
+          ], 64);
+        }), 256))
+      ]);
+    };
+  }
+};
+const EventsTimeLine = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-f70399b8"]]);
+const CategoriesHeaderTeam_vue_vue_type_style_index_0_scoped_2a81f2f0_lang = "";
+const _withScopeId$2 = (n) => (pushScopeId("data-v-2a81f2f0"), n = n(), popScopeId(), n);
+const _hoisted_1$5 = { class: "header-team__info" };
+const _hoisted_2$5 = { class: "header-team__info__checkbox" };
+const _hoisted_3$5 = {
+  key: 0,
+  class: "header-team__info__logo"
+};
+const _hoisted_4$5 = ["src"];
+const _hoisted_5$5 = { class: "header-team__info__name" };
+const _hoisted_6$5 = { class: "header-team__arrow" };
+const _hoisted_7$4 = /* @__PURE__ */ _withScopeId$2(() => /* @__PURE__ */ createElementVNode("div", { class: "header-team__arrow__circle" }, null, -1));
+const _hoisted_8$2 = /* @__PURE__ */ _withScopeId$2(() => /* @__PURE__ */ createElementVNode("div", { class: "header-team__arrow__line" }, null, -1));
+const _sfc_main$5 = {
+  __name: "CategoriesHeaderTeam",
+  props: {
+    team: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isHomeTeam: {
+      type: Boolean,
+      default: true
+    },
+    teamsSelected: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    },
+    isGamePreMatch: {
+      type: Boolean,
+      default: false
+    },
+    isTeamForAnalysis: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["change-team"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const style = computed(() => {
+      return {
+        "--flex-direction-info": props.isHomeTeam ? "flex" : "row-reverse",
+        "--justify-content-info": props.isHomeTeam ? "flex-start" : "flex-end",
+        "--arrow-color": props.isHomeTeam ? "#336dff" : "#7ed321"
+      };
+    });
+    const teamName = computed(() => {
+      return props.team.colloquial_name || props.team.colloquialName || props.team.name || props.team.team_name || "";
+    });
+    function onChangeTeam(value) {
+      emit("change-team", { value, team: props.team });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "header-team",
+        style: normalizeStyle(style.value)
+      }, [
+        createElementVNode("div", _hoisted_1$5, [
+          createElementVNode("div", _hoisted_2$5, [
+            createVNode(unref(GSCCheckbox), {
+              "model-value": __props.team.isSelected,
+              "avoid-interaction": __props.teamsSelected.size === 1 && __props.team.isSelected,
+              "onUpdate:modelValue": onChangeTeam
+            }, null, 8, ["model-value", "avoid-interaction"])
+          ]),
+          teamName.value !== "Rival" ? (openBlock(), createElementBlock("div", _hoisted_3$5, [
+            __props.team.logo ? (openBlock(), createElementBlock("img", {
+              key: 0,
+              src: __props.team.logo,
+              alt: "h-team"
+            }, null, 8, _hoisted_4$5)) : createCommentVNode("", true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_5$5, toDisplayString(teamName.value), 1)
+        ]),
+        createElementVNode("div", _hoisted_6$5, [
+          _hoisted_7$4,
+          _hoisted_8$2,
+          createElementVNode("div", {
+            class: normalizeClass(`header-team__arrow__triangle-${props.isHomeTeam ? "right" : "left"}`)
+          }, null, 2)
+        ])
+      ], 4);
+    };
+  }
+};
+const CategoriesHeaderTeam = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-2a81f2f0"]]);
+const ListEvents_vue_vue_type_style_index_0_scoped_bfb2c86b_lang = "";
+const _withScopeId$1 = (n) => (pushScopeId("data-v-bfb2c86b"), n = n(), popScopeId(), n);
+const _hoisted_1$4 = { class: "list-events" };
+const _hoisted_2$4 = /* @__PURE__ */ _withScopeId$1(() => /* @__PURE__ */ createElementVNode("div", { class: "list-events__title" }, "Tipos de jugadas:", -1));
+const _hoisted_3$4 = { class: "list-events__list" };
+const _hoisted_4$4 = ["onClick"];
+const _hoisted_5$4 = /* @__PURE__ */ _withScopeId$1(() => /* @__PURE__ */ createElementVNode("img", {
+  src: _imports_0,
+  alt: ""
+}, null, -1));
+const _hoisted_6$4 = [
+  _hoisted_5$4
+];
+const _sfc_main$4 = {
+  __name: "ListEvents",
+  props: {
+    listEventsToDisplay: {
+      type: Array,
+      default: () => []
+    },
+    awaitForListEvents: {
+      type: Boolean,
+      default: false
+    },
+    lastEventTypeSelected: {
+      type: Object,
+      default: () => ({})
+    },
+    canPlayVideos: {
+      type: Boolean,
+      default: true
+    },
+    totalEvents: {
+      type: Number,
+      default: 0
+    },
+    isPrivilegesVrApplicable: {
+      type: Boolean,
+      default: false
+    },
+    totalEventsPrivilegesVr: {
+      type: Number,
+      default: 0
+    }
+  },
+  emits: ["change-event-type", "click-play"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const defaultEvents = [
+      {
+        categoriesIds: /* @__PURE__ */ new Set([607, 608]),
+        name: "Oportunidad de gol",
+        value: "0"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([12, 55, "54_r", "35_r"]),
+        name: "Goles",
+        value: "1"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([19]),
+        name: "Tiros a gol",
+        value: "2"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([537, 540, 544, 547]),
+        name: "Tiros a gol (portería)",
+        value: "3"
+      },
+      // {
+      //   categoriesIds: new Set([]),
+      //   name: 'Pases que ganan terreno',
+      //   value: '4'
+      // },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([13, 25]),
+        name: "Centros totales",
+        value: "5"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([98, 101, 104, 105, 109, 112, 115, 116]),
+        name: "Centros acertados",
+        value: "6"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([11]),
+        name: "Balones ganados en área rival",
+        value: "7"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([4]),
+        name: "1vs1 exitosos ofensivos",
+        value: "8"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([208]),
+        name: "1vs1 no exitosos ofensivos",
+        value: "9"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([5]),
+        name: "1vs1 exitoso defensivo",
+        value: "10"
+      },
+      {
+        categoriesIds: /* @__PURE__ */ new Set([31, 32]),
+        name: "Corners",
+        value: "11"
+      }
+    ];
+    const listEvents = ref(props.awaitForListEvents ? [] : defaultEvents);
+    const listEventsMap = ref(
+      props.awaitForListEvents ? /* @__PURE__ */ new Map() : listEvents.value.reduce((acc, item) => {
+        acc.set(item.value, item);
+        return acc;
+      }, /* @__PURE__ */ new Map())
+    );
+    const radioEventTypeSelected = ref(props.awaitForListEvents ? "" : listEvents.value[0].value);
+    watch(
+      () => props.listEventsToDisplay,
+      (newListEvents) => {
+        if (newListEvents.length) {
+          listEventsMap.value = /* @__PURE__ */ new Map();
+          listEvents.value = newListEvents.map((event, index) => {
+            const eventAux = {
+              name: event.name,
+              singleName: event.single_name,
+              categories: new Set(event.categories),
+              categoriesIds: event.categories,
+              post: event.post,
+              prev: event.prev,
+              value: index.toString()
+            };
+            listEventsMap.value.set(eventAux.value, eventAux);
+            return eventAux;
+          });
+          let eventTypeSelected = null;
+          if (props.lastEventTypeSelected && props.lastEventTypeSelected.name) {
+            eventTypeSelected = listEventsMap.value.get(props.lastEventTypeSelected.value);
+          }
+          radioEventTypeSelected.value = eventTypeSelected ? eventTypeSelected.value : listEvents.value[0].value;
+        }
+      },
+      { immediate: true, deep: true }
+    );
+    watch(
+      () => radioEventTypeSelected.value,
+      (newEventType) => {
+        const event = listEventsMap.value.get(newEventType);
+        if (event) {
+          emit("change-event-type", event);
+        }
+      }
+    );
+    function onClickPlay(listEvent, isActive) {
+      if (props.canPlayVideos && isActive) {
+        emit("click-play", listEvent.categoriesIds);
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$4, [
+        _hoisted_2$4,
+        createElementVNode("div", _hoisted_3$4, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(listEvents.value, (event) => {
+            return openBlock(), createElementBlock("div", {
+              key: event.value,
+              class: "list-events__list__item"
+            }, [
+              createVNode(unref(GSCRadioButton), {
+                modelValue: radioEventTypeSelected.value,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => radioEventTypeSelected.value = $event),
+                value: event.value,
+                label: event.name,
+                name: "event-type",
+                "radio-position": "left",
+                class: "list-events__list__item__radio"
+              }, null, 8, ["modelValue", "value", "label"]),
+              createElementVNode("button", {
+                class: normalizeClass(["list-events__list__item__btn-play", {
+                  disabled: !(__props.canPlayVideos && radioEventTypeSelected.value === event.value && (__props.isPrivilegesVrApplicable ? __props.totalEventsPrivilegesVr : __props.totalEvents) > 0)
+                }]),
+                onClick: ($event) => onClickPlay(
+                  event,
+                  __props.canPlayVideos && radioEventTypeSelected.value === event.value && (__props.isPrivilegesVrApplicable ? __props.totalEventsPrivilegesVr : __props.totalEvents) > 0
+                )
+              }, _hoisted_6$4, 10, _hoisted_4$4)
+            ]);
+          }), 128))
+        ])
+      ]);
+    };
+  }
+};
+const ListEvents = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-bfb2c86b"]]);
+const ItemPlayer_vue_vue_type_style_index_0_scoped_03a1125d_lang = "";
+const _hoisted_1$3 = { class: "item-player__info" };
+const _hoisted_2$3 = { class: "item-player__info__photo" };
+const _hoisted_3$3 = { class: "item-player__info__photo__img" };
+const _hoisted_4$3 = ["src"];
+const _hoisted_5$3 = { class: "item-player__info__data" };
+const _hoisted_6$3 = { class: "item-player__info__data__name" };
+const _hoisted_7$3 = { class: "item-player__info__data__position" };
+const _hoisted_8$1 = { class: "item-player__info__data__position__nationality" };
+const _hoisted_9$1 = ["src"];
+const _hoisted_10$1 = { class: "item-player__info__data__position__position" };
+const _hoisted_11$1 = { class: "item-player__jersey-number" };
+const _sfc_main$3 = {
+  __name: "ItemPlayer",
+  props: {
+    isFemale: {
+      type: Boolean,
+      default: false
+    },
+    player: {
+      type: Object,
+      default: () => {
+      }
+    },
+    selectedPlayers: {
+      type: Set,
+      default: () => /* @__PURE__ */ new Set()
+    }
+  },
+  emits: ["change-player"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const playerPosition = computed(() => {
+      return playerPositions.get(props.player.position_id) || "";
+    });
+    const nationalityFlagUrl = computed(() => {
+      return `https://golstatsimages.blob.core.windows.net/flags/${props.player.nationality_id}.jpg`;
+    });
+    function onUpdateModelValue(value) {
+      emit("change-player", value);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["item-player", { inactive: !__props.player.isSelected }])
+      }, [
+        createVNode(unref(GSCCheckbox), {
+          "model-value": __props.player.isSelected,
+          "avoid-interaction": __props.selectedPlayers.size === 1 && __props.player.isSelected,
+          "onUpdate:modelValue": onUpdateModelValue
+        }, null, 8, ["model-value", "avoid-interaction"]),
+        createElementVNode("div", _hoisted_1$3, [
+          createElementVNode("div", _hoisted_2$3, [
+            createElementVNode("div", _hoisted_3$3, [
+              createElementVNode("img", {
+                src: __props.player.photo,
+                alt: "player-photo"
+              }, null, 8, _hoisted_4$3)
+            ])
+          ]),
+          createElementVNode("div", _hoisted_5$3, [
+            createElementVNode("div", _hoisted_6$3, toDisplayString(__props.player.player_lastname) + ", " + toDisplayString(__props.player.player_name), 1),
+            createElementVNode("div", _hoisted_7$3, [
+              createElementVNode("div", _hoisted_8$1, [
+                createElementVNode("img", { src: nationalityFlagUrl.value }, null, 8, _hoisted_9$1)
+              ]),
+              createElementVNode("div", _hoisted_10$1, toDisplayString(__props.isFemale ? playerPosition.value.replace("Portero", "Portera").replace("Delantero", "Delantera").replace("Volante defensivo", "Volante defensiva").replace("Volante ofensivo", "Volante ofensiva") : playerPosition.value), 1)
+            ])
+          ])
+        ]),
+        createElementVNode("div", _hoisted_11$1, toDisplayString(__props.player.jersey), 1)
+      ], 2);
+    };
+  }
+};
+const ItemPlayer = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-03a1125d"]]);
+const ListPlayers_vue_vue_type_style_index_0_scoped_a0fc063d_lang = "";
+const _hoisted_1$2 = { class: "list-players" };
+const _hoisted_2$2 = { class: "list-players__header" };
+const _hoisted_3$2 = ["src"];
+const _hoisted_4$2 = { class: "list-players__header__team__name" };
+const _hoisted_5$2 = ["src"];
+const _hoisted_6$2 = { class: "list-players__header__team__name" };
+const _hoisted_7$2 = { class: "list-players__body" };
+const _sfc_main$2 = {
+  __name: "ListPlayers",
+  props: {
+    isFemale: {
+      type: Boolean,
+      default: false
+    },
+    homeTeam: {
+      type: Object,
+      default: () => ({})
+    },
+    awayTeam: {
+      type: Object,
+      default: () => ({})
+    },
+    availablePlayersByTeam: {
+      type: Map,
+      default: () => /* @__PURE__ */ new Map()
+    }
+  },
+  emits: ["change-players"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const teamIdSelected = ref(0);
+    watch(
+      () => props.homeTeam.team_id,
+      (newVal) => {
+        if (newVal === void 0) {
+          if (props.awayTeam && props.awayTeam.team_id) {
+            teamIdSelected.value = props.awayTeam.team_id;
+          }
+        } else {
+          teamIdSelected.value = newVal;
+        }
+      },
+      { immediate: true }
+    );
+    const availablePlayers = computed(() => {
+      return props.availablePlayersByTeam.get(teamIdSelected.value) || [];
+    });
+    const selectedPlayers = computed(() => {
+      return availablePlayers.value.reduce((acc, player) => {
+        if (player.isSelected) {
+          acc.add(player.player_id);
+        }
+        return acc;
+      }, /* @__PURE__ */ new Set());
+    });
+    watch(
+      () => selectedPlayers.value,
+      (newValue) => {
+        emit("change-players", newValue);
+      },
+      { immediate: true }
+    );
+    function onClickTeam(teamId) {
+      teamIdSelected.value = teamId;
+    }
+    function onChangePlayer(event, player) {
+      player.isSelected = event;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        createElementVNode("div", _hoisted_2$2, [
+          __props.homeTeam.team_id !== void 0 ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            role: "button",
+            class: normalizeClass(["list-players__header__team", { active: teamIdSelected.value === __props.homeTeam.team_id }]),
+            onClick: _cache[0] || (_cache[0] = ($event) => onClickTeam(__props.homeTeam.team_id))
+          }, [
+            createElementVNode("img", {
+              src: __props.homeTeam.logo,
+              alt: "team-logo"
+            }, null, 8, _hoisted_3$2),
+            createElementVNode("div", _hoisted_4$2, toDisplayString(__props.homeTeam.colloquial_name), 1)
+          ], 2)) : createCommentVNode("", true),
+          __props.awayTeam.team_id !== void 0 ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            role: "button",
+            class: normalizeClass(["list-players__header__team away", { active: teamIdSelected.value === __props.awayTeam.team_id }]),
+            onClick: _cache[1] || (_cache[1] = ($event) => onClickTeam(__props.awayTeam.team_id))
+          }, [
+            createElementVNode("img", {
+              src: __props.awayTeam.logo,
+              alt: "team-logo"
+            }, null, 8, _hoisted_5$2),
+            createElementVNode("div", _hoisted_6$2, toDisplayString(__props.awayTeam.colloquial_name), 1)
+          ], 2)) : createCommentVNode("", true)
+        ]),
+        createElementVNode("div", _hoisted_7$2, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(availablePlayers.value, (player) => {
+            return openBlock(), createBlock(ItemPlayer, {
+              key: player.player_id,
+              "is-female": __props.isFemale,
+              player,
+              "selected-players": selectedPlayers.value,
+              onChangePlayer: ($event) => onChangePlayer($event, player)
+            }, null, 8, ["is-female", "player", "selected-players", "onChangePlayer"]);
+          }), 128))
+        ])
+      ]);
+    };
+  }
+};
+const ListPlayers = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-a0fc063d"]]);
+const CategoriesList_vue_vue_type_style_index_0_scoped_86727bbf_lang = "";
+const _hoisted_1$1 = { class: "categories-list" };
+const _hoisted_2$1 = {
+  key: 0,
+  class: "categories-list__games"
+};
+const _hoisted_3$1 = {
+  key: 1,
+  class: "categories-list__header"
+};
+const _hoisted_4$1 = { class: "categories-list__switch" };
+const _hoisted_5$1 = { class: "categories-list__lists" };
+const _hoisted_6$1 = {
+  key: 0,
+  class: "categories-list__lists__events"
+};
+const _hoisted_7$1 = {
+  key: 1,
+  class: "categories-list__lists__players"
+};
+const _sfc_main$1 = {
+  __name: "CategoriesList",
+  props: {
+    isFemale: {
+      type: Boolean,
+      default: false
+    },
+    homeTeam: {
+      type: Object,
+      default: () => ({})
+    },
+    awayTeam: {
+      type: Object,
+      default: () => ({})
+    },
+    listEventsToDisplay: {
+      type: Array,
+      default: () => []
+    },
+    awaitForListEvents: {
+      type: Boolean,
+      default: false
+    },
+    tournamentSelected: {
+      type: Object,
+      default: () => ({})
+    },
+    availablePlayersByTeam: {
+      type: Map,
+      default: () => /* @__PURE__ */ new Map()
+    },
+    listType: {
+      type: String,
+      default: "events"
+    },
+    canPlayVideos: {
+      type: Boolean,
+      default: true
+    },
+    isGamePreMatch: {
+      type: Boolean,
+      default: false
+    },
+    selectedTeamData: {
+      type: Object,
+      default: () => ({})
+    },
+    rivalTeams: {
+      type: Object,
+      default: () => ({
+        isSelected: false,
+        colloquialName: "Rival"
+      })
+    },
+    teamSelected: {
+      type: Object,
+      default: () => ({ teamId: 0 })
+    },
+    totalEvents: {
+      type: Number,
+      default: 0
+    },
+    isPrivilegesVrApplicable: {
+      type: Boolean,
+      default: false
+    },
+    totalEventsPrivilegesVr: {
+      type: Number,
+      default: 0
+    }
+  },
+  emits: [
+    "change-event-type",
+    "change-list-type",
+    "change-players",
+    "change-teams",
+    "change-games"
+  ],
+  setup(__props, { emit }) {
+    const props = __props;
+    const listTypes = ref([
+      "Eventos",
+      props.tournamentSelected.is_female == 1 ? "Jugadoras" : "Jugadores"
+    ]);
+    const listTypeSelectedIndex = ref(0);
+    const lastEventTypeSelected = ref({});
+    const expansionPanelModeProps = ref({
+      isExpansionPanel: false,
+      templateProps: {
+        boxShadow: "0px 4px 4px rgba(0, 0, 0, 0)",
+        width: "100%"
+      },
+      buttonFilterProps: {
+        width: "100%",
+        "background-color": "#293640",
+        padding: "3px 8px",
+        "border-radius": "5px",
+        "border-color": "#293640",
+        "info-border-color": "#424D58"
+      },
+      fieldComponentProps: {
+        width: "100%"
+      },
+      width: "100%"
+    });
+    const currentTeamGamesSelected = ref([]);
+    const homeTeamPreMatch = ref({});
+    const awayTeamPreMatch = ref({});
+    const teamsSelectedPreMatch = ref(/* @__PURE__ */ new Set());
+    const teamsSelected = computed(() => {
+      const teamsSelectedAux = /* @__PURE__ */ new Set();
+      const teamsSelected2 = /* @__PURE__ */ new Set();
+      if (props.isGamePreMatch) {
+        if (props.selectedTeamData.isSelected) {
+          teamsSelected2.add(props.selectedTeamData.teamId);
+          teamsSelectedAux.add(1);
+        }
+        if (props.rivalTeams.isSelected) {
+          teamsSelectedAux.add(2);
+          currentTeamGamesSelected.value.forEach((game) => {
+            teamsSelected2.add(
+              game.rivalTeam.team_id === props.selectedTeamData.teamId ? game.team.team_id : game.rivalTeam.team_id
+            );
+          });
+        }
+        setTamsSelectedPreMatch(teamsSelectedAux);
+      } else {
+        if (props.homeTeam.isSelected) {
+          teamsSelected2.add(props.homeTeam.team_id);
+        }
+        if (props.awayTeam.isSelected) {
+          teamsSelected2.add(props.awayTeam.team_id);
+        }
+      }
+      return teamsSelected2;
+    });
+    const isHomeTeamTeamForAnalysis = computed(() => {
+      return props.homeTeam.team_id === props.teamSelected.teamId;
+    });
+    const isAwayTeamTeamForAnalysis = computed(() => {
+      return props.awayTeam.team_id === props.teamSelected.teamId;
+    });
+    watch(
+      () => listTypeSelectedIndex.value,
+      (newVal) => {
+        emit("change-list-type", newVal ? "players" : "events");
+      },
+      { immediate: true }
+    );
+    watch(
+      () => teamsSelected.value,
+      (newVal) => {
+        emit("change-teams", newVal);
+      },
+      { immediate: true }
+    );
+    const filterGames = computed(() => {
+      if (props.isGamePreMatch && props.selectedTeamData.games && props.selectedTeamData.games.length > 0) {
+        return props.selectedTeamData.games.map((game) => {
+          return {
+            ...game,
+            label: `${game.roundAbbreviation} ${game.team.acronym} vs ${game.rivalTeam.acronym}`,
+            teamsIds: [game.team.team_id, game.rivalTeam.team_id]
+          };
+        });
+      }
+      return [];
+    });
+    function setTamsSelectedPreMatch(teamsSelectedAux) {
+      teamsSelectedPreMatch.value = teamsSelectedAux;
+    }
+    function onChangeListType(value) {
+      listTypeSelectedIndex.value = value.index;
+    }
+    function onChangeEventType(eventType) {
+      lastEventTypeSelected.value = eventType;
+      emit("change-event-type", eventType);
+    }
+    function onChangePlayers(players) {
+      emit("change-players", players);
+    }
+    function onChangeTeam({ value, team }) {
+      team.isSelected = value;
+    }
+    function onClickPlay(categoriesIds) {
+      emit("click-play", categoriesIds);
+    }
+    function onUpdateFiltersGames(filters) {
+      const gamesIds = /* @__PURE__ */ new Set();
+      currentTeamGamesSelected.value = filters.filter((game) => {
+        if (game.isSelected) {
+          gamesIds.add(game.game_id);
+        }
+        return game.isSelected;
+      });
+      if (currentTeamGamesSelected.value.length === 1) {
+        const gameSelected = currentTeamGamesSelected.value[0];
+        homeTeamPreMatch.value = gameSelected.homeTeam;
+        awayTeamPreMatch.value = gameSelected.awayTeam;
+      } else {
+        homeTeamPreMatch.value = props.teamSelected.isHomeTeam ? props.homeTeam : {};
+        awayTeamPreMatch.value = props.teamSelected.isHomeTeam ? {} : props.awayTeam;
+        listTypeSelectedIndex.value = 0;
+      }
+      emit("change-games", {
+        gamesIds,
+        availableTeamsIds: teamsSelected.value,
+        currentTeamGamesSelected: currentTeamGamesSelected.value
+      });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        __props.isGamePreMatch ? (openBlock(), createElementBlock("div", _hoisted_2$1, [
+          createVNode(unref(GSCFilters), mergeProps(expansionPanelModeProps.value, {
+            "filter-type": unref(filtersTypes).GAMES,
+            filters: filterGames.value,
+            "onUpdate:filters": onUpdateFiltersGames
+          }), null, 16, ["filter-type", "filters"])
+        ])) : createCommentVNode("", true),
+        __props.listType === "events" ? (openBlock(), createElementBlock("div", _hoisted_3$1, [
+          createVNode(CategoriesHeaderTeam, {
+            team: __props.isGamePreMatch ? isHomeTeamTeamForAnalysis.value ? __props.selectedTeamData : __props.rivalTeams : __props.homeTeam,
+            "teams-selected": __props.isGamePreMatch ? teamsSelectedPreMatch.value : teamsSelected.value,
+            "is-game-pre-match": __props.isGamePreMatch,
+            "is-team-for-analysis": isHomeTeamTeamForAnalysis.value,
+            onChangeTeam
+          }, null, 8, ["team", "teams-selected", "is-game-pre-match", "is-team-for-analysis"]),
+          createVNode(CategoriesHeaderTeam, {
+            team: __props.isGamePreMatch ? isAwayTeamTeamForAnalysis.value ? __props.selectedTeamData : __props.rivalTeams : __props.awayTeam,
+            "is-home-team": false,
+            "is-game-pre-match": __props.isGamePreMatch,
+            "teams-selected": __props.isGamePreMatch ? teamsSelectedPreMatch.value : teamsSelected.value,
+            "is-team-for-analysis": isAwayTeamTeamForAnalysis.value,
+            onChangeTeam
+          }, null, 8, ["team", "is-game-pre-match", "teams-selected", "is-team-for-analysis"])
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_4$1, [
+          createVNode(ToggleButtons, {
+            "selected-button-index": listTypeSelectedIndex.value,
+            buttons: listTypes.value,
+            width: "220px",
+            "border-radius": "16px",
+            onChange: onChangeListType
+          }, null, 8, ["selected-button-index", "buttons"])
+        ]),
+        createElementVNode("div", _hoisted_5$1, [
+          listTypeSelectedIndex.value === 0 ? (openBlock(), createElementBlock("div", _hoisted_6$1, [
+            createVNode(ListEvents, {
+              "list-events-to-display": __props.isGamePreMatch ? __props.selectedTeamData.categories : __props.listEventsToDisplay,
+              "await-for-list-events": __props.awaitForListEvents,
+              "last-event-type-selected": lastEventTypeSelected.value,
+              "can-play-videos": __props.canPlayVideos,
+              "total-events": __props.totalEvents,
+              "total-events-privileges-vr": __props.totalEventsPrivilegesVr,
+              "is-privileges-vr-applicable": __props.isPrivilegesVrApplicable,
+              onChangeEventType,
+              onClickPlay
+            }, null, 8, ["list-events-to-display", "await-for-list-events", "last-event-type-selected", "can-play-videos", "total-events", "total-events-privileges-vr", "is-privileges-vr-applicable"])
+          ])) : (openBlock(), createElementBlock("div", _hoisted_7$1, [
+            createVNode(ListPlayers, {
+              "is-female": __props.isFemale,
+              "available-players-by-team": __props.availablePlayersByTeam,
+              "home-team": __props.isGamePreMatch ? homeTeamPreMatch.value : __props.homeTeam,
+              "away-team": __props.isGamePreMatch ? awayTeamPreMatch.value : __props.awayTeam,
+              onChangeEventType,
+              onChangePlayers
+            }, null, 8, ["is-female", "available-players-by-team", "home-team", "away-team"])
+          ]))
+        ])
+      ]);
+    };
+  }
+};
+const CategoriesList = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-86727bbf"]]);
+const chalkboardPlayValues = [
+  "playId",
+  "playerId",
+  "teamId",
+  "gameId",
+  "categoryId",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "x3",
+  "y3",
+  "momentOfPlay",
+  "relatedPlayId",
+  "order",
+  "nationalityId",
+  "jersey"
+];
+let chalkboardPlayIndex = null;
+function getChalkboardPlayIndexes() {
+  if (!chalkboardPlayIndex) {
+    chalkboardPlayIndex = getPlayValueIndexesFromArray(chalkboardPlayValues);
+  }
+  return chalkboardPlayIndex;
+}
+const rivalCategoryIds = /* @__PURE__ */ new Set([35, 54]);
+const rivalCategoryIdsR = /* @__PURE__ */ new Set(["35_r", "54_r"]);
+const teamColors = {
+  homeTeam: "#336dff",
+  awayTeam: "#7ed321"
+};
+const teamFontColors = {
+  homeTeam: "#fff",
+  awayTeam: "#000"
+};
+class EventsConnection {
+  constructor(mainPlay = {}, events = [], categoriesIds = /* @__PURE__ */ new Set(), playersIds = /* @__PURE__ */ new Set(), game = null, teamForAnalysis = null) {
+    const isRivalCategory = rivalCategoryIds.has(mainPlay.categoryId);
+    this.mainPlay = mainPlay;
+    this.playEvents = events.sort((a, b) => b.order - a.order);
+    this.categoriesIds = categoriesIds;
+    this.playersIds = playersIds;
+    this.teamForAnalysis = teamForAnalysis;
+    this.mainCategoryId = isRivalCategory ? `${mainPlay.categoryId}_r` : mainPlay.categoryId || 0;
+    this.mainPlay.isMainPlay = true;
+    this.playEvents.forEach((event) => {
+      event.game = game;
+    });
+  }
+  setEventType(eventType) {
+    this.eventType = eventType;
+    this.mainPlay.categoryName = eventType.singleName;
+    this.playEvents.forEach((event) => {
+      event.hasConnectionPath = this.eventType.prev !== 0 || this.eventType.post !== 0;
+    });
+  }
+  getEventsConnectionsByEventType() {
+    const mainEventIndex = this.playEvents.findIndex((event) => {
+      return event.playId === this.mainPlay.playId;
+    });
+    if (mainEventIndex > -1 && this.eventType) {
+      let minEventIndex = mainEventIndex - this.eventType.post;
+      let maxEventIndex = mainEventIndex + this.eventType.prev;
+      if (minEventIndex < 0) {
+        minEventIndex = 0;
+      }
+      if (maxEventIndex > this.playEvents.length - 1) {
+        maxEventIndex = this.playEvents.length - 1;
+      }
+      const eventsConnectionsByEventType = this.playEvents.slice(minEventIndex, maxEventIndex + 1).reverse();
+      eventsConnectionsByEventType.forEach((eventConnection, index) => {
+        if (index > 0) {
+          eventConnection.previousEvent = eventsConnectionsByEventType[index - 1];
+        }
+      });
+      return eventsConnectionsByEventType;
+    }
+    return [];
+  }
+  hasMainCategory(categoriesIds = /* @__PURE__ */ new Set()) {
+    return categoriesIds.has(this.mainCategoryId);
+  }
+  hasCategories(categoriesIds = /* @__PURE__ */ new Set(), teams = { homeTeamId: 0, awayTeamId: 0 }) {
+    const teamsIndex = [];
+    categoriesIds.forEach((categoryId) => {
+      teamsIndex.push(`${teams.homeTeamId}-${categoryId}`);
+      teamsIndex.push(`${teams.awayTeamId}-${categoryId}`);
+    });
+    return teamsIndex.some((categoryId) => this.teamEventsIndex.has(categoryId));
+  }
+  hasPlayer(playersIds = /* @__PURE__ */ new Set()) {
+    return playersIds.has(this.mainPlay.playerId);
+  }
+  hasPlayers(playersIds = /* @__PURE__ */ new Set()) {
+    return Array.from(playersIds.values()).some((playerId) => this.playersIds.has(playerId));
+  }
+  hasTeam(teamIds = /* @__PURE__ */ new Set()) {
+    return teamIds.has(this.mainPlay.teamId);
+  }
+  getTeamColor() {
+    let isHomeTeamAux = this.teamForAnalysis ? this.teamForAnalysis.isHomeTeam ? this.mainPlay.teamId === this.teamForAnalysis.teamId : this.mainPlay.teamId !== this.teamForAnalysis.teamId : this.mainPlay.team.isHomeTeam;
+    if (rivalCategoryIdsR.has(this.mainPlay.categoryId)) {
+      isHomeTeamAux = !isHomeTeamAux;
+    }
+    return isHomeTeamAux ? teamColors.homeTeam : teamColors.awayTeam;
+  }
+  getEventColor(event) {
+    let isHomeTeamAux = this.teamForAnalysis ? this.teamForAnalysis.isHomeTeam ? event.teamId === this.teamForAnalysis.teamId : event.teamId !== this.teamForAnalysis.teamId : event.team.isHomeTeam;
+    return isHomeTeamAux ? teamColors.homeTeam : teamColors.awayTeam;
+  }
+  getTeamFontColor() {
+    let isHomeTeamAux = this.teamForAnalysis ? this.teamForAnalysis.isHomeTeam ? this.mainPlay.teamId === this.teamForAnalysis.teamId : this.mainPlay.teamId !== this.teamForAnalysis.teamId : this.mainPlay.team.isHomeTeam;
+    if (rivalCategoryIdsR.has(this.mainPlay.categoryId)) {
+      isHomeTeamAux = !isHomeTeamAux;
+    }
+    return isHomeTeamAux ? teamFontColors.homeTeam : teamFontColors.awayTeam;
+  }
+  getSingleName(categoryName) {
+    const categoryNameArray = categoryName.split(" ");
+    return categoryNameArray.reduce((accumulator, word) => {
+      let wordAux = word;
+      if (word.endsWith("minaron")) {
+        wordAux = word.replace("minaron", "minó");
+      } else if (word.endsWith("vocan")) {
+        wordAux = word.replace("vocan", "voca");
+      } else if (word.endsWith("lones")) {
+        wordAux = word.replace("lones", "lón");
+      } else if (word.endsWith("oles")) {
+        wordAux = word.replace("oles", "ol");
+      } else if (word.endsWith("os") || word.endsWith("as") || word.endsWith("es")) {
+        wordAux = word.slice(0, word.length - 1);
+      }
+      accumulator.push(wordAux);
+      return accumulator;
+    }, []).join(" ");
+  }
+}
+const cupType0 = /* @__PURE__ */ new Map([
+  [
+    1,
+    {
+      matchDayId: 1,
+      matchDayName: "Jornada 1",
+      matchDayAbbreviation: "J1",
+      matchDayAbbreviation2: "JOR 1"
+    }
+  ],
+  [
+    2,
+    {
+      matchDayId: 2,
+      matchDayName: "Jornada 2",
+      matchDayAbbreviation: "J2",
+      matchDayAbbreviation2: "JOR 2"
+    }
+  ],
+  [
+    3,
+    {
+      matchDayId: 3,
+      matchDayName: "Jornada 3",
+      matchDayAbbreviation: "J3",
+      matchDayAbbreviation2: "JOR 3"
+    }
+  ],
+  [
+    4,
+    {
+      matchDayId: 4,
+      matchDayName: "Jornada 4",
+      matchDayAbbreviation: "J4",
+      matchDayAbbreviation2: "JOR 4"
+    }
+  ],
+  [
+    5,
+    {
+      matchDayId: 5,
+      matchDayName: "Jornada 5",
+      matchDayAbbreviation: "J5",
+      matchDayAbbreviation2: "JOR 5"
+    }
+  ],
+  [
+    6,
+    {
+      matchDayId: 6,
+      matchDayName: "Jornada 6",
+      matchDayAbbreviation: "J6",
+      matchDayAbbreviation2: "JOR 6"
+    }
+  ],
+  [
+    7,
+    {
+      matchDayId: 7,
+      matchDayName: "Jornada 7",
+      matchDayAbbreviation: "J7",
+      matchDayAbbreviation2: "JOR 7"
+    }
+  ],
+  [
+    8,
+    {
+      matchDayId: 8,
+      matchDayName: "Jornada 8",
+      matchDayAbbreviation: "J8",
+      matchDayAbbreviation2: "JOR 8"
+    }
+  ],
+  [
+    9,
+    {
+      matchDayId: 9,
+      matchDayName: "Jornada 9",
+      matchDayAbbreviation: "J9",
+      matchDayAbbreviation2: "JOR 9"
+    }
+  ],
+  [
+    10,
+    {
+      matchDayId: 10,
+      matchDayName: "Jornada 10",
+      matchDayAbbreviation: "J10",
+      matchDayAbbreviation2: "JOR 10"
+    }
+  ],
+  [
+    11,
+    {
+      matchDayId: 11,
+      matchDayName: "Jornada 11",
+      matchDayAbbreviation: "J11",
+      matchDayAbbreviation2: "JOR 11"
+    }
+  ],
+  [
+    12,
+    {
+      matchDayId: 12,
+      matchDayName: "Jornada 12",
+      matchDayAbbreviation: "J12",
+      matchDayAbbreviation2: "JOR 12"
+    }
+  ],
+  [
+    13,
+    {
+      matchDayId: 13,
+      matchDayName: "Jornada 13",
+      matchDayAbbreviation: "J13",
+      matchDayAbbreviation2: "JOR 13"
+    }
+  ],
+  [
+    14,
+    {
+      matchDayId: 14,
+      matchDayName: "Jornada 14",
+      matchDayAbbreviation: "J14",
+      matchDayAbbreviation2: "JOR 14"
+    }
+  ],
+  [
+    15,
+    {
+      matchDayId: 15,
+      matchDayName: "Jornada 15",
+      matchDayAbbreviation: "J15",
+      matchDayAbbreviation2: "JOR 15"
+    }
+  ],
+  [
+    16,
+    {
+      matchDayId: 16,
+      matchDayName: "Jornada 16",
+      matchDayAbbreviation: "J16",
+      matchDayAbbreviation2: "JOR 16"
+    }
+  ],
+  [
+    17,
+    {
+      matchDayId: 17,
+      matchDayName: "Jornada 17",
+      matchDayAbbreviation: "J17",
+      matchDayAbbreviation2: "JOR 17"
+    }
+  ],
+  [
+    18,
+    {
+      matchDayId: 18,
+      matchDayName: "Cuartos de Final Ida",
+      matchDayAbbreviation: "CFI",
+      matchDayAbbreviation2: "CFI"
+    }
+  ],
+  [
+    19,
+    {
+      matchDayId: 19,
+      matchDayName: "Cuartos de Final Vuelta",
+      matchDayAbbreviation: "CFV",
+      matchDayAbbreviation2: "CFV"
+    }
+  ],
+  [
+    20,
+    {
+      matchDayId: 20,
+      matchDayName: "Semifinal Ida",
+      matchDayAbbreviation: "SFI",
+      matchDayAbbreviation2: "SFI"
+    }
+  ],
+  [
+    21,
+    {
+      matchDayId: 21,
+      matchDayName: "Semifinal Vuelta",
+      matchDayAbbreviation: "SFV",
+      matchDayAbbreviation2: "SFV"
+    }
+  ],
+  [
+    22,
+    {
+      matchDayId: 22,
+      matchDayName: "Final Ida",
+      matchDayAbbreviation: "FI",
+      matchDayAbbreviation2: "FI"
+    }
+  ],
+  [
+    86,
+    {
+      matchDayId: 86,
+      matchDayName: "Final Vuelta",
+      matchDayAbbreviation: "FV",
+      matchDayAbbreviation2: "FV"
+    }
+  ],
+  [
+    182,
+    {
+      matchDayId: 182,
+      matchDayName: "Play In 1",
+      matchDayAbbreviation: "PI1",
+      matchDayAbbreviation2: "PI1"
+    }
+  ],
+  [
+    183,
+    {
+      matchDayId: 183,
+      matchDayName: "Play In 2",
+      matchDayAbbreviation: "PI2",
+      matchDayAbbreviation2: "PI2"
+    }
+  ],
+  [
+    184,
+    {
+      matchDayId: 184,
+      matchDayName: "Repechaje",
+      matchDayAbbreviation: "R",
+      matchDayAbbreviation2: "R"
+    }
+  ]
+]);
+const cupType1ById = /* @__PURE__ */ new Map([
+  [1, { matchDayId: 1, matchDayName: "Jornada 1", matchDayAbbreviation: "J1" }],
+  [2, { matchDayId: 2, matchDayName: "Jornada 2", matchDayAbbreviation: "J2" }],
+  [3, { matchDayId: 3, matchDayName: "Jornada 3", matchDayAbbreviation: "J3" }],
+  [4, { matchDayId: 4, matchDayName: "Jornada 4", matchDayAbbreviation: "J4" }],
+  [5, { matchDayId: 5, matchDayName: "Jornada 5", matchDayAbbreviation: "J5" }],
+  [6, { matchDayId: 6, matchDayName: "Jornada 6", matchDayAbbreviation: "J6" }],
+  [181, { matchDayId: 181, matchDayName: "16vos de Final", matchDayAbbreviation: "DF" }],
+  [176, { matchDayId: 176, matchDayName: "Octavos de Final", matchDayAbbreviation: "OF" }],
+  [177, { matchDayId: 177, matchDayName: "Cuartos de Final", matchDayAbbreviation: "CF" }],
+  [178, { matchDayId: 178, matchDayName: "Semifinales", matchDayAbbreviation: "SF" }],
+  [179, { matchDayId: 179, matchDayName: "Tercer lugar", matchDayAbbreviation: "3ER" }],
+  [180, { matchDayId: 180, matchDayName: "Final", matchDayAbbreviation: "FINAL" }]
+]);
+const cupType2ById = /* @__PURE__ */ new Map([
+  [1, { matchDayId: 1, matchDayName: "16vos de Final Ida", matchDayAbbreviation: "DFI" }],
+  [2, { matchDayId: 2, matchDayName: "16vos de Final Vuelta", matchDayAbbreviation: "DFV" }],
+  [3, { matchDayId: 3, matchDayName: "Octavos de Final Ida", matchDayAbbreviation: "OFI" }],
+  [4, { matchDayId: 4, matchDayName: "Octavos de Final Vuelta", matchDayAbbreviation: "OFV" }],
+  [5, { matchDayId: 5, matchDayName: "Cuartos de Final Ida", matchDayAbbreviation: "CFI" }],
+  [6, { matchDayId: 6, matchDayName: "Cuartos de Final Vuelta", matchDayAbbreviation: "CFV" }],
+  [7, { matchDayId: 7, matchDayName: "Semifinales Ida", matchDayAbbreviation: "SFI" }],
+  [8, { matchDayId: 8, matchDayName: "Semifinales Vuelta", matchDayAbbreviation: "SFV" }],
+  [10, { matchDayId: 10, matchDayName: "Final", matchDayAbbreviation: "FINAL" }]
+]);
+const namesAndAbbByTournamentTypeAndMatchDayId = /* @__PURE__ */ new Map([
+  [0, cupType0],
+  [1, cupType1ById],
+  [2, cupType2ById]
+]);
+const ChalkboardSectionContainer_vue_vue_type_style_index_0_scoped_96de1508_lang = "";
+const _withScopeId = (n) => (pushScopeId("data-v-96de1508"), n = n(), popScopeId(), n);
+const _hoisted_1 = { class: "chalkboard-section-container" };
+const _hoisted_2 = {
+  key: 0,
+  class: "chalkboard-section-container__pre-match-header"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "container-info-text-pre-match"
+};
+const _hoisted_4 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("span", { class: "info-text-bold" }, "IMPORTANTE:", -1));
+const _hoisted_5 = {
+  key: 1,
+  class: "container-info-text-pre-match-mobile"
+};
+const _hoisted_6 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("span", { class: "info-text-bold" }, "IMPORTANTE:", -1));
+const _hoisted_7 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("br", null, null, -1));
+const _hoisted_8 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("br", null, null, -1));
+const _hoisted_9 = {
+  key: 2,
+  class: "container-info-text-pre-match-mobile"
+};
+const _hoisted_10 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("span", { class: "info-text-bold" }, "IMPORTANTE:", -1));
+const _hoisted_11 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("br", null, null, -1));
+const _hoisted_12 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("br", null, null, -1));
+const _hoisted_13 = { class: "section-container" };
+const _hoisted_14 = { class: "section-container__left-column" };
+const _hoisted_15 = { class: "chalkboard-component" };
+const _hoisted_16 = { class: "assistant-zones" };
+const _hoisted_17 = { class: "categories-time-line-component" };
+const _hoisted_18 = { class: "total-events" };
+const _hoisted_19 = { class: "section-container__right-column" };
+const _sfc_main = {
+  __name: "ChalkboardSectionContainer",
+  props: {
+    isFemale: {
+      type: Boolean,
+      default: false
+    },
+    game: {
+      type: Object,
+      default: () => ({})
+    },
+    seasonSelected: {
+      type: Object,
+      default: () => ({})
+    },
+    tournamentSelected: {
+      type: Object,
+      default: () => ({})
+    },
+    token: {
+      type: String,
+      default: ""
+    },
+    canPlayVideos: {
+      type: Boolean,
+      default: true
+    },
+    widthSection: {
+      type: Number,
+      default: 0
+    },
+    isGamePreMatch: {
+      type: Boolean,
+      default: false
+    },
+    playVideosPrivileges: {
+      type: Object,
+      default: null
+    },
+    chalkboardIntervalMinutes: {
+      type: Number,
+      default: 2
+    }
+  },
+  emits: ["open-media-player"],
+  setup(__props, { emit }) {
+    const props = __props;
+    let eventsInterval = null;
+    const chalkboardPlayIndexes = getChalkboardPlayIndexes();
+    const teamSelected = ref({ teamId: 0 });
+    const teamButtonSelectedIndex = ref(0);
+    const homeTeam = ref({});
+    const awayTeam = ref({});
+    const eventsList = ref([]);
+    const eventTypeSelected = ref({ value: "" });
+    const eventsConnectionsToShow = ref([]);
+    const eventsConnectionsBase = ref([]);
+    const availablePlayersByTeamMap = ref(/* @__PURE__ */ new Map());
+    const playersMap = ref(/* @__PURE__ */ new Map());
+    const currentListType = ref("events");
+    const playersSelected = ref(/* @__PURE__ */ new Set());
+    const teamsSelected = ref(/* @__PURE__ */ new Set());
+    const currentTeamGamesSelected = ref([]);
+    const chalkboardDataPreMatchByTeam = /* @__PURE__ */ new Map();
+    const selectedTeamData = ref({});
+    const rivalTeams = ref({
+      isSelected: true,
+      colloquialName: "Rival"
+    });
+    const selectedGamesIds = ref(/* @__PURE__ */ new Set());
+    const selectedGamesIdsPrivilegesVR = ref(/* @__PURE__ */ new Set());
+    const gameTotalEventsIds = ref(/* @__PURE__ */ new Set());
+    const lastGameFilledId = ref(0);
+    const playsIdsUsed = /* @__PURE__ */ new Set();
+    const isAssistantZoneVisible = ref(false);
+    const toggleButtonsValues = computed(() => {
+      return [
+        {
+          teamId: props.game.homeTeam.team_id,
+          text: props.game.homeTeam.colloquial_name,
+          img: props.game.homeTeam.logo,
+          isHomeTeam: true
+        },
+        {
+          teamId: props.game.awayTeam.team_id,
+          text: props.game.awayTeam.colloquial_name,
+          img: props.game.awayTeam.logo,
+          isHomeTeam: false
+        }
+      ];
+    });
+    const totalCurrentEvents = computed(() => {
+      return eventsConnectionsToShow.value.reduce((acc, eventsConnection) => {
+        if (currentListType.value === "events" && teamsSelected.value.has(eventsConnection.mainPlay.teamId) || currentListType.value === "players" && playersSelected.value.has(eventsConnection.mainPlay.playerId)) {
+          acc++;
+        }
+        return acc;
+      }, 0);
+    });
+    const isPrivilegesVRApplicable = computed(() => {
+      return props.isGamePreMatch && props.playVideosPrivileges;
+    });
+    const totalCurrentEventsPrivilegesVR = computed(() => {
+      if (isPrivilegesVRApplicable.value) {
+        return eventsConnectionsToShow.value.reduce((acc, eventsConnection) => {
+          if ((currentListType.value === "events" && teamsSelected.value.has(eventsConnection.mainPlay.teamId) || currentListType.value === "players" && playersSelected.value.has(eventsConnection.mainPlay.playerId)) && selectedGamesIdsPrivilegesVR.value.has(eventsConnection.mainPlay.gameId)) {
+            acc++;
+          }
+          return acc;
+        }, 0);
+      }
+      return 0;
+    });
+    const totalEvents = computed(() => {
+      return `${eventTypeSelected.value.name}: ${totalCurrentEvents.value}`;
+    });
+    const canPlayVideosChalkboard = computed(() => {
+      if (props.isGamePreMatch) {
+        return props.playVideosPrivileges ? getCanPlayVideosPreMatch() : props.canPlayVideos;
+      } else {
+        return props.playVideosPrivileges ? props.canPlayVideos && teamsSelected.value.has(props.playVideosPrivileges.seasonAndPrivileges.teamId) : props.canPlayVideos;
+      }
+    });
+    watch(
+      () => teamSelected.value.teamId,
+      (newVal) => {
+        if (props.isGamePreMatch && newVal) {
+          if (selectedTeamData.value && !selectedTeamData.value.isSelected) {
+            selectedTeamData.value.isSelected = true;
+          }
+          rivalTeams.value.isSelected = true;
+          selectedTeamData.value = chalkboardDataPreMatchByTeam.get(newVal);
+          const gamesSelectedIdsSet = /* @__PURE__ */ new Set();
+          const availableTeamsIdsSet = /* @__PURE__ */ new Set();
+          if (selectedTeamData.value) {
+            selectedTeamData.value.games.forEach((game) => {
+              if (game.isSelected) {
+                gamesSelectedIdsSet.add(game.id);
+                availableTeamsIdsSet.add(game.team.team_id);
+                availableTeamsIdsSet.add(game.rivalTeam.team_id);
+              }
+            });
+            onChangeGames({ gamesIds: gamesSelectedIdsSet, availableTeamsIds: availableTeamsIdsSet });
+          }
+        }
+      },
+      { immediate: true }
+    );
+    watch(
+      () => props.game.gameId,
+      (newVal) => {
+        if (newVal) {
+          homeTeam.value = { ...props.game.homeTeam, isSelected: true };
+          awayTeam.value = { ...props.game.awayTeam, isSelected: true };
+          gameTotalEventsIds.value = /* @__PURE__ */ new Set();
+          deleteInterval();
+          if (props.game.game_status === 4 && !props.game.is_live) {
+            fillPlaysPreMatch();
+          } else {
+            fillPlays(newVal, props.game.is_live && props.game.game_status === 4);
+          }
+        }
+      },
+      { immediate: true }
+    );
+    watch(
+      () => toggleButtonsValues.value,
+      () => {
+        teamButtonSelectedIndex.value = 0;
+        teamSelected.value = toggleButtonsValues.value[teamButtonSelectedIndex.value];
+      },
+      { immediate: true, deep: true }
+    );
+    watch(
+      () => eventTypeSelected.value.value,
+      () => {
+        if (props.isGamePreMatch) {
+          fillEventsConnectionsToShowPreMatch();
+        } else {
+          availablePlayersByTeamMap.value = /* @__PURE__ */ new Map([
+            [props.game.homeTeam.team_id, []],
+            [props.game.awayTeam.team_id, []]
+          ]);
+          if (eventTypeSelected.value.name) {
+            fillEventsConnectionsToShow(eventsConnectionsBase.value);
+          }
+        }
+      },
+      { immediate: true, deep: true }
+    );
+    function getCanPlayVideosPreMatch() {
+      if (currentTeamGamesSelected.value) {
+        if (teamSelected.value && props.playVideosPrivileges && props.playVideosPrivileges.seasonAndPrivileges && teamSelected.value.teamId === props.playVideosPrivileges.seasonAndPrivileges.teamId) {
+          const validGamesCount = currentTeamGamesSelected.value.reduce((acc, game) => {
+            if (game.home_team === teamSelected.value.teamId || game.visiting_team === teamSelected.value.teamId) {
+              const playingAs = game.home_team === teamSelected.value.teamId ? 1 : 2;
+              if (props.playVideosPrivileges.seasonAndPrivileges.playingAs.has(playingAs)) {
+                acc++;
+              }
+            }
+            return acc;
+          }, 0);
+          return validGamesCount > 0 && teamsSelected.value.has(teamSelected.value.teamId);
+        }
+      }
+      return false;
+    }
+    function createInterval() {
+      eventsInterval = setInterval(
+        () => {
+          fillPlays(props.game.gameId);
+        },
+        1e3 * 60 * props.chalkboardIntervalMinutes
+      );
+    }
+    function fillEventsConnectionsToShow(eventsConnections) {
+      const availablePlayersIds = /* @__PURE__ */ new Set();
+      eventsConnectionsToShow.value = [];
+      eventsConnections.forEach((eventsConnection) => {
+        if (eventsConnection.hasMainCategory(eventTypeSelected.value.categories)) {
+          eventsConnection.setEventType(eventTypeSelected.value);
+          eventsConnectionsToShow.value.push(eventsConnection);
+          availablePlayersIds.add(eventsConnection.mainPlay.playerId);
+        }
+      });
+      availablePlayersIds.forEach((playerId) => {
+        const player = playersMap.value.get(playerId);
+        if (player) {
+          const teamPlayers = availablePlayersByTeamMap.value.get(player.team_id);
+          const playerExists = teamPlayers.find(
+            (teamPlayer) => teamPlayer.player_id === player.player_id
+          );
+          if (!playerExists) {
+            teamPlayers.push({ ...player, isSelected: true });
+          }
+        }
+      });
+    }
+    function deleteInterval() {
+      if (eventsInterval) {
+        clearInterval(eventsInterval);
+        eventsInterval = null;
+      }
+    }
+    function getPreMatchTeamData({
+      isHomeTeam,
+      acronym,
+      team_id,
+      team_name,
+      colloquial_name,
+      logo,
+      categories,
+      data,
+      games,
+      players,
+      teams
+    }) {
+      const preMatchTeamData = {
+        logo,
+        acronym,
+        categories,
+        teamId: team_id,
+        name: team_name,
+        colloquialName: colloquial_name,
+        isSelected: true,
+        availablePlayersMap: /* @__PURE__ */ new Map()
+      };
+      const matchDayAbbreviations = namesAndAbbByTournamentTypeAndMatchDayId.get(
+        props.tournamentSelected.tournament_type
+      );
+      const availableTeamsMap = Object.values(teams).reduce((acc, team) => {
+        acc.set(team.team_id, { ...team, colloquial_name: team.colloquial_name || team.team_name });
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      const playersByTeamMap = Object.values(players).reduce((acc, player) => {
+        preMatchTeamData.availablePlayersMap.set(player.player_id, { ...player });
+        const teamPlayers = acc.get(player.team_id);
+        if (teamPlayers) {
+          teamPlayers.set(player.player_id, { ...player });
+        } else {
+          acc.set(player.team_id, /* @__PURE__ */ new Map([[player.player_id, { ...player }]]));
+        }
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      const preMatchDataGamesMap = games.reduce((acc, game, index) => {
+        const matchDayData = matchDayAbbreviations.get(game.matchday_id);
+        const gameData = {
+          ...game,
+          dateTimeMillis: new Date(game.date_time_utc).getTime(),
+          id: game.game_id,
+          roundAbbreviation: matchDayData ? matchDayData.matchDayAbbreviation : "",
+          playingAs: teamSelected.value.id === game.home_team ? 1 : 2,
+          team: teamSelected.value.teamId === game.home_team ? availableTeamsMap.get(game.home_team) : availableTeamsMap.get(game.visiting_team),
+          rivalTeam: teamSelected.value.teamId === game.home_team ? availableTeamsMap.get(game.visiting_team) : availableTeamsMap.get(game.home_team),
+          homeTeam: availableTeamsMap.get(game.home_team),
+          awayTeam: availableTeamsMap.get(game.visiting_team),
+          playersSelected: /* @__PURE__ */ new Set(),
+          eventsConnectionsBase: [],
+          availablePlayersByTeamMap: /* @__PURE__ */ new Map([
+            [game.home_team, playersByTeamMap.get(game.home_team)],
+            [game.visiting_team, playersByTeamMap.get(game.visiting_team)]
+          ]),
+          availableTeamsByTeamMapSimple: /* @__PURE__ */ new Map([
+            [game.home_team, Array.from(playersByTeamMap.get(game.home_team).values())],
+            [game.visiting_team, Array.from(playersByTeamMap.get(game.visiting_team).values())]
+          ]),
+          teamsMap: /* @__PURE__ */ new Map([
+            [game.home_team, availableTeamsMap.get(game.home_team)],
+            [game.visiting_team, availableTeamsMap.get(game.visiting_team)]
+          ]),
+          isSelected: index < 4
+        };
+        acc.set(game.game_id, gameData);
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      const teamsForAnalysisMap = /* @__PURE__ */ new Map([
+        [toggleButtonsValues.value[0].teamId, toggleButtonsValues.value[0]],
+        [toggleButtonsValues.value[1].teamId, toggleButtonsValues.value[1]]
+      ]);
+      const allRelatedPlaysByGame = getAllRelatedPlaysByGame(data, preMatchDataGamesMap, isHomeTeam);
+      preMatchTeamData.games = Array.from(preMatchDataGamesMap.values()).map((gameData) => {
+        const eventsConnectionsBaseByGame = [];
+        const relatedPlaysByGame = allRelatedPlaysByGame.get(gameData.id);
+        if (relatedPlaysByGame) {
+          Array.from(relatedPlaysByGame.values()).forEach((relatedPlay) => {
+            if (relatedPlay.mainPlay) {
+              relatedPlay.mainPlay.gameAux = {
+                homeTeam: gameData.homeTeam,
+                awayTeam: gameData.awayTeam
+              };
+              eventsConnectionsBaseByGame.push(
+                new EventsConnection(
+                  relatedPlay.mainPlay,
+                  relatedPlay.events,
+                  relatedPlay.categoriesIds,
+                  relatedPlay.playersIds,
+                  {
+                    homeTeam: gameData.homeTeam,
+                    awayTeam: gameData.awayTeam,
+                    roundAbbreviation: gameData.roundAbbreviation
+                  },
+                  teamsForAnalysisMap.get(team_id)
+                )
+              );
+            }
+          });
+        }
+        return {
+          ...gameData,
+          eventsConnectionsBase: eventsConnectionsBaseByGame
+        };
+      });
+      return preMatchTeamData;
+    }
+    async function fillPlaysPreMatch() {
+      try {
+        const preMatchGameTeamsData = await fetchPlaysDataPreMatch();
+        preMatchGameTeamsData.forEach((teamData, index) => {
+          if (index === 0) {
+            teamData.isHomeTeam = true;
+          }
+          chalkboardDataPreMatchByTeam.set(teamData.team_id, getPreMatchTeamData(teamData));
+        });
+        if (selectedTeamData.value && !selectedTeamData.value.isSelected) {
+          selectedTeamData.value.isSelected = true;
+        }
+        rivalTeams.value.isSelected = true;
+        selectedTeamData.value = chalkboardDataPreMatchByTeam.get(teamSelected.value.teamId);
+      } catch (e) {
+        throw new Error(e);
+      }
+    }
+    async function fillPlays(gameId, createIntervalFunc = false) {
+      try {
+        const isSameGame = gameId === lastGameFilledId.value;
+        const { categories, data, players, teams } = await fetchPlaysData(gameId);
+        let dataAux = data;
+        const newEventsConnections = [];
+        if (!isSameGame.value) {
+          eventsList.value = categories;
+          lastGameFilledId.value = gameId;
+          eventsConnectionsBase.value = [];
+          playsIdsUsed.clear();
+        }
+        dataAux = data.filter((play) => {
+          const playId = `${play[chalkboardPlayIndexes.relatedPlayId]}-${play[chalkboardPlayIndexes.playId]}`;
+          const isPlayUsed = playsIdsUsed.has(playId);
+          if (!isPlayUsed) {
+            playsIdsUsed.add(playId);
+          }
+          return !isPlayUsed;
+        });
+        playersMap.value = Object.values(players).reduce((acc, player) => {
+          acc.set(player.player_id, { ...player });
+          return acc;
+        }, /* @__PURE__ */ new Map());
+        const teamsMap = Object.values(teams).reduce((acc, team) => {
+          acc.set(team.team_id, { ...team, isHomeTeam: props.game.homeTeam.team_id === team.team_id });
+          return acc;
+        }, /* @__PURE__ */ new Map());
+        const relatedPlays = getAllRelatedPlays(dataAux, playersMap.value, teamsMap);
+        Array.from(relatedPlays.values()).forEach((relatedPlay) => {
+          if (relatedPlay.mainPlay) {
+            relatedPlay.mainPlay.gameAux = {
+              homeTeam: teamsMap.get(props.game.homeTeam.team_id),
+              awayTeam: teamsMap.get(props.game.awayTeam.team_id)
+            };
+            const EventsConnectionObj = new EventsConnection(
+              relatedPlay.mainPlay,
+              relatedPlay.events,
+              relatedPlay.categoriesIds,
+              relatedPlay.playersIds
+            );
+            eventsConnectionsBase.value.push(EventsConnectionObj);
+            newEventsConnections.push(EventsConnectionObj);
+          }
+        });
+        if (newEventsConnections.length) {
+          fillEventsConnectionsToShow(newEventsConnections);
+        }
+        if (createIntervalFunc) {
+          createInterval();
+        }
+      } catch (e) {
+        throw new Error(e);
+      }
+    }
+    function getPlayObject(play) {
+      return play.reduce((acc, value, index) => {
+        acc[chalkboardPlayValues[index]] = value;
+        return acc;
+      }, {});
+    }
+    function getAllRelatedPlaysByGame(plays, dataGamesMap, isHomeTeam) {
+      const relatedPlaysAux = plays.reduce((acc, play) => {
+        const playObject = getPlayObject(play);
+        const gameData = dataGamesMap.get(playObject.gameId);
+        if (gameData) {
+          const isMainPlay = playObject.relatedPlayId === playObject.playId;
+          const relatedPlaysByGameId = acc.get(playObject.gameId);
+          const playersByTeam = gameData.availablePlayersByTeamMap.get(playObject.teamId);
+          if (!isHomeTeam) {
+            playObject.x1 = 1 - playObject.x1;
+            playObject.x2 = 1 - playObject.x2;
+            playObject.x3 = 1 - playObject.x3;
+            playObject.y1 = 1 - playObject.y1;
+            playObject.y2 = 1 - playObject.y2;
+            playObject.y3 = 1 - playObject.y3;
+          }
+          playObject.player = playersByTeam ? playersByTeam.get(playObject.playerId) : {};
+          playObject.team = gameData.teamsMap.get(playObject.teamId) || {};
+          if (relatedPlaysByGameId) {
+            const relatedPlaysByPlayId = relatedPlaysByGameId.get(playObject.relatedPlayId);
+            if (relatedPlaysByPlayId) {
+              if (isMainPlay) {
+                relatedPlaysByPlayId.mainPlay = playObject;
+              }
+              if (!relatedPlaysByPlayId.playsIds.has(playObject.playId)) {
+                relatedPlaysByPlayId.events.push(playObject);
+                relatedPlaysByPlayId.categoriesIds.add(playObject.categoryId);
+                relatedPlaysByPlayId.playersIds.add(playObject.playerId);
+                relatedPlaysByPlayId.playsIds.add(playObject.playId);
+                relatedPlaysByPlayId.players.push(playObject.player);
+              }
+            } else {
+              const relatedPlays = {
+                events: [playObject],
+                categoriesIds: /* @__PURE__ */ new Set([playObject.categoryId]),
+                playersIds: /* @__PURE__ */ new Set([playObject.playerId]),
+                playsIds: /* @__PURE__ */ new Set([playObject.playId]),
+                players: [playObject.player]
+              };
+              if (isMainPlay) {
+                relatedPlays.mainPlay = playObject;
+              }
+              relatedPlaysByGameId.set(playObject.relatedPlayId, relatedPlays);
+            }
+          } else {
+            const relatedPlaysByPlayId = /* @__PURE__ */ new Map();
+            const relatedPlaysByPlayIdAux = {
+              events: [playObject],
+              categoriesIds: /* @__PURE__ */ new Set([playObject.categoryId]),
+              playersIds: /* @__PURE__ */ new Set([playObject.playerId]),
+              playsIds: /* @__PURE__ */ new Set([playObject.playId]),
+              players: [playObject.player]
+            };
+            if (isMainPlay) {
+              relatedPlaysByPlayIdAux.mainPlay = playObject;
+            }
+            relatedPlaysByPlayId.set(playObject.relatedPlayId, relatedPlaysByPlayIdAux);
+            acc.set(playObject.gameId, relatedPlaysByPlayId);
+          }
+        }
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      return relatedPlaysAux;
+    }
+    function getAllRelatedPlays(plays, playersMap2, teamsMap) {
+      const relatedPlaysAux = plays.reduce((acc, play) => {
+        const playObject = getPlayObject(play);
+        const relatedPlaysByPlayId = acc.get(playObject.relatedPlayId);
+        const isMainPlay = playObject.relatedPlayId === playObject.playId;
+        playObject.player = playersMap2.get(playObject.playerId);
+        playObject.team = teamsMap.get(playObject.teamId);
+        if (relatedPlaysByPlayId) {
+          if (isMainPlay) {
+            relatedPlaysByPlayId.mainPlay = playObject;
+          }
+          if (!relatedPlaysByPlayId.playsIds.has(playObject.playId)) {
+            relatedPlaysByPlayId.events.push(playObject);
+            relatedPlaysByPlayId.categoriesIds.add(playObject.categoryId);
+            relatedPlaysByPlayId.playersIds.add(playObject.playerId);
+            relatedPlaysByPlayId.playsIds.add(playObject.playId);
+            relatedPlaysByPlayId.players.push(playObject.player);
+          }
+        } else {
+          const relatedPlays = {
+            events: [playObject],
+            categoriesIds: /* @__PURE__ */ new Set([playObject.categoryId]),
+            playersIds: /* @__PURE__ */ new Set([playObject.playerId]),
+            playsIds: /* @__PURE__ */ new Set([playObject.playId]),
+            players: [playObject.player]
+          };
+          if (isMainPlay) {
+            relatedPlays.mainPlay = playObject;
+          }
+          acc.set(playObject.relatedPlayId, relatedPlays);
+        }
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      Array.from(relatedPlaysAux.values()).forEach((relatedPlay) => {
+        relatedPlay.events.sort((a, b) => b.order - a.order);
+      });
+      return relatedPlaysAux;
+    }
+    async function fetchPlaysDataPreMatch() {
+      try {
+        const config = {
+          headers: {
+            Authorization: ""
+          }
+        };
+        const [homeTeamResponse, awayTeamResponse] = await Promise.all([
+          axios.get(
+            `https://golstats-microservices.s3.us-west-2.amazonaws.com/chalkboard/chalkboard_${props.seasonSelected.id}_${props.game.homeTeam.team_id}.json`,
+            config
+          ),
+          axios.get(
+            `https://golstats-microservices.s3.us-west-2.amazonaws.com/chalkboard/chalkboard_${props.seasonSelected.id}_${props.game.awayTeam.team_id}.json`,
+            config
+          )
+        ]);
+        return [homeTeamResponse.data, awayTeamResponse.data];
+      } catch (error) {
+        throw new Error(error);
+      }
+    }
+    async function fetchPlaysData(gameId) {
+      try {
+        const response = await axios.get(
+          `https://df43gcr5d6.execute-api.us-east-2.amazonaws.com/prod/chalkboard/seasons/${props.seasonSelected.id}/games/${gameId}`,
+          {
+            headers: {
+              Authorization: props.token
+            }
+          }
+        );
+        return response.data;
+      } catch (error) {
+        throw new Error(error);
+      }
+    }
+    function fillEventsConnectionsToShowPreMatch() {
+      if (selectedTeamData.value && selectedTeamData.value.games && selectedTeamData.value.games.length > 0) {
+        const availablePlayersIds = /* @__PURE__ */ new Set();
+        availablePlayersByTeamMap.value = /* @__PURE__ */ new Map();
+        eventsConnectionsToShow.value = [];
+        selectedTeamData.value.games.forEach((game) => {
+          if (selectedGamesIds.value.has(game.id)) {
+            game.eventsConnectionsBase.forEach((eventsConnection) => {
+              if (eventsConnection.hasMainCategory(eventTypeSelected.value.categories)) {
+                eventsConnection.setEventType(eventTypeSelected.value);
+                eventsConnectionsToShow.value.push(eventsConnection);
+                availablePlayersIds.add(eventsConnection.mainPlay.playerId);
+              }
+            });
+          }
+        });
+        availablePlayersIds.forEach((playerId) => {
+          const player = selectedTeamData.value.availablePlayersMap.get(playerId);
+          if (player) {
+            const teamPlayers = availablePlayersByTeamMap.value.get(player.team_id);
+            if (teamPlayers) {
+              if (!teamPlayers.find((teamPlayer) => teamPlayer.player_id === player.player_id)) {
+                teamPlayers.push({ ...player, isSelected: true });
+              }
+            } else {
+              availablePlayersByTeamMap.value.set(player.team_id, [{ ...player, isSelected: true }]);
+            }
+          }
+        });
+      }
+    }
+    function onChangeEventType(eventType) {
+      eventTypeSelected.value = eventType;
+    }
+    function onChangeListType(listType) {
+      currentListType.value = listType;
+      if (listType === "events") {
+        homeTeam.value.isSelected = true;
+        awayTeam.value.isSelected = true;
+      }
+    }
+    function onChangePlayers(players) {
+      playersSelected.value = players;
+    }
+    function onChangeTeams(teams) {
+      teamsSelected.value = teams;
+    }
+    function onChangeGames({ gamesIds, availableTeamsIds, currentTeamGamesSelected: gamesSelected }) {
+      selectedGamesIds.value = gamesIds;
+      teamsSelected.value = availableTeamsIds;
+      currentTeamGamesSelected.value = gamesSelected;
+      if (props.isGamePreMatch) {
+        selectedGamesIdsPrivilegesVR.value.clear();
+        if (props.playVideosPrivileges && props.playVideosPrivileges.seasonAndPrivileges) {
+          gamesSelected.forEach((game) => {
+            const playingAs = game.home_team === props.playVideosPrivileges.seasonAndPrivileges.teamId ? 1 : game.visiting_team === props.playVideosPrivileges.seasonAndPrivileges.teamId ? 2 : 0;
+            if (props.playVideosPrivileges.seasonAndPrivileges.playingAs.has(playingAs)) {
+              selectedGamesIdsPrivilegesVR.value.add(game.game_id);
+            }
+          });
+        } else {
+          selectedGamesIdsPrivilegesVR.value = gamesIds;
+        }
+      }
+      fillEventsConnectionsToShowPreMatch();
+    }
+    function onChangeToggle(value) {
+      teamButtonSelectedIndex.value = value.index;
+      teamSelected.value = value.button;
+    }
+    function onClickPlay(categoriesIds) {
+      const modalInitialState = {
+        seasonId: props.game.is_live || props.game.game_status === 0 ? props.game.seasonId : props.seasonSelected.id,
+        isFeaturedPlayers: false,
+        // para indicar si es de la seccion jugadores destacados
+        mainSectionType: 1,
+        // 1 = videoplayer, 2 = my playlists
+        playListType: (
+          /*props.isGamePreMatch ? 3 :*/
+          1
+        ),
+        // 1 = partidos, 2 = jugadores, 3 = equipos
+        gameIdsToFilter: props.isGamePreMatch ? Array.from(selectedGamesIds.value.values()) : [props.game.gameId],
+        // array de id de partido, en caso de no ser necesario dejar en null
+        playerIds: [],
+        // ids de jugador, en caso de no ser necesario dejar array vacio
+        teamIdsToFilter: Array.from(teamsSelected.value.values()),
+        // ids de equipos a ser filtrados
+        categoryIds: categoriesIds,
+        // son los ids de las categorias a ser pedidas
+        teamId: props.isGamePreMatch ? (
+          /*teamSelected.value.teamId*/
+          null
+        ) : teamsSelected.value.size === 1 ? Array.from(teamsSelected.value)[0] : 0,
+        // id de equipo, en caso de no ser necesario dejar en null
+        matchResult: [1, 2, 3],
+        // 1 = gana, 2 = pierde, 3 = empate.
+        currentPlayIndex: 0
+      };
+      emit("open-media-player", modalInitialState);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.isGamePreMatch ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          __props.widthSection > 590 ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            _hoisted_4,
+            createTextVNode("  Con base en las estadísticas de los partidos ya jugados en el torneo. ")
+          ])) : createCommentVNode("", true),
+          __props.widthSection > 340 && __props.widthSection <= 590 ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            _hoisted_6,
+            createTextVNode("  "),
+            _hoisted_7,
+            createTextVNode("Con base en las estadísticas de los partidos ya "),
+            _hoisted_8,
+            createTextVNode(" jugados en el torneo. ")
+          ])) : createCommentVNode("", true),
+          __props.widthSection <= 340 ? (openBlock(), createElementBlock("div", _hoisted_9, [
+            _hoisted_10,
+            createTextVNode("  "),
+            _hoisted_11,
+            createTextVNode("Con base en las estadísticas de los "),
+            _hoisted_12,
+            createTextVNode("partidos ya jugados en el torneo. ")
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", {
+            class: normalizeClass(
+              __props.widthSection > 420 ? "container-switch-pre-match-teams" : "container-switch-pre-match-teams-mobile"
+            )
+          }, [
+            createVNode(ToggleButtons, {
+              "selected-button-index": teamButtonSelectedIndex.value,
+              buttons: toggleButtonsValues.value,
+              width: "320px",
+              "border-radius": "16px",
+              onChange: onChangeToggle
+            }, null, 8, ["selected-button-index", "buttons"])
+          ], 2)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_13, [
+          createElementVNode("div", _hoisted_14, [
+            createElementVNode("div", _hoisted_15, [
+              createElementVNode("div", _hoisted_16, [
+                createVNode(unref(GSCCheckbox), {
+                  modelValue: isAssistantZoneVisible.value,
+                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isAssistantZoneVisible.value = $event),
+                  label: "Mostrar zona de asistencia"
+                }, null, 8, ["modelValue"])
+              ]),
+              createVNode(SoccerChalkboard, {
+                "events-connections": eventsConnectionsToShow.value,
+                "list-type": currentListType.value,
+                "players-selected": playersSelected.value,
+                "teams-selected": teamsSelected.value,
+                "is-game-pre-match": __props.isGamePreMatch,
+                "is-assistant-zone-visible": isAssistantZoneVisible.value
+              }, null, 8, ["events-connections", "list-type", "players-selected", "teams-selected", "is-game-pre-match", "is-assistant-zone-visible"])
+            ]),
+            createElementVNode("div", _hoisted_17, [
+              createVNode(EventsTimeLine, {
+                "events-connections": eventsConnectionsToShow.value,
+                "list-type": currentListType.value,
+                "players-selected": playersSelected.value,
+                "teams-selected": teamsSelected.value,
+                "is-game-pre-match": __props.isGamePreMatch
+              }, null, 8, ["events-connections", "list-type", "players-selected", "teams-selected", "is-game-pre-match"])
+            ]),
+            createElementVNode("div", _hoisted_18, toDisplayString(totalEvents.value), 1)
+          ]),
+          createElementVNode("div", _hoisted_19, [
+            createVNode(CategoriesList, {
+              "is-female": __props.isFemale,
+              "home-team": homeTeam.value,
+              "away-team": awayTeam.value,
+              "tournament-selected": __props.tournamentSelected,
+              "list-events-to-display": eventsList.value,
+              "available-players-by-team": availablePlayersByTeamMap.value,
+              "list-type": currentListType.value,
+              "can-play-videos": canPlayVideosChalkboard.value,
+              "is-game-pre-match": __props.isGamePreMatch,
+              "selected-team-data": selectedTeamData.value,
+              "rival-teams": rivalTeams.value,
+              "team-selected": teamSelected.value,
+              "total-events": totalCurrentEvents.value,
+              "total-events-privileges-vr": totalCurrentEventsPrivilegesVR.value,
+              "is-privileges-vr-applicable": isPrivilegesVRApplicable.value,
+              "await-for-list-events": "",
+              onChangeEventType,
+              onChangeListType,
+              onChangePlayers,
+              onChangeTeams,
+              onChangeGames,
+              onClickPlay
+            }, null, 8, ["is-female", "home-team", "away-team", "tournament-selected", "list-events-to-display", "available-players-by-team", "list-type", "can-play-videos", "is-game-pre-match", "selected-team-data", "rival-teams", "team-selected", "total-events", "total-events-privileges-vr", "is-privileges-vr-applicable"])
+          ])
+        ])
+      ]);
+    };
+  }
+};
+const ChalkboardSectionContainer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-96de1508"]]);
+export {
+  ChalkboardSectionContainer as C,
+  ToggleButtons as T,
+  _imports_0 as _,
+  getTeamLogoUrl as a,
+  getTeamFilterOptions as b,
+  areTwoArraysEquals as c,
+  getPlayValueIndexesFromArray as g,
+  toFixedTwoDigitsMax as t
+};