<div class="text">
  <h1>Our Team 💫</h1>
  <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Necessitatibus corporis beatae dignissimos eum optio voluptas totam hic! Minus quae similique, atque at possimus voluptate maxime eum nostrum deserunt excepturi eaque!</p>
</div>
<div class="marquee-wrapper">
  <div class="marquee">
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="700" height="700" src="https://assets.codepen.io/162656/team1.jpg" alt="Team Member #1" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #1</h3>
            <p class="member-subtitle">CEO</p>
          </figcaption>
        </a>
      </article>
    </div>
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="1000" height="667" src="https://assets.codepen.io/162656/team2.jpg" alt="Team Member #2" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #2</h3>
            <p class="member-subtitle">CTO</p>
          </figcaption>
        </a>
      </article>
    </div>
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="560" height="700" src="https://assets.codepen.io/162656/team3.jpg" alt="Team Member #3" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #3</h3>
            <p class="member-subtitle">Senior Developer</p>
          </figcaption>
        </a>
      </article>
    </div>
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="1000" height="667" src="https://assets.codepen.io/162656/team4.jpg" alt="Team Member #4" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #4</h3>
            <p class="member-subtitle">Visual Designer</p>
          </figcaption>
        </a>
      </article>
    </div>
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="560" height="700" src="https://assets.codepen.io/162656/team5.jpg" alt="Team Member #5" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #5</h3>
            <p class="member-subtitle">Marketing Lead</p>
          </figcaption>
        </a>
      </article>
    </div>
    <div class="marquee-item">
      <article class="member">
        <a class="member-link" href="#0">
          <figure class="member-img-wrapper">
            <img class="member-img" width="1000" height="667" src="https://assets.codepen.io/162656/team6.jpg" alt="Team Member #6" />
          </figure>
          <figcaption class="member-details">
            <h3 class="member-title">Team Member #6</h3>
            <p class="member-subtitle">Art Director</p>
          </figcaption>
        </a>
      </article>
    </div>
  </div>
  <button type="button" class="marquee-arrow arrow-prev" aria-label="Go to the previous team member">
    <svg width="24" height="24" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill-rule="evenodd" clip-rule="evenodd">
      <path d="M20 .755l-14.374 11.245 14.374 11.219-.619.781-15.381-12 15.391-12 .609.755z" />
    </svg>

  </button>
  <button type="button" class="marquee-arrow arrow-next" aria-label="Go to the next team member">
    <svg width="24" height="24" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill-rule="evenodd" clip-rule="evenodd">
      <path d="M4 .755l14.374 11.245-14.374 11.219.619.781 15.381-12-15.391-12-.609.755z" />
    </svg>
  </button>
</div>

<footer class="page-footer">
  <span>made by </span>
  <a href="https://georgemartsoukos.com/" target="_blank">
    <img width="24" height="24" src="https://assets.codepen.io/162656/george-martsoukos-small-logo.svg" alt="George Martsoukos logo">
  </a>
</footer>

/* BASIC STYLES
–––––––––––––––––––––––––––––––––––––––––––––––––– */
@import url("https://fonts.googleapis.com/css2?family=DM+Sans:ital,opsz,wght@0,9..40,100..1000;1,9..40,100..1000&display=swap");

* {
  box-sizing: border-box;
}

a {
  color: inherit;
}

body {
  font-family: "DM Sans", sans-serif;
  margin: 100px 0;
  color: white;
  background: #131417;
}

.text {
  max-width: 1000px;
  padding: 0 15px;
  margin: 0 auto 50px;
  font-size: 1.5rem;
}

/* MARQUEE STYLES
–––––––––––––––––––––––––––––––––––––––––––––––––– */
.marquee-wrapper {
  position: relative;
}

.marquee {
  display: flex;
  gap: 30px;
  overflow: hidden;
}

.marquee-item {
  position: relative;
  width: 300px;
  display: flex;
  align-items: center;
  justify-content: center;
  flex-shrink: 0;
  overflow: hidden;
}

.member {
  width: 100%;
}

.member-link {
  display: block;
}

.member-img-wrapper {
  margin: 0;
}

.member-img {
  display: block;
  width: 100%;
  height: 300px;
  object-fit: cover;
  filter: grayscale(100%);
  transition: filter 0.3s;
}

