@bigbinary/neeto-site-blocks 1.2.11 → 1.3.0

package/dist/index.cjs.js

@@ -15533,6 +15533,29 @@ var Media = function Media(_ref) {
   }, otherProps));
 };
 
+var PageNavigation = function PageNavigation(_ref) {
+  var Icon = _ref.Icon,
+    isStart = _ref.isStart,
+    onClick = _ref.onClick,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? "" : _ref$className;
+  var StyledIcon = styled__default["default"](Icon)(function () {
+    return {
+      borderColor: "#1F2433"
+    };
+  });
+  return /*#__PURE__*/React__default["default"].createElement("button", {
+    onClick: onClick,
+    className: classnames("col-span-1", {
+      "col-start-1": isStart,
+      "col-start-12 flex justify-end": !isStart
+    }, className)
+  }, /*#__PURE__*/React__default["default"].createElement(StyledIcon, {
+    fill: "#66C1D4",
+    size: 52
+  }));
+};
+
 var Pagination$1 = function Pagination(_ref) {
   var _classnames, _classnames2;
   var swiper = _ref.swiper,
@@ -16075,6 +16098,20 @@ function createElement(tag, classes) {
   el.classList.add(...(Array.isArray(classes) ? classes : [classes]));
   return el;
 }
+function elementOffset(el) {
+  const window = getWindow();
+  const document = getDocument();
+  const box = el.getBoundingClientRect();
+  const body = document.body;
+  const clientTop = el.clientTop || body.clientTop || 0;
+  const clientLeft = el.clientLeft || body.clientLeft || 0;
+  const scrollTop = el === window ? window.scrollY : el.scrollTop;
+  const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
+  return {
+    top: box.top + scrollTop - clientTop,
+    left: box.left + scrollLeft - clientLeft
+  };
+}
 function elementPrevAll(el, selector) {
   const prevEls = [];
   while (el.previousElementSibling) {
@@ -23450,6 +23487,29 @@ function requireFollowRedirects () {
 	var assert = require$$4__default["default"];
 	var debug = requireDebug();
 
+	// Whether to use the native URL object or the legacy url module
+	var useNativeURL = false;
+	try {
+	  assert(new URL());
+	}
+	catch (error) {
+	  useNativeURL = error.code === "ERR_INVALID_URL";
+	}
+
+	// URL fields to preserve in copy operations
+	var preservedUrlFields = [
+	  "auth",
+	  "host",
+	  "hostname",
+	  "href",
+	  "path",
+	  "pathname",
+	  "port",
+	  "protocol",
+	  "query",
+	  "search",
+	];
+
 	// Create handlers that pass events from native requests
 	var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
 	var eventHandlers = Object.create(null);
@@ -23459,19 +23519,20 @@ function requireFollowRedirects () {
 	  };
 	});
 
+	// Error types with codes
 	var InvalidUrlError = createErrorType(
 	  "ERR_INVALID_URL",
 	  "Invalid URL",
 	  TypeError
 	);
-	// Error types with codes
 	var RedirectionError = createErrorType(
 	  "ERR_FR_REDIRECTION_FAILURE",
 	  "Redirected request failed"
 	);
 	var TooManyRedirectsError = createErrorType(
 	  "ERR_FR_TOO_MANY_REDIRECTS",
-	  "Maximum number of redirects exceeded"
+	  "Maximum number of redirects exceeded",
+	  RedirectionError
 	);
 	var MaxBodyLengthExceededError = createErrorType(
 	  "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
@@ -23482,6 +23543,9 @@ function requireFollowRedirects () {
 	  "write after end"
 	);
 
+	// istanbul ignore next
+	var destroy = Writable.prototype.destroy || noop;
+
 	// An HTTP(S) request that can be redirected
 	function RedirectableRequest(options, responseCallback) {
 	  // Initialize the request
@@ -23503,7 +23567,13 @@ function requireFollowRedirects () {
 	  // React to responses of native requests
 	  var self = this;
 	  this._onNativeResponse = function (response) {
-	    self._processResponse(response);
+	    try {
+	      self._processResponse(response);
+	    }
+	    catch (cause) {
+	      self.emit("error", cause instanceof RedirectionError ?
+	        cause : new RedirectionError({ cause: cause }));
+	    }
 	  };
 
 	  // Perform the first request
@@ -23512,10 +23582,17 @@ function requireFollowRedirects () {
 	RedirectableRequest.prototype = Object.create(Writable.prototype);
 
 	RedirectableRequest.prototype.abort = function () {
-	  abortRequest(this._currentRequest);
+	  destroyRequest(this._currentRequest);
+	  this._currentRequest.abort();
 	  this.emit("abort");
 	};
 
+	RedirectableRequest.prototype.destroy = function (error) {
+	  destroyRequest(this._currentRequest, error);
+	  destroy.call(this, error);
+	  return this;
+	};
+
 	// Writes buffered data to the current native request
 	RedirectableRequest.prototype.write = function (data, encoding, callback) {
 	  // Writing is not allowed if end has been called
@@ -23628,6 +23705,7 @@ function requireFollowRedirects () {
 	    self.removeListener("abort", clearTimer);
 	    self.removeListener("error", clearTimer);
 	    self.removeListener("response", clearTimer);
+	    self.removeListener("close", clearTimer);
 	    if (callback) {
 	      self.removeListener("timeout", callback);
 	    }
@@ -23654,6 +23732,7 @@ function requireFollowRedirects () {
 	  this.on("abort", clearTimer);
 	  this.on("error", clearTimer);
 	  this.on("response", clearTimer);
+	  this.on("close", clearTimer);
 
 	  return this;
 	};
@@ -23712,8 +23791,7 @@ function requireFollowRedirects () {
 	  var protocol = this._options.protocol;
 	  var nativeProtocol = this._options.nativeProtocols[protocol];
 	  if (!nativeProtocol) {
-	    this.emit("error", new TypeError("Unsupported protocol " + protocol));
-	    return;
+	    throw new TypeError("Unsupported protocol " + protocol);
 	  }
 
 	  // If specified, use the agent corresponding to the protocol
@@ -23805,15 +23883,14 @@ function requireFollowRedirects () {
 	  }
 
 	  // The response is a redirect, so abort the current request
-	  abortRequest(this._currentRequest);
+	  destroyRequest(this._currentRequest);
 	  // Discard the remainder of the response to avoid waiting for data
 	  response.destroy();
 
 	  // RFC7231§6.4: A client SHOULD detect and intervene
 	  // in cyclical redirections (i.e., "infinite" redirection loops).
 	  if (++this._redirectCount > this._options.maxRedirects) {
-	    this.emit("error", new TooManyRedirectsError());
-	    return;
+	    throw new TooManyRedirectsError();
 	  }
 
 	  // Store the request headers if applicable
@@ -23847,33 +23924,23 @@ function requireFollowRedirects () {
 	  var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
 
 	  // If the redirect is relative, carry over the host of the last request
-	  var currentUrlParts = url.parse(this._currentUrl);
+	  var currentUrlParts = parseUrl(this._currentUrl);
 	  var currentHost = currentHostHeader || currentUrlParts.host;
 	  var currentUrl = /^\w+:/.test(location) ? this._currentUrl :
 	    url.format(Object.assign(currentUrlParts, { host: currentHost }));
 
-	  // Determine the URL of the redirection
-	  var redirectUrl;
-	  try {
-	    redirectUrl = url.resolve(currentUrl, location);
-	  }
-	  catch (cause) {
-	    this.emit("error", new RedirectionError({ cause: cause }));
-	    return;
-	  }
-
 	  // Create the redirected request
-	  debug("redirecting to", redirectUrl);
+	  var redirectUrl = resolveUrl(location, currentUrl);
+	  debug("redirecting to", redirectUrl.href);
 	  this._isRedirect = true;
-	  var redirectUrlParts = url.parse(redirectUrl);
-	  Object.assign(this._options, redirectUrlParts);
+	  spreadUrlObject(redirectUrl, this._options);
 
 	  // Drop confidential headers when redirecting to a less secure protocol
 	  // or to a different domain that is not a superdomain
-	  if (redirectUrlParts.protocol !== currentUrlParts.protocol &&
-	     redirectUrlParts.protocol !== "https:" ||
-	     redirectUrlParts.host !== currentHost &&
-	     !isSubdomain(redirectUrlParts.host, currentHost)) {
+	  if (redirectUrl.protocol !== currentUrlParts.protocol &&
+	     redirectUrl.protocol !== "https:" ||
+	     redirectUrl.host !== currentHost &&
+	     !isSubdomain(redirectUrl.host, currentHost)) {
 	    removeMatchingHeaders(/^(?:authorization|cookie)$/i, this._options.headers);
 	  }
 
@@ -23888,23 +23955,12 @@ function requireFollowRedirects () {
 	      method: method,
 	      headers: requestHeaders,
 	    };
-	    try {
-	      beforeRedirect(this._options, responseDetails, requestDetails);
-	    }
-	    catch (err) {
-	      this.emit("error", err);
-	      return;
-	    }
+	    beforeRedirect(this._options, responseDetails, requestDetails);
 	    this._sanitizeOptions(this._options);
 	  }
 
 	  // Perform the redirected request
-	  try {
-	    this._performRequest();
-	  }
-	  catch (cause) {
-	    this.emit("error", new RedirectionError({ cause: cause }));
-	  }
+	  this._performRequest();
 	};
 
 	// Wraps the key/value object of protocols with redirect functionality
@@ -23924,27 +23980,16 @@ function requireFollowRedirects () {
 
 	    // Executes a request, following redirects
 	    function request(input, options, callback) {
-	      // Parse parameters
-	      if (isString(input)) {
-	        var parsed;
-	        try {
-	          parsed = urlToOptions(new URL(input));
-	        }
-	        catch (err) {
-	          /* istanbul ignore next */
-	          parsed = url.parse(input);
-	        }
-	        if (!isString(parsed.protocol)) {
-	          throw new InvalidUrlError({ input });
-	        }
-	        input = parsed;
+	      // Parse parameters, ensuring that input is an object
+	      if (isURL(input)) {
+	        input = spreadUrlObject(input);
 	      }
-	      else if (URL && (input instanceof URL)) {
-	        input = urlToOptions(input);
+	      else if (isString(input)) {
+	        input = spreadUrlObject(parseUrl(input));
 	      }
 	      else {
 	        callback = options;
-	        options = input;
+	        options = validateUrl(input);
 	        input = { protocol: protocol };
 	      }
 	      if (isFunction(options)) {
@@ -23983,27 +24028,57 @@ function requireFollowRedirects () {
 	  return exports;
 	}
 
-	/* istanbul ignore next */
 	function noop() { /* empty */ }
 
-	// from https://github.com/nodejs/node/blob/master/lib/internal/url.js
-	function urlToOptions(urlObject) {
-	  var options = {
-	    protocol: urlObject.protocol,
-	    hostname: urlObject.hostname.startsWith("[") ?
-	      /* istanbul ignore next */
-	      urlObject.hostname.slice(1, -1) :
-	      urlObject.hostname,
-	    hash: urlObject.hash,
-	    search: urlObject.search,
-	    pathname: urlObject.pathname,
-	    path: urlObject.pathname + urlObject.search,
-	    href: urlObject.href,
-	  };
-	  if (urlObject.port !== "") {
-	    options.port = Number(urlObject.port);
+	function parseUrl(input) {
+	  var parsed;
+	  /* istanbul ignore else */
+	  if (useNativeURL) {
+	    parsed = new URL(input);
+	  }
+	  else {
+	    // Ensure the URL is valid and absolute
+	    parsed = validateUrl(url.parse(input));
+	    if (!isString(parsed.protocol)) {
+	      throw new InvalidUrlError({ input });
+	    }
+	  }
+	  return parsed;
+	}
+
+	function resolveUrl(relative, base) {
+	  /* istanbul ignore next */
+	  return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+	}
+
+	function validateUrl(input) {
+	  if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+	    throw new InvalidUrlError({ input: input.href || input });
 	  }
-	  return options;
+	  if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+	    throw new InvalidUrlError({ input: input.href || input });
+	  }
+	  return input;
+	}
+
+	function spreadUrlObject(urlObject, target) {
+	  var spread = target || {};
+	  for (var key of preservedUrlFields) {
+	    spread[key] = urlObject[key];
+	  }
+
+	  // Fix IPv6 hostname
+	  if (spread.hostname.startsWith("[")) {
+	    spread.hostname = spread.hostname.slice(1, -1);
+	  }
+	  // Ensure port is a number
+	  if (spread.port !== "") {
+	    spread.port = Number(spread.port);
+	  }
+	  // Concatenate path
+	  spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+
+	  return spread;
 	}
 
 	function removeMatchingHeaders(regex, headers) {
@@ -24029,17 +24104,25 @@ function requireFollowRedirects () {
 
 	  // Attach constructor and set default properties
 	  CustomError.prototype = new (baseClass || Error)();
-	  CustomError.prototype.constructor = CustomError;
-	  CustomError.prototype.name = "Error [" + code + "]";
+	  Object.defineProperties(CustomError.prototype, {
+	    constructor: {
+	      value: CustomError,
+	      enumerable: false,
+	    },
+	    name: {
+	      value: "Error [" + code + "]",
+	      enumerable: false,
+	    },
+	  });
 	  return CustomError;
 	}
 
-	function abortRequest(request) {
+	function destroyRequest(request, error) {
 	  for (var event of events) {
 	    request.removeListener(event, eventHandlers[event]);
 	  }
 	  request.on("error", noop);
-	  request.abort();
+	  request.destroy(error);
 	}
 
 	function isSubdomain(subdomain, domain) {
@@ -24060,6 +24143,10 @@ function requireFollowRedirects () {
 	  return typeof value === "object" && ("length" in value);
 	}
 
+	function isURL(value) {
+	  return URL && value instanceof URL;
+	}
+
 	// Exports
 	followRedirects.exports = wrap({ http: http, https: https });
 	followRedirects.exports.wrap = wrap;
@@ -38799,6 +38886,119 @@ var FooterWithLinks = function FooterWithLinks(_ref) {
   }, copyrightText));
 };
 
+/* eslint-disable consistent-return */
+function Keyboard(_ref) {
+  let {
+    swiper,
+    extendParams,
+    on,
+    emit
+  } = _ref;
+  const document = getDocument();
+  const window = getWindow();
+  swiper.keyboard = {
+    enabled: false
+  };
+  extendParams({
+    keyboard: {
+      enabled: false,
+      onlyInViewport: true,
+      pageUpDown: true
+    }
+  });
+  function handle(event) {
+    if (!swiper.enabled) return;
+    const {
+      rtlTranslate: rtl
+    } = swiper;
+    let e = event;
+    if (e.originalEvent) e = e.originalEvent; // jquery fix
+    const kc = e.keyCode || e.charCode;
+    const pageUpDown = swiper.params.keyboard.pageUpDown;
+    const isPageUp = pageUpDown && kc === 33;
+    const isPageDown = pageUpDown && kc === 34;
+    const isArrowLeft = kc === 37;
+    const isArrowRight = kc === 39;
+    const isArrowUp = kc === 38;
+    const isArrowDown = kc === 40;
+    // Directions locks
+    if (!swiper.allowSlideNext && (swiper.isHorizontal() && isArrowRight || swiper.isVertical() && isArrowDown || isPageDown)) {
+      return false;
+    }
+    if (!swiper.allowSlidePrev && (swiper.isHorizontal() && isArrowLeft || swiper.isVertical() && isArrowUp || isPageUp)) {
+      return false;
+    }
+    if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) {
+      return undefined;
+    }
+    if (document.activeElement && document.activeElement.nodeName && (document.activeElement.nodeName.toLowerCase() === 'input' || document.activeElement.nodeName.toLowerCase() === 'textarea')) {
+      return undefined;
+    }
+    if (swiper.params.keyboard.onlyInViewport && (isPageUp || isPageDown || isArrowLeft || isArrowRight || isArrowUp || isArrowDown)) {
+      let inView = false;
+      // Check that swiper should be inside of visible area of window
+      if (elementParents(swiper.el, `.${swiper.params.slideClass}, swiper-slide`).length > 0 && elementParents(swiper.el, `.${swiper.params.slideActiveClass}`).length === 0) {
+        return undefined;
+      }
+      const el = swiper.el;
+      const swiperWidth = el.clientWidth;
+      const swiperHeight = el.clientHeight;
+      const windowWidth = window.innerWidth;
+      const windowHeight = window.innerHeight;
+      const swiperOffset = elementOffset(el);
+      if (rtl) swiperOffset.left -= el.scrollLeft;
+      const swiperCoord = [[swiperOffset.left, swiperOffset.top], [swiperOffset.left + swiperWidth, swiperOffset.top], [swiperOffset.left, swiperOffset.top + swiperHeight], [swiperOffset.left + swiperWidth, swiperOffset.top + swiperHeight]];
+      for (let i = 0; i < swiperCoord.length; i += 1) {
+        const point = swiperCoord[i];
+        if (point[0] >= 0 && point[0] <= windowWidth && point[1] >= 0 && point[1] <= windowHeight) {
+          if (point[0] === 0 && point[1] === 0) continue; // eslint-disable-line
+          inView = true;
+        }
+      }
+      if (!inView) return undefined;
+    }
+    if (swiper.isHorizontal()) {
+      if (isPageUp || isPageDown || isArrowLeft || isArrowRight) {
+        if (e.preventDefault) e.preventDefault();else e.returnValue = false;
+      }
+      if ((isPageDown || isArrowRight) && !rtl || (isPageUp || isArrowLeft) && rtl) swiper.slideNext();
+      if ((isPageUp || isArrowLeft) && !rtl || (isPageDown || isArrowRight) && rtl) swiper.slidePrev();
+    } else {
+      if (isPageUp || isPageDown || isArrowUp || isArrowDown) {
+        if (e.preventDefault) e.preventDefault();else e.returnValue = false;
+      }
+      if (isPageDown || isArrowDown) swiper.slideNext();
+      if (isPageUp || isArrowUp) swiper.slidePrev();
+    }
+    emit('keyPress', kc);
+    return undefined;
+  }
+  function enable() {
+    if (swiper.keyboard.enabled) return;
+    document.addEventListener('keydown', handle);
+    swiper.keyboard.enabled = true;
+  }
+  function disable() {
+    if (!swiper.keyboard.enabled) return;
+    document.removeEventListener('keydown', handle);
+    swiper.keyboard.enabled = false;
+  }
+  on('init', () => {
+    if (swiper.params.keyboard.enabled) {
+      enable();
+    }
+  });
+  on('destroy', () => {
+    if (swiper.keyboard.enabled) {
+      disable();
+    }
+  });
+  Object.assign(swiper.keyboard, {
+    enable,
+    disable
+  });
+}
+
 /* eslint-disable consistent-return */
 function Mousewheel(_ref) {
   let {
@@ -39676,6 +39876,145 @@ function Pagination(_ref) {
   });
 }
 
+function History(_ref) {
+  let {
+    swiper,
+    extendParams,
+    on
+  } = _ref;
+  extendParams({
+    history: {
+      enabled: false,
+      root: '',
+      replaceState: false,
+      key: 'slides',
+      keepQuery: false
+    }
+  });
+  let initialized = false;
+  let paths = {};
+  const slugify = text => {
+    return text.toString().replace(/\s+/g, '-').replace(/[^\w-]+/g, '').replace(/--+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
+  };
+  const getPathValues = urlOverride => {
+    const window = getWindow();
+    let location;
+    if (urlOverride) {
+      location = new URL(urlOverride);
+    } else {
+      location = window.location;
+    }
+    const pathArray = location.pathname.slice(1).split('/').filter(part => part !== '');
+    const total = pathArray.length;
+    const key = pathArray[total - 2];
+    const value = pathArray[total - 1];
+    return {
+      key,
+      value
+    };
+  };
+  const setHistory = (key, index) => {
+    const window = getWindow();
+    if (!initialized || !swiper.params.history.enabled) return;
+    let location;
+    if (swiper.params.url) {
+      location = new URL(swiper.params.url);
+    } else {
+      location = window.location;
+    }
+    const slide = swiper.slides[index];
+    let value = slugify(slide.getAttribute('data-history'));
+    if (swiper.params.history.root.length > 0) {
+      let root = swiper.params.history.root;
+      if (root[root.length - 1] === '/') root = root.slice(0, root.length - 1);
+      value = `${root}/${key ? `${key}/` : ''}${value}`;
+    } else if (!location.pathname.includes(key)) {
+      value = `${key ? `${key}/` : ''}${value}`;
+    }
+    if (swiper.params.history.keepQuery) {
+      value += location.search;
+    }
+    const currentState = window.history.state;
+    if (currentState && currentState.value === value) {
+      return;
+    }
+    if (swiper.params.history.replaceState) {
+      window.history.replaceState({
+        value
+      }, null, value);
+    } else {
+      window.history.pushState({
+        value
+      }, null, value);
+    }
+  };
+  const scrollToSlide = (speed, value, runCallbacks) => {
+    if (value) {
+      for (let i = 0, length = swiper.slides.length; i < length; i += 1) {
+        const slide = swiper.slides[i];
+        const slideHistory = slugify(slide.getAttribute('data-history'));
+        if (slideHistory === value) {
+          const index = swiper.getSlideIndex(slide);
+          swiper.slideTo(index, speed, runCallbacks);
+        }
+      }
+    } else {
+      swiper.slideTo(0, speed, runCallbacks);
+    }
+  };
+  const setHistoryPopState = () => {
+    paths = getPathValues(swiper.params.url);
+    scrollToSlide(swiper.params.speed, paths.value, false);
+  };
+  const init = () => {
+    const window = getWindow();
+    if (!swiper.params.history) return;
+    if (!window.history || !window.history.pushState) {
+      swiper.params.history.enabled = false;
+      swiper.params.hashNavigation.enabled = true;
+      return;
+    }
+    initialized = true;
+    paths = getPathValues(swiper.params.url);
+    if (!paths.key && !paths.value) {
+      if (!swiper.params.history.replaceState) {
+        window.addEventListener('popstate', setHistoryPopState);
+      }
+      return;
+    }
+    scrollToSlide(0, paths.value, swiper.params.runCallbacksOnInit);
+    if (!swiper.params.history.replaceState) {
+      window.addEventListener('popstate', setHistoryPopState);
+    }
+  };
+  const destroy = () => {
+    const window = getWindow();
+    if (!swiper.params.history.replaceState) {
+      window.removeEventListener('popstate', setHistoryPopState);
+    }
+  };
+  on('init', () => {
+    if (swiper.params.history.enabled) {
+      init();
+    }
+  });
+  on('destroy', () => {
+    if (swiper.params.history.enabled) {
+      destroy();
+    }
+  });
+  on('transitionEnd _freeModeNoMomentumRelease', () => {
+    if (initialized) {
+      setHistory(swiper.params.history.key, swiper.activeIndex);
+    }
+  });
+  on('slideChange', () => {
+    if (initialized && swiper.params.cssMode) {
+      setHistory(swiper.params.history.key, swiper.activeIndex);
+    }
+  });
+}
+
 /* eslint no-underscore-dangle: "off" */
 /* eslint no-use-before-define: "off" */
 function Autoplay(_ref) {
@@ -41343,6 +41682,134 @@ var PricingInCardView = function PricingInCardView(_ref) {
   })));
 };
 
+var Slides = function Slides(_ref) {
+  var configurations = _ref.configurations,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? "" : _ref$className,
+    id = _ref.id;
+  var _useState = React.useState(0),
+    _useState2 = _slicedToArray__default["default"](_useState, 2),
+    activeIndex = _useState2[0],
+    setActiveIndex = _useState2[1];
+  var swiperRef = React.useRef(null);
+  var properties = configurations.properties,
+    design = configurations.design;
+  var _properties$content$s = properties.content.slides,
+    slides = _properties$content$s === void 0 ? [] : _properties$content$s,
+    src = properties.backgroundImage.src,
+    enableAnimation = properties.enableAnimation;
+  var baseClasses = "grid grid-cols-12 items-center gap-y-4 sm:gap-x-4 grid-flow-row-dense";
+  var renderSwiperSlide = function renderSwiperSlide(_ref2) {
+    var title = _ref2.title,
+      logoUrl = _ref2.logoUrl,
+      subTitle = _ref2.subTitle,
+      layout = _ref2.layout,
+      imageUrl = _ref2.imageUrl;
+    if (layout === "titleWithSubTitle") {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
+        className: "absolute top-8 right-12 w-20",
+        src: logoUrl
+      }), /*#__PURE__*/React__default["default"].createElement("div", {
+        className: "col-span-12"
+      }, /*#__PURE__*/React__default["default"].createElement(Typography$1, {
+        isTitle: true,
+        component: "h1",
+        style: design.title
+      }, title), /*#__PURE__*/React__default["default"].createElement(Typography$1, {
+        isTitle: true,
+        component: "h1",
+        style: design.subTitle
+      }, subTitle)));
+    }
+    return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
+      className: "absolute top-8 right-12 w-20",
+      src: logoUrl
+    }), /*#__PURE__*/React__default["default"].createElement("div", {
+      className: "bottom-0 col-span-12 flex w-full justify-center sm:absolute sm:col-span-10 sm:col-start-2"
+    }, /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
+      src: imageUrl
+    })));
+  };
+  return /*#__PURE__*/React__default["default"].createElement(MotionWrapper, {
+    enableAnimation: enableAnimation,
+    id: id,
+    backgroundImage: mergeLeft({
+      src: src
+    }, design.backgroundImage),
+    className: "relative flex items-center justify-between",
+    design: mergeDesign(design.body, 80)
+  }, /*#__PURE__*/React__default["default"].createElement(PageNavigation, {
+    activeIndex: activeIndex,
+    slides: slides,
+    swiperRef: swiperRef,
+    isStart: true,
+    Icon: ArrowLeftS$1,
+    className: "absolute left-0 top-1/2 z-20 sm:left-2 lg:left-28",
+    onClick: function onClick() {
+      var _swiperRef$current;
+      return (_swiperRef$current = swiperRef.current) === null || _swiperRef$current === void 0 ? void 0 : _swiperRef$current.slidePrev();
+    }
+  }), /*#__PURE__*/React__default["default"].createElement(Swiper, {
+    loop: true,
+    history: {
+      enabled: true,
+      key: id
+    },
+    keyboard: {
+      enabled: true,
+      onlyInViewport: true
+    },
+    modules: [History, Keyboard],
+    spaceBetween: 10,
+    onSlideChange: function onSlideChange(swiper) {
+      return setActiveIndex(swiper.activeIndex);
+    },
+    onSwiper: function onSwiper(swiper) {
+      swiperRef.current = swiper;
+    }
+  }, slides.map(function (_ref3, index) {
+    var title = _ref3.title,
+      url = _ref3.url,
+      logoUrl = _ref3.logoUrl,
+      subTitle = _ref3.subTitle,
+      layout = _ref3.layout,
+      imageUrl = _ref3.imageUrl,
+      backgroundImage = _ref3.backgroundImage;
+    return /*#__PURE__*/React__default["default"].createElement(SwiperSlide, {
+      className: classnames("my-auto", className),
+      "data-history": url,
+      key: getUniqueKey(title, index)
+    }, /*#__PURE__*/React__default["default"].createElement(StyledWrapper, {
+      isRootWrapper: true,
+      backgroundImage: mergeLeft({
+        src: backgroundImage.src
+      }, design.backgroundImage),
+      className: classnames("neeto-site-block-wrapper relative lg:w-9/12", baseClasses),
+      design: mergeRight(design.container, {
+        paddingHorizontal: design.body.paddingHorizontal
+      })
+    }, /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
+      className: "absolute top-8 right-12 w-20",
+      src: logoUrl
+    }), renderSwiperSlide({
+      title: title,
+      logoUrl: logoUrl,
+      subTitle: subTitle,
+      layout: layout,
+      imageUrl: imageUrl
+    })));
+  })), /*#__PURE__*/React__default["default"].createElement(PageNavigation, {
+    activeIndex: activeIndex,
+    swiperRef: swiperRef,
+    Icon: ArrowRightS$1,
+    className: "absolute top-1/2 right-0 z-20 sm:right-2 lg:right-28",
+    onClick: function onClick() {
+      var _swiperRef$current2;
+      return (_swiperRef$current2 = swiperRef.current) === null || _swiperRef$current2 === void 0 ? void 0 : _swiperRef$current2.slideNext();
+    }
+  }));
+};
+
 var _excluded$1 = ["configurations", "className", "id"];
 var TestimonialWithSlider = function TestimonialWithSlider(_ref) {
   var configurations = _ref.configurations,
@@ -41573,6 +42040,7 @@ exports.Icons = index;
 exports.LogoClouds = LogoClouds;
 exports.Paragraph = Paragraph;
 exports.PricingInCardView = PricingInCardView;
+exports.Slides = Slides;
 exports.TestimonialWithSlider = TestimonialWithSlider;
 exports.TestimonialWithVerticalView = TestimonialWithVerticalView;
 //# sourceMappingURL=index.cjs.js.map