@bigbinary/neeto-site-blocks 1.2.10 → 1.2.12

package/dist/index.cjs.js

@@ -23450,6 +23450,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 +23482,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 +23506,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 +23530,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 +23545,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 +23668,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 +23695,7 @@ function requireFollowRedirects () {
 	  this.on("abort", clearTimer);
 	  this.on("error", clearTimer);
 	  this.on("response", clearTimer);
+	  this.on("close", clearTimer);
 
 	  return this;
 	};
@@ -23712,8 +23754,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 +23846,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 +23887,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 +23918,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 +23943,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 +23991,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 options;
+	  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 });
+	  }
+	  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 +24067,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 +24106,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;
@@ -41131,7 +41181,8 @@ var LogoClouds = function LogoClouds(_ref) {
   var configurations = _ref.configurations,
     _ref$className = _ref.className,
     className = _ref$className === void 0 ? "" : _ref$className,
-    id = _ref.id;
+    id = _ref.id,
+    disableButtonAndLinks = _ref.disableButtonAndLinks;
   var properties = configurations.properties,
     design = configurations.design;
   var _properties$logos = properties.logos,
@@ -41171,7 +41222,7 @@ var LogoClouds = function LogoClouds(_ref) {
       url = _ref2.url;
     return /*#__PURE__*/React__default["default"].createElement("a", {
       className: logoBaseClasses(index),
-      href: url,
+      href: !disableButtonAndLinks && url,
       key: getUniqueKey(title, index)
     }, /*#__PURE__*/React__default["default"].createElement(StyledImage$1, {
       alt: alt,