.member-details {
  position: absolute;
  left: 0;
  bottom: 0;
  width: 100%;
  padding: 20px;
  text-align: center;
  background: rgba(0, 0, 0, 0.35);
  transform: translateY(100%);
  transition: transform 0.3s;
}

.member-title {
  margin: 0 0 5px;
}

.member-subtitle {
  margin: 0;
  text-transform: uppercase;
  color: rgba(255, 255, 255, 0.5);
}

.member-link:hover .member-details {
  transform: none;
}

.member-link:hover .member-img {
  filter: grayscale(0);
}

.marquee-arrow {
  position: absolute;
  bottom: -60px;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 45px;
  height: 45px;
  border-radius: 50%;
  background: #dc2f02;
  border: none;
  cursor: pointer;
  transition: all 0.2s;
}

.marquee-arrow.arrow-prev {
  left: calc(50% - 50px);
}

.marquee-arrow.arrow-next {
  right: calc(50% - 50px);
}

@media (min-width: 850px) {
  .marquee-item {
    width: 500px;
  }

  .member-img {
    height: 500px;
  }

  .member-title {
    font-size: 1.6em;
  }

  .marquee-arrow {
    top: 50%;
    transform: translateY(-50%);
    width: 70px;
    height: 70px;
  }

  .marquee-arrow.arrow-prev {
    left: 40px;
  }

  .marquee-arrow.arrow-next {
    right: 40px;
  }
}

/* FOOTER STYLES
–––––––––––––––––––––––––––––––––––––––––––––––––– */
.page-footer {
  position: fixed;
  right: 0;
  bottom: 50px;
  display: flex;
  align-items: center;
  padding: 5px;
  z-index: 1;
  font-size: 14px;
  color: black;
  background: white;
}

.page-footer a {
  display: flex;
  margin-left: 4px;
}

const marqueeItems = document.querySelectorAll(".marquee-item");
const btnPrev = document.querySelector(".arrow-prev");
const btnNext = document.querySelector(".arrow-next");
const conf = { duration: 1, ease: "power.inOut" };

window.addEventListener("load", function () {
  const loop = horizontalLoop(marqueeItems, {
    repeat: -1,
    paddingRight: 30,
    speed: 0.2,
    draggable: true
  });

  marqueeItems.forEach(function (item) {
    item.addEventListener("mouseenter", () => loop.pause());
    item.addEventListener("mouseleave", () => loop.play());
  });

  btnPrev.addEventListener("click", () => loop.previous(conf));
  btnNext.addEventListener("click", () => loop.next(conf));
});

/*
This helper function makes a group of elements animate along the x-axis in a seamless, responsive loop.

Features:
 - Uses xPercent so that even if the widths change (like if the window gets resized), it should still work in most cases.
 - When each item animates to the left or right enough, it will loop back to the other side
 - Optionally pass in a config object with values like draggable: true, center: true, speed (default: 1, which travels at roughly 100 pixels per second), paused (boolean), repeat, reversed, and paddingRight.
 - The returned timeline will have the following methods added to it:
   - next() - animates to the next element using a timeline.tweenTo() which it returns. You can pass in a vars object to control duration, easing, etc.
   - previous() - animates to the previous element using a timeline.tweenTo() which it returns. You can pass in a vars object to control duration, easing, etc.
   - toIndex() - pass in a zero-based index value of the element that it should animate to, and optionally pass in a vars object to control duration, easing, etc. Always goes in the shortest direction
   - current() - returns the current index (if an animation is in-progress, it reflects the final index)
   - times - an Array of the times on the timeline where each element hits the "starting" spot.
 */
function horizontalLoop(items, config) {
  let timeline;
  items = gsap.utils.toArray(items);
  config = config || {};
  gsap.context(() => {
    // use a context so that if this is called from within another context or a gsap.matchMedia(), we can perform proper cleanup like the "resize" event handler on the window
    let onChange = config.onChange,
      lastIndex = 0,
      tl = gsap.timeline({
        repeat: config.repeat,
        onUpdate:
          onChange &&
          function () {
            let i = tl.closestIndex();
            if (lastIndex !== i) {
              lastIndex = i;
              onChange(items[i], i);
            }
          },
        paused: config.paused,
        defaults: { ease: "none" },
        onReverseComplete: () =>
          tl.totalTime(tl.rawTime() + tl.duration() * 100)
      }),
      length = items.length,
      startX = items[0].offsetLeft,
      times = [],
      widths = [],
      spaceBefore = [],
      xPercents = [],
      curIndex = 0,
      indexIsDirty = false,
      center = config.center,
      pixelsPerSecond = (config.speed || 1) * 100,
      snap =
        config.snap === false ? (v) => v : gsap.utils.snap(config.snap || 1), // some browsers shift by a pixel to accommodate flex layouts, so for example if width is 20% the first element's width might be 242px, and the next 243px, alternating back and forth. So we snap to 5 percentage points to make things look more natural
      timeOffset = 0,
      container =
        center === true
          ? items[0].parentNode
          : gsap.utils.toArray(center)[0] || items[0].parentNode,
      totalWidth,
      getTotalWidth = () =>
        items[length - 1].offsetLeft +
        (xPercents[length - 1] / 100) * widths[length - 1] -
        startX +
        spaceBefore[0] +
        items[length - 1].offsetWidth *
          gsap.getProperty(items[length - 1], "scaleX") +
        (parseFloat(config.paddingRight) || 0),
      populateWidths = () => {
        let b1 = container.getBoundingClientRect(),
          b2;
        items.forEach((el, i) => {
          widths[i] = parseFloat(gsap.getProperty(el, "width", "px"));
          xPercents[i] = snap(
            (parseFloat(gsap.getProperty(el, "x", "px")) / widths[i]) * 100 +
              gsap.getProperty(el, "xPercent")
          );
          b2 = el.getBoundingClientRect();
          spaceBefore[i] = b2.left - (i ? b1.right : b1.left);
          b1 = b2;
        });
        gsap.set(items, {
          // convert "x" to "xPercent" to make things responsive, and populate the widths/xPercents Arrays to make lookups faster.
          xPercent: (i) => xPercents[i]
        });
        totalWidth = getTotalWidth();
      },
      timeWrap,
      populateOffsets = () => {
        timeOffset = center
          ? (tl.duration() * (container.offsetWidth / 2)) / totalWidth
          : 0;
        center &&
          times.forEach((t, i) => {
            times[i] = timeWrap(
              tl.labels["label" + i] +
                (tl.duration() * widths[i]) / 2 / totalWidth -
                timeOffset
            );
          });
      },
      getClosest = (values, value, wrap) => {
        let i = values.length,
          closest = 1e10,
          index = 0,
          d;
        while (i--) {
          d = Math.abs(values[i] - value);
          if (d > wrap / 2) {
            d = wrap - d;
          }
          if (d < closest) {
            closest = d;
            index = i;
          }
        }
        return index;
      },
      populateTimeline = () => {
        let i, item, curX, distanceToStart, distanceToLoop;
        tl.clear();
        for (i = 0; i < length; i++) {
          item = items[i];
          curX = (xPercents[i] / 100) * widths[i];
          distanceToStart = item.offsetLeft + curX - startX + spaceBefore[0];
          distanceToLoop =
            distanceToStart + widths[i] * gsap.getProperty(item, "scaleX");
          tl.to(
            item,
            {
              xPercent: snap(((curX - distanceToLoop) / widths[i]) * 100),
              duration: distanceToLoop / pixelsPerSecond
            },
            0
          )
            .fromTo(
              item,
              {
                xPercent: snap(
                  ((curX - distanceToLoop + totalWidth) / widths[i]) * 100
                )
              },
              {
                xPercent: xPercents[i],
                duration:
                  (curX - distanceToLoop + totalWidth - curX) / pixelsPerSecond,
                immediateRender: false
              },
              distanceToLoop / pixelsPerSecond
            )
            .add("label" + i, distanceToStart / pixelsPerSecond);
          times[i] = distanceToStart / pixelsPerSecond;
        }
        timeWrap = gsap.utils.wrap(0, tl.duration());
      },
      refresh = (deep) => {
        let progress = tl.progress();
        tl.progress(0, true);
        populateWidths();
        deep && populateTimeline();
        populateOffsets();
        deep && tl.draggable
          ? tl.time(times[curIndex], true)
          : tl.progress(progress, true);
      },
      onResize = () => refresh(true),
      proxy;
    gsap.set(items, { x: 0 });
    populateWidths();
    populateTimeline();
    populateOffsets();
    window.addEventListener("resize", onResize);
    function toIndex(index, vars) {
      vars = vars || {};
      Math.abs(index - curIndex) > length / 2 &&
        (index += index > curIndex ? -length : length); // always go in the shortest direction
      let newIndex = gsap.utils.wrap(0, length, index),
        time = times[newIndex];
      if (time > tl.time() !== index > curIndex && index !== curIndex) {
        // if we're wrapping the timeline's playhead, make the proper adjustments
        time += tl.duration() * (index > curIndex ? 1 : -1);
      }
      if (time < 0 || time > tl.duration()) {
        vars.modifiers = { time: timeWrap };
      }
      curIndex = newIndex;
      vars.overwrite = true;
      gsap.killTweensOf(proxy);
      return vars.duration === 0
        ? tl.time(timeWrap(time))
        : tl.tweenTo(time, vars);
    }
    tl.toIndex = (index, vars) => toIndex(index, vars);
    tl.closestIndex = (setCurrent) => {
      let index = getClosest(times, tl.time(), tl.duration());
      if (setCurrent) {
        curIndex = index;
        indexIsDirty = false;
      }
      return index;
    };
    tl.current = () => (indexIsDirty ? tl.closestIndex(true) : curIndex);
    tl.next = (vars) => toIndex(tl.current() + 1, vars);
    tl.previous = (vars) => toIndex(tl.current() - 1, vars);
    tl.times = times;
    tl.progress(1, true).progress(0, true); // pre-render for performance
    if (config.reversed) {
      tl.vars.onReverseComplete();
      tl.reverse();
    }
    if (config.draggable && typeof Draggable === "function") {
      proxy = document.createElement("div");
      let wrap = gsap.utils.wrap(0, 1),
        ratio,
        startProgress,
        draggable,
        dragSnap,
        lastSnap,
        initChangeX,
        wasPlaying,
        align = () =>
          tl.progress(
            wrap(startProgress + (draggable.startX - draggable.x) * ratio)
          ),
        syncIndex = () => tl.closestIndex(true);
      typeof InertiaPlugin === "undefined" &&
        console.warn(
          "InertiaPlugin required for momentum-based scrolling and snapping. https://greensock.com/club"
        );
      draggable = Draggable.create(proxy, {
        trigger: items[0].parentNode,
        type: "x",
        onPressInit() {
          let x = this.x;
          gsap.killTweensOf(tl);
          wasPlaying = !tl.paused();
          tl.pause();
          startProgress = tl.progress();
          refresh();
          ratio = 1 / totalWidth;
          initChangeX = startProgress / -ratio - x;
          gsap.set(proxy, { x: startProgress / -ratio });
        },
        onDrag: align,
        onThrowUpdate: align,
        overshootTolerance: 0,
        inertia: true,
        snap(value) {
          //note: if the user presses and releases in the middle of a throw, due to the sudden correction of proxy.x in the onPressInit(), the velocity could be very large, throwing off the snap. So sense that condition and adjust for it. We also need to set overshootTolerance to 0 to prevent the inertia from causing it to shoot past and come back
          if (Math.abs(startProgress / -ratio - this.x) < 10) {
            return lastSnap + initChangeX;
          }
          let time = -(value * ratio) * tl.duration(),
            wrappedTime = timeWrap(time),
            snapTime = times[getClosest(times, wrappedTime, tl.duration())],
            dif = snapTime - wrappedTime;
          Math.abs(dif) > tl.duration() / 2 &&
            (dif += dif < 0 ? tl.duration() : -tl.duration());
          lastSnap = (time + dif) / tl.duration() / -ratio;
          return lastSnap;
        },
        onRelease() {
          syncIndex();
          draggable.isThrowing && (indexIsDirty = true);
        },
        onThrowComplete: () => {
          syncIndex();
          wasPlaying && tl.play();
        }
      })[0];
      tl.draggable = draggable;
    }
    tl.closestIndex(true);
    lastIndex = curIndex;
    onChange && onChange(items[curIndex], curIndex);
    timeline = tl;
    return () => window.removeEventListener("resize", onResize); // cleanup
  });
  return timeline;
}