@wix/editor-react-components 1.2416.0 → 1.2417.0

package/dist/site/components/chunks/index3.js

@@ -1,1465 +1,5 @@
-const API_VERSION = "v1";
-const MAX_DEVICE_PIXEL_RATIO = 2;
-const DSKTP_MAX_BG_SITE_LEGACY_WIDTH = 1920;
-const DSKTP_MAX_BG_SITE_LEGACY_HEIGHT = 1920;
-const MOBILE_MAX_BG_SITE_LEGACY_WIDTH = 1e3;
-const MOBILE_MAX_BG_SITE_LEGACY_HEIGHT = 1e3;
-const fittingTypes = {
-  SCALE_TO_FILL: "fill",
-  SCALE_TO_FIT: "fit",
-  STRETCH: "stretch",
-  ORIGINAL_SIZE: "original_size",
-  TILE: "tile",
-  TILE_HORIZONTAL: "tile_horizontal",
-  TILE_VERTICAL: "tile_vertical",
-  FIT_AND_TILE: "fit_and_tile",
-  LEGACY_STRIP_TILE: "legacy_strip_tile",
-  LEGACY_STRIP_TILE_HORIZONTAL: "legacy_strip_tile_horizontal",
-  LEGACY_STRIP_TILE_VERTICAL: "legacy_strip_tile_vertical",
-  LEGACY_STRIP_SCALE_TO_FILL: "legacy_strip_fill",
-  LEGACY_STRIP_SCALE_TO_FIT: "legacy_strip_fit",
-  LEGACY_STRIP_FIT_AND_TILE: "legacy_strip_fit_and_tile",
-  LEGACY_STRIP_ORIGINAL_SIZE: "legacy_strip_original_size",
-  LEGACY_ORIGINAL_SIZE: "actual_size",
-  LEGACY_FIT_WIDTH: "fitWidth",
-  LEGACY_FIT_HEIGHT: "fitHeight",
-  LEGACY_FULL: "full",
-  LEGACY_BG_FIT_AND_TILE: "legacy_tile",
-  LEGACY_BG_FIT_AND_TILE_HORIZONTAL: "legacy_tile_horizontal",
-  LEGACY_BG_FIT_AND_TILE_VERTICAL: "legacy_tile_vertical",
-  LEGACY_BG_NORMAL: "legacy_normal"
-};
-const transformTypes = {
-  FIT: "fit",
-  FILL: "fill",
-  FILL_FOCAL: "fill_focal",
-  CROP: "crop",
-  LEGACY_CROP: "legacy_crop",
-  LEGACY_FILL: "legacy_fill"
-};
-const alignTypes = {
-  CENTER: "center",
-  TOP: "top",
-  TOP_LEFT: "top_left",
-  TOP_RIGHT: "top_right",
-  BOTTOM: "bottom",
-  BOTTOM_LEFT: "bottom_left",
-  BOTTOM_RIGHT: "bottom_right",
-  LEFT: "left",
-  RIGHT: "right"
-};
-const ALIGN_TYPE_TO_FOCAL_POINT = {
-  [alignTypes.CENTER]: { x: 0.5, y: 0.5 },
-  [alignTypes.TOP_LEFT]: { x: 0, y: 0 },
-  [alignTypes.TOP_RIGHT]: { x: 1, y: 0 },
-  [alignTypes.TOP]: { x: 0.5, y: 0 },
-  [alignTypes.BOTTOM_LEFT]: { x: 0, y: 1 },
-  [alignTypes.BOTTOM_RIGHT]: { x: 1, y: 1 },
-  [alignTypes.BOTTOM]: { x: 0.5, y: 1 },
-  [alignTypes.RIGHT]: { x: 1, y: 0.5 },
-  [alignTypes.LEFT]: { x: 0, y: 0.5 }
-};
-const alignTypesMap = {
-  center: "c",
-  top: "t",
-  top_left: "tl",
-  top_right: "tr",
-  bottom: "b",
-  bottom_left: "bl",
-  bottom_right: "br",
-  left: "l",
-  right: "r"
-};
-const htmlTag = {
-  BG: "bg",
-  SVG: "svg"
-};
-const upscaleMethods = {
-  AUTO: "auto",
-  CLASSIC: "classic",
-  SUPER: "super"
-};
-const upscaleMethodsValues = {
-  classic: 1,
-  super: 2
-};
-const defaultUSM = {
-  radius: "0.66",
-  amount: "1.00",
-  threshold: "0.01"
-};
-const emptyData = {
-  uri: "",
-  css: {
-    img: {},
-    container: {}
-  },
-  attr: {
-    img: {},
-    container: {}
-  },
-  transformed: false
-};
-const MAX_TRANSFORMED_IMAGE_WIDTH = 5e3;
-const MAX_TRANSFORMED_IMAGE_HEIGHT = 5e3;
-const SAFE_TRANSFORMED_AREA = MAX_TRANSFORMED_IMAGE_WIDTH * MAX_TRANSFORMED_IMAGE_HEIGHT;
-const SUPER_UPSCALE_MODELS = [1.5, 2, 4];
-const imageScaleDefaults = {
-  HIGH: {
-    size: 1400 * 1400,
-    quality: 90,
-    maxUpscale: 1
-  },
-  MEDIUM: {
-    size: 600 * 600,
-    quality: 85,
-    maxUpscale: 1
-  },
-  LOW: {
-    size: 400 * 400,
-    quality: 80,
-    maxUpscale: 1.2
-  },
-  TINY: {
-    size: 0,
-    quality: 80,
-    maxUpscale: 1.4
-  }
-};
-const imageQuality = {
-  HIGH: "HIGH",
-  MEDIUM: "MEDIUM",
-  LOW: "LOW",
-  TINY: "TINY"
-};
-const imageFilters = {
-  CONTRAST: "contrast",
-  BRIGHTNESS: "brightness",
-  SATURATION: "saturation",
-  HUE: "hue",
-  BLUR: "blur"
-};
-const fileType = {
-  JPG: "jpg",
-  JPEG: "jpeg",
-  JPE: "jpe",
-  PNG: "png",
-  WEBP: "webp",
-  WIX_ICO_MP: "wix_ico_mp",
-  WIX_MP: "wix_mp",
-  GIF: "gif",
-  AVIF: "avif",
-  UNRECOGNIZED: "unrecognized"
-};
-const encodingTypes = {
-  AVIF: "AVIF",
-  PAVIF: "PAVIF"
-};
-function template(strings, ...keys) {
-  return function(...values) {
-    const dict = values[values.length - 1] || {};
-    const result = [strings[0]];
-    keys.forEach(function(key, i) {
-      const value = Number.isInteger(key) ? values[key] : dict[key];
-      result.push(value, strings[i + 1]);
-    });
-    return result.join("");
-  };
-}
-function last(array) {
-  return array[array.length - 1];
-}
-const SUPPORTED_IMAGE_EXTENSIONS = [
-  fileType.PNG,
-  fileType.JPEG,
-  fileType.JPG,
-  fileType.JPE,
-  fileType.WIX_ICO_MP,
-  fileType.WIX_MP,
-  fileType.WEBP,
-  fileType.AVIF
-];
-const JPG_EXTENSIONS = [
-  fileType.JPEG,
-  fileType.JPG,
-  fileType.JPE
-];
-function isImageTypeSupported(uri) {
-  return SUPPORTED_IMAGE_EXTENSIONS.includes(getFileExtension(uri));
-}
-function isValidRequest(fittingType, src, target) {
-  return target && src && !isUrlEmptyOrNone(src.id) && Object.values(fittingTypes).includes(fittingType);
-}
-function canTransformAnimatedWebpOrAvif(uri, hasAnimation, allowAnimatedTransform) {
-  const isAvifWebpFormat = isWEBP(uri) || isAVIF(uri);
-  if (!isAvifWebpFormat || !hasAnimation) {
-    return true;
-  }
-  return allowAnimatedTransform;
-}
-function canTransformGIF(uri, allowAnimatedTransform, allowFullGIFTransformation) {
-  if (!isGIF(uri)) {
-    return false;
-  }
-  return !!(allowAnimatedTransform || allowFullGIFTransformation);
-}
-function isImageTransformApplicable(uri, hasAnimation, allowAnimatedTransform, allowFullGIFTransformation) {
-  if (isExternalUrl(uri)) {
-    return false;
-  }
-  if (!canTransformAnimatedWebpOrAvif(uri, hasAnimation, allowAnimatedTransform)) {
-    return false;
-  }
-  const isSupportedImageType = isImageTypeSupported(uri);
-  const isTransformableGif = canTransformGIF(uri, allowAnimatedTransform, allowFullGIFTransformation);
-  return isSupportedImageType || isTransformableGif;
-}
-function isJPG(uri) {
-  return JPG_EXTENSIONS.includes(getFileExtension(uri));
-}
-function isPNG(uri) {
-  return getFileExtension(uri) === fileType.PNG;
-}
-function isWEBP(uri) {
-  return getFileExtension(uri) === fileType.WEBP;
-}
-function isGIF(uri) {
-  return getFileExtension(uri) === fileType.GIF;
-}
-function isAVIF(uri) {
-  return getFileExtension(uri) === fileType.AVIF;
-}
-function isExternalUrl(url) {
-  return /(^https?)|(^data)|(^\/\/)/.test(url);
-}
-function isUrlEmptyOrNone(url) {
-  return !url || !url.trim() || url.toLowerCase() === "none";
-}
-function isSEOBot(options) {
-  return (options == null ? void 0 : options.isSEOBot) ?? false;
-}
-const ILLEGAL_CHARS = ["/", "\\", "?", "<", ">", "|", "“", ":", '"'].map(encodeURIComponent);
-const URL_SAFE_ILLEGAL_CHARS = ["\\.", "\\*"];
-const ILLEGAL_CHARS_REPLACEMENT = "_";
-function getFileName(uri, name) {
-  const beforeLeadingSlashRegexp = /\/(.*?)$/;
-  const fileExtensionRegexp = /\.([^.]*)$/;
-  const illegalCharsRegex = new RegExp(`(${ILLEGAL_CHARS.concat(URL_SAFE_ILLEGAL_CHARS).join("|")})`, "g");
-  if (name && name.length) {
-    let fileName2 = name;
-    const extension = name.match(fileExtensionRegexp);
-    if (extension && SUPPORTED_IMAGE_EXTENSIONS.includes(extension[1])) {
-      fileName2 = name.replace(fileExtensionRegexp, "");
-    }
-    return encodeURIComponent(fileName2).replace(illegalCharsRegex, ILLEGAL_CHARS_REPLACEMENT);
-  }
-  const trimmed = uri.match(beforeLeadingSlashRegexp);
-  const fileName = trimmed ? trimmed[1] : uri;
-  return fileName.replace(fileExtensionRegexp, "");
-}
-function getFileType(uri) {
-  if (isJPG(uri)) {
-    return fileType.JPG;
-  } else if (isPNG(uri)) {
-    return fileType.PNG;
-  } else if (isWEBP(uri)) {
-    return fileType.WEBP;
-  } else if (isGIF(uri)) {
-    return fileType.GIF;
-  } else if (isAVIF(uri)) {
-    return fileType.AVIF;
-  }
-  return fileType.UNRECOGNIZED;
-}
-function getFileExtension(uri) {
-  const splitURI = /[.]([^.]+)$/.exec(uri);
-  return (splitURI && /[.]([^.]+)$/.exec(uri)[1] || "").toLowerCase();
-}
-function getFitScaleFactor(sWidth, sHeight, dWidth, dHeight) {
-  return Math.min(dWidth / sWidth, dHeight / sHeight);
-}
-function getFillScaleFactor(sWidth, sHeight, dWidth, dHeight) {
-  return Math.max(dWidth / sWidth, dHeight / sHeight);
-}
-function getScaleFactor(sWidth, sHeight, dWidth, dHeight, transformType) {
-  let scaleFactor;
-  if (transformType === transformTypes.FILL) {
-    scaleFactor = getFillScaleFactor(sWidth, sHeight, dWidth, dHeight);
-  } else if (transformType === transformTypes.FIT) {
-    scaleFactor = getFitScaleFactor(sWidth, sHeight, dWidth, dHeight);
-  } else {
-    scaleFactor = 1;
-  }
-  return scaleFactor;
-}
-function getSafeTransformData(sWidth, sHeight, dWidth, dHeight, transformType) {
-  let scaleFactor;
-  let width = dWidth;
-  let height = dHeight;
-  scaleFactor = getScaleFactor(sWidth, sHeight, dWidth, dHeight, transformType);
-  if (transformType === transformTypes.FIT) {
-    width = sWidth * scaleFactor;
-    height = sHeight * scaleFactor;
-  }
-  if (width && height && width * height > SAFE_TRANSFORMED_AREA) {
-    const dimensionScaleFactor = Math.sqrt(SAFE_TRANSFORMED_AREA / (width * height));
-    width *= dimensionScaleFactor;
-    height *= dimensionScaleFactor;
-    scaleFactor = getScaleFactor(sWidth, sHeight, width, height, transformType);
-  }
-  return {
-    scaleFactor,
-    width,
-    height
-  };
-}
-function getTransformData(sWidth, sHeight, transformType, target, dpr, upscaleMethod) {
-  sWidth = sWidth || target.width;
-  sHeight = sHeight || target.height;
-  const { scaleFactor, width, height } = getSafeTransformData(sWidth, sHeight, target.width * dpr, target.height * dpr, transformType);
-  return getOptimizedTransformData(sWidth, sHeight, width, height, upscaleMethod, scaleFactor, transformType);
-}
-function getFocalPointFrom9GridAlignment(alignment = alignTypes.CENTER) {
-  return ALIGN_TYPE_TO_FOCAL_POINT[alignment];
-}
-function getAlignedRect(sRect, dRect, sFP, alignment) {
-  const fp = getFocalPoint(sFP) || getFocalPointFrom9GridAlignment(alignment);
-  const x = Math.max(0, Math.min(sRect.width - dRect.width, fp.x * sRect.width - dRect.width / 2));
-  const y = Math.max(0, Math.min(sRect.height - dRect.height, fp.y * sRect.height - dRect.height / 2));
-  return {
-    x,
-    y,
-    width: Math.min(sRect.width, dRect.width),
-    height: Math.min(sRect.height, dRect.height)
-  };
-}
-function getOverlappingRect(sRect, dRect) {
-  const width = Math.max(0, Math.min(sRect.width, dRect.x + dRect.width) - Math.max(0, dRect.x));
-  const height = Math.max(0, Math.min(sRect.height, dRect.y + dRect.height) - Math.max(0, dRect.y));
-  const isValidRect = width && height && (sRect.width !== width || sRect.height !== height);
-  return isValidRect ? {
-    x: Math.max(0, dRect.x),
-    y: Math.max(0, dRect.y),
-    width,
-    height
-  } : null;
-}
-function getDevicePixelRatio(target) {
-  return Math.min(target.pixelAspectRatio || 1, MAX_DEVICE_PIXEL_RATIO);
-}
-function getAlignment(target) {
-  return target.alignment && alignTypesMap[target.alignment] || alignTypesMap[alignTypes.CENTER];
-}
-function getFocalPoint(focalPoint) {
-  let fp;
-  if (focalPoint && typeof focalPoint.x === "number" && !isNaN(focalPoint.x) && typeof focalPoint.y === "number" && !isNaN(focalPoint.y)) {
-    fp = {
-      x: roundToFixed(Math.max(0, Math.min(100, focalPoint.x)) / 100, 2),
-      y: roundToFixed(Math.max(0, Math.min(100, focalPoint.y)) / 100, 2)
-    };
-  }
-  return fp;
-}
-function getPreferredImageQuality(imageWidth, imageHeight) {
-  return imageScaleDefaults[getImageQualityKey(imageWidth, imageHeight)].quality;
-}
-function getClassicScaleData(sWidth, sHeight) {
-  const imageKey = getImageQualityKey(sWidth, sHeight);
-  return {
-    optimizedScaleFactor: imageScaleDefaults[imageKey].maxUpscale,
-    upscaleMethodValue: upscaleMethodsValues.classic,
-    forceUSM: false
-  };
-}
-function getAutoScaleData(sWidth, sHeight) {
-  const imageKey = getImageQualityKey(sWidth, sHeight);
-  return {
-    optimizedScaleFactor: imageScaleDefaults[imageKey].maxUpscale,
-    upscaleMethodValue: upscaleMethodsValues.classic,
-    forceUSM: false
-  };
-}
-function getSuperScaleData(scaleFactor) {
-  return {
-    optimizedScaleFactor: last(SUPER_UPSCALE_MODELS),
-    upscaleMethodValue: upscaleMethodsValues.super,
-    forceUSM: !(SUPER_UPSCALE_MODELS.includes(scaleFactor) || scaleFactor > last(SUPER_UPSCALE_MODELS))
-  };
-}
-function getOptimizedScaleData(sWidth, sHeight, scaleFactor, upscaleMethod) {
-  if (upscaleMethod === "auto") {
-    return getAutoScaleData(sWidth, sHeight);
-  } else if (upscaleMethod === "super") {
-    return getSuperScaleData(scaleFactor);
-  }
-  return getClassicScaleData(sWidth, sHeight);
-}
-function getOptimizedTransformData(sWidth, sHeight, tWidth, tHeight, upscaleMethod, scaleFactor, transformType) {
-  const { optimizedScaleFactor, upscaleMethodValue, forceUSM } = getOptimizedScaleData(sWidth, sHeight, scaleFactor, upscaleMethod);
-  let width = tWidth;
-  let height = tHeight;
-  if (scaleFactor <= optimizedScaleFactor) {
-    return {
-      width,
-      height,
-      scaleFactor,
-      upscaleMethodValue,
-      forceUSM,
-      cssUpscaleNeeded: false
-    };
-  }
-  switch (transformType) {
-    case transformTypes.FILL:
-      width = tWidth * (optimizedScaleFactor / scaleFactor);
-      height = tHeight * (optimizedScaleFactor / scaleFactor);
-      break;
-    case transformTypes.FIT:
-      width = sWidth * optimizedScaleFactor;
-      height = sHeight * optimizedScaleFactor;
-      break;
-  }
-  return {
-    width,
-    height,
-    scaleFactor: optimizedScaleFactor,
-    upscaleMethodValue,
-    forceUSM,
-    cssUpscaleNeeded: true
-  };
-}
-function getImageQualityKey(imageWidth, imageHeight) {
-  const size = imageWidth * imageHeight;
-  if (size > imageScaleDefaults[imageQuality.HIGH].size) {
-    return imageQuality.HIGH;
-  } else if (size > imageScaleDefaults[imageQuality.MEDIUM].size) {
-    return imageQuality.MEDIUM;
-  } else if (size > imageScaleDefaults[imageQuality.LOW].size) {
-    return imageQuality.LOW;
-  }
-  return imageQuality.TINY;
-}
-function getDimension(sWidth, sHeight, tWidth, tHeight, transformType) {
-  const scaleFactor = getScaleFactor(sWidth, sHeight, tWidth, tHeight, transformType);
-  return {
-    width: Math.round(sWidth * scaleFactor),
-    height: Math.round(sHeight * scaleFactor)
-  };
-}
-function roundToFixed(value, precision) {
-  const truncatePrecision = Math.pow(10, precision);
-  return (value * truncatePrecision / truncatePrecision).toFixed(precision);
-}
-function getUpscaleString(options) {
-  if (!options || !options.upscaleMethod) {
-    return upscaleMethods.AUTO;
-  }
-  return upscaleMethods[options.upscaleMethod.toUpperCase()] || upscaleMethods.AUTO;
-}
-function imageIsAnimated(uri, hasAnimation) {
-  const isAvifWebpFormat = isWEBP(uri) || isAVIF(uri);
-  return getFileExtension(uri) === fileType.GIF || isAvifWebpFormat && hasAnimation;
-}
-const globalFeaturesSupportObj = {
-  /**
-   * @type {object<boolean>}
-   */
-  isMobile: false
-};
-const getFeature = function(feature) {
-  return globalFeaturesSupportObj[feature];
-};
-const setFeature = function(feature, value) {
-  globalFeaturesSupportObj[feature] = value;
-};
-function populateGlobalFeatureSupport() {
-  if (typeof window !== "undefined" && typeof navigator !== "undefined") {
-    const isSmallScreen = window.matchMedia && window.matchMedia("(max-width: 767px)").matches;
-    const isMobileAgent = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-    setFeature("isMobile", isSmallScreen && isMobileAgent);
-  }
-}
-function getCSS$1(transformsObj, target) {
-  const attributes = {
-    css: {
-      container: {}
-    }
-  };
-  const { css } = attributes;
-  const { fittingType } = transformsObj;
-  switch (fittingType) {
-    case fittingTypes.ORIGINAL_SIZE:
-    case fittingTypes.LEGACY_ORIGINAL_SIZE:
-    case fittingTypes.LEGACY_STRIP_ORIGINAL_SIZE:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "no-repeat";
-      break;
-    case fittingTypes.SCALE_TO_FIT:
-    case fittingTypes.LEGACY_STRIP_SCALE_TO_FIT:
-      css.container.backgroundSize = "contain";
-      css.container.backgroundRepeat = "no-repeat";
-      break;
-    case fittingTypes.STRETCH:
-      css.container.backgroundSize = "100% 100%";
-      css.container.backgroundRepeat = "no-repeat";
-      break;
-    case fittingTypes.SCALE_TO_FILL:
-    case fittingTypes.LEGACY_STRIP_SCALE_TO_FILL:
-      css.container.backgroundSize = "cover";
-      css.container.backgroundRepeat = "no-repeat";
-      break;
-    case fittingTypes.TILE_HORIZONTAL:
-    case fittingTypes.LEGACY_STRIP_TILE_HORIZONTAL:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat-x";
-      break;
-    case fittingTypes.TILE_VERTICAL:
-    case fittingTypes.LEGACY_STRIP_TILE_VERTICAL:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat-y";
-      break;
-    case fittingTypes.TILE:
-    case fittingTypes.LEGACY_STRIP_TILE:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat";
-      break;
-    case fittingTypes.LEGACY_STRIP_FIT_AND_TILE:
-      css.container.backgroundSize = "contain";
-      css.container.backgroundRepeat = "repeat";
-      break;
-    case fittingTypes.FIT_AND_TILE:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat";
-      break;
-    // Legacy old editor bg types.
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat";
-      break;
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_HORIZONTAL:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat-x";
-      break;
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_VERTICAL:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "repeat-y";
-      break;
-    case fittingTypes.LEGACY_BG_NORMAL:
-      css.container.backgroundSize = "auto";
-      css.container.backgroundRepeat = "no-repeat";
-      break;
-  }
-  switch (target.alignment) {
-    case alignTypes.CENTER:
-      css.container.backgroundPosition = "center center";
-      break;
-    case alignTypes.LEFT:
-      css.container.backgroundPosition = "left center";
-      break;
-    case alignTypes.RIGHT:
-      css.container.backgroundPosition = "right center";
-      break;
-    case alignTypes.TOP:
-      css.container.backgroundPosition = "center top";
-      break;
-    case alignTypes.BOTTOM:
-      css.container.backgroundPosition = "center bottom";
-      break;
-    case alignTypes.TOP_RIGHT:
-      css.container.backgroundPosition = "right top";
-      break;
-    case alignTypes.TOP_LEFT:
-      css.container.backgroundPosition = "left top";
-      break;
-    case alignTypes.BOTTOM_RIGHT:
-      css.container.backgroundPosition = "right bottom";
-      break;
-    case alignTypes.BOTTOM_LEFT:
-      css.container.backgroundPosition = "left bottom";
-      break;
-  }
-  return attributes;
-}
-function alignTypeToPosition(verticalMiddle, horizontalMiddle, target) {
-  return {
-    [alignTypes.TOP_LEFT]: { top: 0, left: 0 },
-    [alignTypes.TOP_RIGHT]: { top: 0, right: 0 },
-    [alignTypes.TOP]: { top: 0, left: horizontalMiddle },
-    [alignTypes.BOTTOM_LEFT]: { bottom: 0, left: 0 },
-    [alignTypes.BOTTOM_RIGHT]: { bottom: 0, right: 0 },
-    [alignTypes.BOTTOM]: { bottom: 0, left: horizontalMiddle },
-    [alignTypes.RIGHT]: { top: verticalMiddle, right: 0 },
-    [alignTypes.LEFT]: { top: verticalMiddle, left: 0 },
-    [alignTypes.CENTER]: {
-      width: target.width,
-      height: target.height,
-      objectFit: "none"
-    }
-  };
-}
-const alignTypeToPositionStr = {
-  [alignTypes.CENTER]: "center",
-  [alignTypes.TOP]: "top",
-  [alignTypes.TOP_LEFT]: "top left",
-  [alignTypes.TOP_RIGHT]: "top right",
-  [alignTypes.BOTTOM]: "bottom",
-  [alignTypes.BOTTOM_LEFT]: "bottom left",
-  [alignTypes.BOTTOM_RIGHT]: "bottom right",
-  [alignTypes.LEFT]: "left",
-  [alignTypes.RIGHT]: "right"
-};
-const aligmentDefaults = {
-  position: "absolute",
-  top: "auto",
-  right: "auto",
-  bottom: "auto",
-  left: "auto"
-};
-function getCSS(transformsObj, target) {
-  const attributes = {
-    css: {
-      container: {},
-      img: {}
-    }
-  };
-  const { css } = attributes;
-  const { fittingType } = transformsObj;
-  const alignType = target.alignment;
-  css.container.position = "relative";
-  switch (fittingType) {
-    case fittingTypes.ORIGINAL_SIZE:
-    case fittingTypes.LEGACY_ORIGINAL_SIZE:
-      if (transformsObj.parts && transformsObj.parts.length) {
-        css.img.width = transformsObj.parts[0].width;
-        css.img.height = transformsObj.parts[0].height;
-      } else {
-        css.img.width = transformsObj.src.width;
-        css.img.height = transformsObj.src.height;
-      }
-      break;
-    case fittingTypes.SCALE_TO_FIT:
-    case fittingTypes.LEGACY_FIT_WIDTH:
-    case fittingTypes.LEGACY_FIT_HEIGHT:
-    case fittingTypes.LEGACY_FULL:
-      css.img.width = target.width;
-      css.img.height = target.height;
-      css.img.objectFit = "contain";
-      css.img.objectPosition = alignTypeToPositionStr[alignType] || "unset";
-      break;
-    // BG_NORMAL is a sitebackground legacy for original size fitting type.
-    // target width and height were modified in transform.js
-    case fittingTypes.LEGACY_BG_NORMAL:
-      css.img.width = "100%";
-      css.img.height = "100%";
-      css.img.objectFit = "none";
-      css.img.objectPosition = alignTypeToPositionStr[alignType] || "unset";
-      break;
-    case fittingTypes.STRETCH:
-      css.img.width = target.width;
-      css.img.height = target.height;
-      css.img.objectFit = "fill";
-      break;
-    case fittingTypes.SCALE_TO_FILL:
-      css.img.width = target.width;
-      css.img.height = target.height;
-      css.img.objectFit = "cover";
-      break;
-  }
-  if (typeof css.img.width === "number" && typeof css.img.height === "number" && (css.img.width !== target.width || css.img.height !== target.height)) {
-    const verticalMiddle = Math.round((target.height - css.img.height) / 2);
-    const horizontalMiddle = Math.round((target.width - css.img.width) / 2);
-    Object.assign(css.img, aligmentDefaults, alignTypeToPosition(verticalMiddle, horizontalMiddle, target)[alignType]);
-  }
-  return attributes;
-}
-function getSvgAttr(transformsObj, target) {
-  const attributes = {
-    css: {
-      container: {}
-    },
-    attr: {
-      container: {},
-      img: {}
-    }
-  };
-  const { css, attr } = attributes;
-  const { fittingType } = transformsObj;
-  const alignType = target.alignment;
-  const { width: sourceWidth, height: sourceHeight } = transformsObj.src;
-  let imageScale;
-  css.container.position = "relative";
-  switch (fittingType) {
-    case fittingTypes.ORIGINAL_SIZE:
-    case fittingTypes.LEGACY_ORIGINAL_SIZE:
-    case fittingTypes.TILE:
-      if (transformsObj.parts && transformsObj.parts.length) {
-        attr.img.width = transformsObj.parts[0].width;
-        attr.img.height = transformsObj.parts[0].height;
-      } else {
-        attr.img.width = sourceWidth;
-        attr.img.height = sourceHeight;
-      }
-      attr.img.preserveAspectRatio = "xMidYMid slice";
-      break;
-    case fittingTypes.SCALE_TO_FIT:
-    case fittingTypes.LEGACY_FIT_WIDTH:
-    case fittingTypes.LEGACY_FIT_HEIGHT:
-    case fittingTypes.LEGACY_FULL:
-      attr.img.width = "100%";
-      attr.img.height = "100%";
-      attr.img.transform = "";
-      attr.img.preserveAspectRatio = "";
-      break;
-    case fittingTypes.STRETCH:
-      attr.img.width = target.width;
-      attr.img.height = target.height;
-      attr.img.x = 0;
-      attr.img.y = 0;
-      attr.img.transform = "";
-      attr.img.preserveAspectRatio = "none";
-      break;
-    case fittingTypes.SCALE_TO_FILL:
-      if (!isImageTransformApplicable(transformsObj.src.id)) {
-        imageScale = getDimension(sourceWidth, sourceHeight, target.width, target.height, transformTypes.FILL);
-        attr.img.width = imageScale.width;
-        attr.img.height = imageScale.height;
-      } else {
-        attr.img.width = target.width;
-        attr.img.height = target.height;
-      }
-      attr.img.x = 0;
-      attr.img.y = 0;
-      attr.img.transform = "";
-      attr.img.preserveAspectRatio = "xMidYMid slice";
-      break;
-  }
-  if (typeof attr.img.width === "number" && typeof attr.img.height === "number" && (attr.img.width !== target.width || attr.img.height !== target.height)) {
-    let x = 0;
-    let y = 0;
-    let right;
-    let bottom;
-    if (fittingType === fittingTypes.TILE) {
-      right = target.width % attr.img.width;
-      bottom = target.height % attr.img.height;
-    } else {
-      right = target.width - attr.img.width;
-      bottom = target.height - attr.img.height;
-    }
-    const center = Math.round(right / 2);
-    const middle = Math.round(bottom / 2);
-    switch (alignType) {
-      case alignTypes.TOP_LEFT:
-        x = 0;
-        y = 0;
-        break;
-      case alignTypes.TOP:
-        x = center;
-        y = 0;
-        break;
-      case alignTypes.TOP_RIGHT:
-        x = right;
-        y = 0;
-        break;
-      case alignTypes.LEFT:
-        x = 0;
-        y = middle;
-        break;
-      case alignTypes.CENTER:
-        x = center;
-        y = middle;
-        break;
-      case alignTypes.RIGHT:
-        x = right;
-        y = middle;
-        break;
-      case alignTypes.BOTTOM_LEFT:
-        x = 0;
-        y = bottom;
-        break;
-      case alignTypes.BOTTOM:
-        x = center;
-        y = bottom;
-        break;
-      case alignTypes.BOTTOM_RIGHT:
-        x = right;
-        y = bottom;
-        break;
-    }
-    attr.img.x = x;
-    attr.img.y = y;
-  }
-  attr.container.width = target.width;
-  attr.container.height = target.height;
-  attr.container.viewBox = [0, 0, target.width, target.height].join(" ");
-  return attributes;
-}
-function getAttributes(transformsObj, target) {
-  let attributesGetter;
-  if (target.htmlTag === htmlTag.BG) {
-    attributesGetter = getCSS$1;
-  } else if (target.htmlTag === htmlTag.SVG) {
-    attributesGetter = getSvgAttr;
-  } else {
-    attributesGetter = getCSS;
-  }
-  return attributesGetter(transformsObj, target);
-}
-function isMobile() {
-  return getFeature("isMobile");
-}
-function setTransformParts(transformsObj, src, target) {
-  let rect;
-  if (src.crop) {
-    rect = getOverlappingRect(src, src.crop);
-    if (rect) {
-      transformsObj.src.width = rect.width;
-      transformsObj.src.height = rect.height;
-      transformsObj.src.isCropped = true;
-      transformsObj.parts.push(getCropPart(rect));
-    }
-  }
-  switch (transformsObj.fittingType) {
-    case fittingTypes.SCALE_TO_FIT:
-    case fittingTypes.LEGACY_FIT_WIDTH:
-    case fittingTypes.LEGACY_FIT_HEIGHT:
-    case fittingTypes.LEGACY_FULL:
-    case fittingTypes.FIT_AND_TILE:
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE:
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_HORIZONTAL:
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_VERTICAL:
-    case fittingTypes.LEGACY_BG_NORMAL:
-      transformsObj.parts.push(getFitPart(transformsObj, target));
-      break;
-    case fittingTypes.SCALE_TO_FILL:
-      transformsObj.parts.push(getFillPart(transformsObj, target));
-      break;
-    case fittingTypes.STRETCH:
-      transformsObj.parts.push(getStretchPart(transformsObj, target));
-      break;
-    case fittingTypes.TILE_HORIZONTAL:
-    case fittingTypes.TILE_VERTICAL:
-    case fittingTypes.TILE:
-    case fittingTypes.LEGACY_ORIGINAL_SIZE:
-    case fittingTypes.ORIGINAL_SIZE:
-      rect = getAlignedRect(transformsObj.src, target, transformsObj.focalPoint, target.alignment);
-      if (transformsObj.src.isCropped) {
-        Object.assign(transformsObj.parts[0], rect);
-        transformsObj.src.width = rect.width;
-        transformsObj.src.height = rect.height;
-      } else {
-        transformsObj.parts.push(getCropPart(rect));
-      }
-      break;
-    // ---------------------------------------------------------------------------------------
-    // handles a legacy bug on bgImageStrip, background html tag
-    // component Full Width Strip stored incorrect image source width and height
-    // ---------------------------------------------------------------------------------------
-    case fittingTypes.LEGACY_STRIP_TILE_HORIZONTAL:
-    case fittingTypes.LEGACY_STRIP_TILE_VERTICAL:
-    case fittingTypes.LEGACY_STRIP_TILE:
-    case fittingTypes.LEGACY_STRIP_ORIGINAL_SIZE:
-      transformsObj.parts.push(getLegacyCropPart(target));
-      break;
-    case fittingTypes.LEGACY_STRIP_SCALE_TO_FIT:
-    case fittingTypes.LEGACY_STRIP_FIT_AND_TILE:
-      transformsObj.parts.push(getLegacyFitPart(target));
-      break;
-    case fittingTypes.LEGACY_STRIP_SCALE_TO_FILL:
-      transformsObj.parts.push(getLegacyFillPart(target));
-      break;
-  }
-}
-function getFitPart(transformsObj, target) {
-  const transformedData = getTransformData(transformsObj.src.width, transformsObj.src.height, transformTypes.FIT, target, transformsObj.devicePixelRatio, transformsObj.upscaleMethod);
-  const isMissingSrcDimensions = !transformsObj.src.width || !transformsObj.src.height;
-  const transformType = isMissingSrcDimensions ? transformTypes.FIT : transformTypes.FILL;
-  return {
-    transformType,
-    width: Math.round(transformedData.width),
-    height: Math.round(transformedData.height),
-    alignment: alignTypesMap.center,
-    upscale: transformedData.scaleFactor > 1,
-    forceUSM: transformedData.forceUSM,
-    scaleFactor: transformedData.scaleFactor,
-    cssUpscaleNeeded: transformedData.cssUpscaleNeeded,
-    upscaleMethodValue: transformedData.upscaleMethodValue
-  };
-}
-function getFillPart(transformsObj, target) {
-  const transformedData = getTransformData(transformsObj.src.width, transformsObj.src.height, transformTypes.FILL, target, transformsObj.devicePixelRatio, transformsObj.upscaleMethod);
-  const focalPoint = getFocalPoint(transformsObj.focalPoint);
-  const transformType = focalPoint ? transformTypes.FILL_FOCAL : transformTypes.FILL;
-  return {
-    transformType,
-    width: Math.round(transformedData.width),
-    height: Math.round(transformedData.height),
-    alignment: getAlignment(target),
-    focalPointX: focalPoint && focalPoint.x,
-    focalPointY: focalPoint && focalPoint.y,
-    upscale: transformedData.scaleFactor > 1,
-    forceUSM: transformedData.forceUSM,
-    scaleFactor: transformedData.scaleFactor,
-    cssUpscaleNeeded: transformedData.cssUpscaleNeeded,
-    upscaleMethodValue: transformedData.upscaleMethodValue
-  };
-}
-function getStretchPart(transformsObj, target) {
-  const scaleFactor = getScaleFactor(transformsObj.src.width, transformsObj.src.height, target.width, target.height, transformTypes.FILL);
-  const clonedTarget = { ...target };
-  clonedTarget.width = transformsObj.src.width * scaleFactor;
-  clonedTarget.height = transformsObj.src.height * scaleFactor;
-  return getFitPart(transformsObj, clonedTarget);
-}
-function getCropPart(rect) {
-  return {
-    transformType: transformTypes.CROP,
-    x: Math.round(rect.x),
-    y: Math.round(rect.y),
-    width: Math.round(rect.width),
-    height: Math.round(rect.height),
-    upscale: false,
-    forceUSM: false,
-    scaleFactor: 1,
-    cssUpscaleNeeded: false
-  };
-}
-function getLegacyFitPart(target) {
-  return {
-    transformType: transformTypes.FIT,
-    width: Math.round(target.width),
-    height: Math.round(target.height),
-    upscale: false,
-    forceUSM: true,
-    scaleFactor: 1,
-    cssUpscaleNeeded: false
-  };
-}
-function getLegacyFillPart(target) {
-  return {
-    transformType: transformTypes.LEGACY_FILL,
-    width: Math.round(target.width),
-    height: Math.round(target.height),
-    alignment: getAlignment(target),
-    upscale: false,
-    forceUSM: true,
-    scaleFactor: 1,
-    cssUpscaleNeeded: false
-  };
-}
-function getLegacyCropPart(target) {
-  return {
-    transformType: transformTypes.LEGACY_CROP,
-    width: Math.round(target.width),
-    height: Math.round(target.height),
-    alignment: getAlignment(target),
-    upscale: false,
-    forceUSM: false,
-    scaleFactor: 1,
-    cssUpscaleNeeded: false
-  };
-}
-function setTransformOptions(transformsObj, options) {
-  options = options || {};
-  transformsObj.quality = getQuality(transformsObj, options);
-  transformsObj.progressive = getProgressive(options);
-  transformsObj.watermark = getWatermark(options);
-  transformsObj.autoEncode = options.autoEncode ?? true;
-  transformsObj.encoding = options == null ? void 0 : options.encoding;
-  transformsObj.unsharpMask = getUnsharpMask(transformsObj, options);
-  transformsObj.filters = getFilters(options);
-}
-function getWatermark(options) {
-  return options.watermark;
-}
-function getProgressive(options) {
-  return options.progressive !== false;
-}
-function getQuality(transformsObj, options) {
-  const isPNG2 = transformsObj.fileType === fileType.PNG;
-  const isJPG2 = transformsObj.fileType === fileType.JPG;
-  const isWEBP2 = transformsObj.fileType === fileType.WEBP;
-  const isAVIF2 = transformsObj.fileType === fileType.AVIF;
-  const isQualitySupported = isJPG2 || isPNG2 || isWEBP2 || isAVIF2;
-  if (isQualitySupported) {
-    const transformData = last(transformsObj.parts);
-    const defaultQuality = getPreferredImageQuality(transformData.width, transformData.height);
-    let quality = options.quality && options.quality >= 5 && options.quality <= 90 ? options.quality : defaultQuality;
-    quality = isPNG2 ? quality + 5 : quality;
-    return quality;
-  }
-  return 0;
-}
-function getFilters(options) {
-  const filterOptions = options.filters || {};
-  const filters = {};
-  if (isValidImageFilter(filterOptions[imageFilters.CONTRAST], -100, 100)) {
-    filters[imageFilters.CONTRAST] = filterOptions[imageFilters.CONTRAST];
-  }
-  if (isValidImageFilter(filterOptions[imageFilters.BRIGHTNESS], -100, 100)) {
-    filters[imageFilters.BRIGHTNESS] = filterOptions[imageFilters.BRIGHTNESS];
-  }
-  if (isValidImageFilter(filterOptions[imageFilters.SATURATION], -100, 100)) {
-    filters[imageFilters.SATURATION] = filterOptions[imageFilters.SATURATION];
-  }
-  if (isValidImageFilter(filterOptions[imageFilters.HUE], -180, 180)) {
-    filters[imageFilters.HUE] = filterOptions[imageFilters.HUE];
-  }
-  if (isValidImageFilter(filterOptions[imageFilters.BLUR], 0, 100)) {
-    filters[imageFilters.BLUR] = filterOptions[imageFilters.BLUR];
-  }
-  return filters;
-}
-function isValidImageFilter(filterValue, minValue, maxValue) {
-  return typeof filterValue === "number" && !isNaN(filterValue) && filterValue !== 0 && filterValue >= minValue && filterValue <= maxValue;
-}
-function getUnsharpMask(transformsObj, options) {
-  var _a, _b, _c;
-  if (isUSMValid(options.unsharpMask)) {
-    return {
-      radius: roundToFixed((_a = options.unsharpMask) == null ? void 0 : _a.radius, 2),
-      amount: roundToFixed((_b = options.unsharpMask) == null ? void 0 : _b.amount, 2),
-      threshold: roundToFixed((_c = options.unsharpMask) == null ? void 0 : _c.threshold, 2)
-    };
-  } else if (!isZeroUSM(options.unsharpMask) && isUSMNeeded(transformsObj)) {
-    return defaultUSM;
-  }
-  return;
-}
-function isUSMNeeded(transformsObj) {
-  const transformPart = last(transformsObj.parts);
-  const upscale = transformPart.scaleFactor >= 1;
-  return !upscale || transformPart.forceUSM || transformPart.transformType === transformTypes.FIT;
-}
-function isUSMValid(usm) {
-  usm = usm || {};
-  const radius = typeof usm.radius === "number" && !isNaN(usm.radius) && usm.radius >= 0.1 && usm.radius <= 500;
-  const amount = typeof usm.amount === "number" && !isNaN(usm.amount) && usm.amount >= 0 && usm.amount <= 10;
-  const threshold = typeof usm.threshold === "number" && !isNaN(usm.threshold) && usm.threshold >= 0 && usm.threshold <= 255;
-  return radius && amount && threshold;
-}
-function isZeroUSM(usm) {
-  usm = usm || {};
-  return typeof usm.radius === "number" && !isNaN(usm.radius) && usm.radius === 0 && typeof usm.amount === "number" && !isNaN(usm.amount) && usm.amount === 0 && typeof usm.threshold === "number" && !isNaN(usm.threshold) && usm.threshold === 0;
-}
-function getTransform(fittingType, src, target, options) {
-  const _isSEOBot = isSEOBot(options);
-  const fileType2 = getFileType(src.id);
-  const fileName = getFileName(src.id, src.name);
-  const devicePixelRatio = _isSEOBot ? 1 : getDevicePixelRatio(target);
-  const fileExtension = getFileExtension(src.id);
-  const preferredExtension = fileExtension;
-  const canTransformImage = isImageTransformApplicable(src.id, options == null ? void 0 : options.hasAnimation, options == null ? void 0 : options.allowAnimatedTransform, options == null ? void 0 : options.allowFullGIFTransformation);
-  const transformsObj = {
-    fileName,
-    fileExtension,
-    fileType: fileType2,
-    fittingType,
-    preferredExtension,
-    src: {
-      id: src.id,
-      width: src.width,
-      height: src.height,
-      isCropped: false,
-      isAnimated: imageIsAnimated(src.id, options == null ? void 0 : options.hasAnimation)
-    },
-    focalPoint: {
-      x: src.focalPoint && src.focalPoint.x,
-      y: src.focalPoint && src.focalPoint.y
-    },
-    parts: [],
-    // options - general
-    devicePixelRatio,
-    quality: 0,
-    upscaleMethod: getUpscaleString(options),
-    progressive: true,
-    watermark: "",
-    unsharpMask: {},
-    filters: {},
-    transformed: canTransformImage,
-    allowFullGIFTransformation: options == null ? void 0 : options.allowFullGIFTransformation,
-    isPlaceholderFlow: options == null ? void 0 : options.isPlaceholderFlow
-  };
-  if (canTransformImage) {
-    setTransformParts(transformsObj, src, target);
-    setTransformOptions(transformsObj, options);
-  }
-  return transformsObj;
-}
-function getTarget(fittingType, src, target) {
-  const targetObj = { ...target };
-  const _isMobile = isMobile();
-  switch (fittingType) {
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE:
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_HORIZONTAL:
-    case fittingTypes.LEGACY_BG_FIT_AND_TILE_VERTICAL:
-    case fittingTypes.LEGACY_BG_NORMAL:
-      const maxBGSiteLegacyWidth = _isMobile ? MOBILE_MAX_BG_SITE_LEGACY_WIDTH : DSKTP_MAX_BG_SITE_LEGACY_WIDTH;
-      const maxBGSiteLegacyHeight = _isMobile ? MOBILE_MAX_BG_SITE_LEGACY_HEIGHT : DSKTP_MAX_BG_SITE_LEGACY_HEIGHT;
-      targetObj.width = Math.min(maxBGSiteLegacyWidth, src.width);
-      targetObj.height = Math.min(maxBGSiteLegacyHeight, Math.round(targetObj.width / (src.width / src.height)));
-      targetObj.pixelAspectRatio = 1;
-  }
-  return targetObj;
-}
-const fitTemplate = template`fit/w_${"width"},h_${"height"}`;
-const fillTemplate = template`fill/w_${"width"},h_${"height"},al_${"alignment"}`;
-const fillFocalTemplate = template`fill/w_${"width"},h_${"height"},fp_${"focalPointX"}_${"focalPointY"}`;
-const cropTemplate = template`crop/x_${"x"},y_${"y"},w_${"width"},h_${"height"}`;
-const legacyCropTemplate = template`crop/w_${"width"},h_${"height"},al_${"alignment"}`;
-const legacyFillTemplate = template`fill/w_${"width"},h_${"height"},al_${"alignment"}`;
-const upscaleTemplate = template`,lg_${"upscaleMethodValue"}`;
-const qualityTemplate = template`,q_${"quality"}`;
-const qualityAutoTemplate = template`,quality_auto`;
-const unSharpMaskTemplate = template`,usm_${"radius"}_${"amount"}_${"threshold"}`;
-const nonProgressiveTemplate = template`,bl`;
-const watermarkTemplate = template`,wm_${"watermark"}`;
-const filterTemplatesMap = {
-  [imageFilters.CONTRAST]: template`,con_${"contrast"}`,
-  [imageFilters.BRIGHTNESS]: template`,br_${"brightness"}`,
-  [imageFilters.SATURATION]: template`,sat_${"saturation"}`,
-  [imageFilters.HUE]: template`,hue_${"hue"}`,
-  [imageFilters.BLUR]: template`,blur_${"blur"}`
-};
-const autoEncodeTemplate = template`,enc_auto`;
-const AVIFEncodeTemplate = template`,enc_avif`;
-const pAVIFEncodeTemplate = template`,enc_pavif`;
-const animatedTransformTemplate = template`,pstr`;
-const animatedGIFTransformTemplate = template`,anm_all`;
-function getImageURI(transformsObj) {
-  var _a;
-  const transformsObjStrArr = [];
-  transformsObj.parts.forEach((transformPart) => {
-    switch (transformPart.transformType) {
-      case transformTypes.CROP:
-        transformsObjStrArr.push(cropTemplate(transformPart));
-        break;
-      case transformTypes.LEGACY_CROP:
-        transformsObjStrArr.push(legacyCropTemplate(transformPart));
-        break;
-      case transformTypes.LEGACY_FILL:
-        let legacyFillStr = legacyFillTemplate(transformPart);
-        if (transformPart.upscale) {
-          legacyFillStr += upscaleTemplate(transformPart);
-        }
-        transformsObjStrArr.push(legacyFillStr);
-        break;
-      case transformTypes.FIT:
-        let fitStr = fitTemplate(transformPart);
-        if (transformPart.upscale) {
-          fitStr += upscaleTemplate(transformPart);
-        }
-        transformsObjStrArr.push(fitStr);
-        break;
-      case transformTypes.FILL:
-        let fillStr = fillTemplate(transformPart);
-        if (transformPart.upscale) {
-          fillStr += upscaleTemplate(transformPart);
-        }
-        transformsObjStrArr.push(fillStr);
-        break;
-      case transformTypes.FILL_FOCAL:
-        let fillFocalStr = fillFocalTemplate(transformPart);
-        if (transformPart.upscale) {
-          fillFocalStr += upscaleTemplate(transformPart);
-        }
-        transformsObjStrArr.push(fillFocalStr);
-        break;
-    }
-  });
-  let transformsStr = transformsObjStrArr.join("/");
-  if (transformsObj.quality) {
-    transformsStr += qualityTemplate(transformsObj);
-  }
-  if (transformsObj.unsharpMask) {
-    transformsStr += unSharpMaskTemplate(transformsObj.unsharpMask);
-  }
-  if (!transformsObj.progressive) {
-    transformsStr += nonProgressiveTemplate(transformsObj);
-  }
-  if (transformsObj.watermark) {
-    transformsStr += watermarkTemplate(transformsObj);
-  }
-  if (transformsObj.filters) {
-    transformsStr += Object.keys(transformsObj.filters).map((filterName) => filterTemplatesMap[filterName](transformsObj.filters)).join("");
-  }
-  if (transformsObj.fileType !== fileType.GIF) {
-    if (transformsObj.encoding === encodingTypes.AVIF) {
-      transformsStr += AVIFEncodeTemplate(transformsObj);
-      transformsStr += qualityAutoTemplate(transformsObj);
-    } else if (transformsObj.encoding === encodingTypes.PAVIF) {
-      transformsStr += pAVIFEncodeTemplate(transformsObj);
-      transformsStr += qualityAutoTemplate(transformsObj);
-    } else if (transformsObj.autoEncode) {
-      transformsStr += autoEncodeTemplate(transformsObj);
-    }
-  }
-  if (((_a = transformsObj.src) == null ? void 0 : _a.isAnimated) && transformsObj.transformed) {
-    const isGif = isGIF(transformsObj.src.id);
-    const isPlaceholderFlow = transformsObj.isPlaceholderFlow === true;
-    const allowFullGIFTransformation = transformsObj.allowFullGIFTransformation === true;
-    if (isPlaceholderFlow) {
-      transformsStr += animatedTransformTemplate(transformsObj);
-    } else if (isGif && allowFullGIFTransformation) {
-      transformsStr += animatedGIFTransformTemplate(transformsObj);
-    }
-  }
-  return `${transformsObj.src.id}/${API_VERSION}/${transformsStr}/${transformsObj.fileName}.${transformsObj.preferredExtension}`;
-}
-function getURI(fittingType, src, target, options = {}, transformObj) {
-  if (isImageTransformApplicable(src.id, options == null ? void 0 : options.hasAnimation, options == null ? void 0 : options.allowAnimatedTransform, options == null ? void 0 : options.allowFullGIFTransformation)) {
-    if ((isWEBP(src.id) || isAVIF(src.id)) && !options.allowWebpAvifTransforms) {
-      const { alignment, ...transformTarget } = target;
-      src.focalPoint = { x: void 0, y: void 0 };
-      src == null ? true : delete src.crop;
-      transformObj = getTransform(fittingType, src, transformTarget, options);
-    } else {
-      transformObj = transformObj || getTransform(fittingType, src, target, options);
-    }
-    return getImageURI(transformObj);
-  }
-  return src.id;
-}
-function getSrcset(fittingType, src, target, options, data) {
-  const dpr = target.pixelAspectRatio || 1;
-  return {
-    dpr: [
-      `${dpr === 1 ? data.uri : getURI(fittingType, src, {
-        ...target,
-        pixelAspectRatio: 1
-      }, options)} 1x`,
-      `${dpr === 2 ? data.uri : getURI(fittingType, src, {
-        ...target,
-        pixelAspectRatio: 2
-      }, options)} 2x`
-    ]
-  };
-}
-const ALIGN_TYPE_TO_POSITION = {
-  [alignTypes.CENTER]: "50% 50%",
-  [alignTypes.TOP_LEFT]: "0% 0%",
-  [alignTypes.TOP_RIGHT]: "100% 0%",
-  [alignTypes.TOP]: "50% 0%",
-  [alignTypes.BOTTOM_LEFT]: "0% 100%",
-  [alignTypes.BOTTOM_RIGHT]: "100% 100%",
-  [alignTypes.BOTTOM]: "50% 100%",
-  [alignTypes.RIGHT]: "100% 50%",
-  [alignTypes.LEFT]: "0% 50%"
-};
-const POSITION_TO_ALIGN_TYPE = Object.entries(ALIGN_TYPE_TO_POSITION).reduce((acc, [align, position]) => {
-  acc[position] = align;
-  return acc;
-}, {});
-const TILE_FITTING_TYPES = [
-  fittingTypes.TILE,
-  fittingTypes.TILE_HORIZONTAL,
-  fittingTypes.TILE_VERTICAL,
-  fittingTypes.LEGACY_BG_FIT_AND_TILE,
-  fittingTypes.LEGACY_BG_FIT_AND_TILE_HORIZONTAL,
-  fittingTypes.LEGACY_BG_FIT_AND_TILE_VERTICAL
-];
-const NON_SCALING_FITTING_TYPES = [
-  fittingTypes.LEGACY_ORIGINAL_SIZE,
-  fittingTypes.ORIGINAL_SIZE,
-  fittingTypes.LEGACY_BG_NORMAL
-];
-function getIsFakeTile(fittingType, src, { width: targetWidth, height: targetHeight }) {
-  return fittingType === fittingTypes.TILE && src.width > targetWidth && src.height > targetHeight;
-}
-function getScaledDimensions(fittingType, src, { width, height }, isSEOBot2 = false) {
-  if (isSEOBot2) {
-    return { width, height };
-  }
-  const isScalable = !NON_SCALING_FITTING_TYPES.includes(fittingType);
-  const isFakeTile = getIsFakeTile(fittingType, src, { width, height });
-  const isTile = !isFakeTile && TILE_FITTING_TYPES.includes(fittingType);
-  const _width = isTile ? src.width : width;
-  const _height = isTile ? src.height : height;
-  const scaleFactor = isScalable ? getScaleFactorByWidth(_width, isPNG(src.id)) : 1;
-  return {
-    width: isFakeTile ? 1920 : _width * scaleFactor,
-    height: _height * scaleFactor
-  };
-}
-function getConvertedFitting(fittingType, isFakeTile) {
-  const isTile = TILE_FITTING_TYPES.includes(fittingType) && !isFakeTile;
-  const isFill = fittingType === fittingTypes.SCALE_TO_FILL;
-  return isFill || isTile ? fittingTypes.SCALE_TO_FIT : fittingType;
-}
-function validateTargetDimensions(src, { width, height }) {
-  if (!width || !height) {
-    const _width = width || Math.min(980, src.width);
-    const heightRatio = _width / src.width;
-    return {
-      width: _width,
-      height: height || src.height * heightRatio
-    };
-  }
-  return { width, height };
-}
-function getScaleFactorByWidth(width, isHighQuality) {
-  if (width > 900) {
-    return isHighQuality ? 0.05 : 0.15;
-  } else if (width > 500) {
-    return isHighQuality ? 0.1 : 0.18;
-  } else if (width > 200) {
-    return 0.25;
-  }
-  return 1;
-}
-function getBlurValue(width, fittingType, isSEOBot2) {
-  if (isSEOBot2) {
-    return 0;
-  }
-  if (TILE_FITTING_TYPES.includes(fittingType)) {
-    return 1;
-  }
-  if (width > 200) {
-    return 2;
-  }
-  return 3;
-}
-function getCSSOverrides(fittingType, src, target, alignment = "center") {
-  const returnValue = {
-    img: {},
-    container: {}
-  };
-  if (fittingType === fittingTypes.SCALE_TO_FILL) {
-    const alignTypeFromFocalPoint = src.focalPoint && convertFocalPointToAlignType(src.focalPoint);
-    const alignType = alignTypeFromFocalPoint || alignment;
-    if (src.focalPoint && !alignTypeFromFocalPoint) {
-      returnValue.img = {
-        objectPosition: convertFillFocalToPosition(src, target, src.focalPoint)
-      };
-    } else {
-      returnValue.img = {
-        objectPosition: ALIGN_TYPE_TO_POSITION[alignType]
-      };
-    }
-  } else if ([fittingTypes.LEGACY_ORIGINAL_SIZE, fittingTypes.ORIGINAL_SIZE].includes(fittingType)) {
-    returnValue.img = {
-      objectFit: "none",
-      top: "auto",
-      left: "auto",
-      right: "auto",
-      bottom: "auto"
-    };
-  } else if (TILE_FITTING_TYPES.includes(fittingType)) {
-    returnValue.container = {
-      backgroundSize: `${src.width}px ${src.height}px`
-    };
-  }
-  return returnValue;
-}
-function convertFocalPointToAlignType(focalPoint) {
-  const position = `${focalPoint.x}% ${focalPoint.y}%`;
-  return POSITION_TO_ALIGN_TYPE[position] || "";
-}
-function convertFillFocalToPosition(src, target, focalPoint) {
-  const { width: sW, height: sH } = src;
-  const { width: tW, height: tH } = target;
-  const { x: fpX, y: fpY } = focalPoint;
-  if (!tW || !tH) {
-    return `${fpX}% ${fpY}%`;
-  }
-  const fillScaleFactor = Math.max(tW / sW, tH / sH);
-  const imgScaledW = sW * fillScaleFactor;
-  const imgScaledH = sH * fillScaleFactor;
-  const x = Math.max(0, Math.min(imgScaledW - tW, imgScaledW * (fpX / 100) - tW / 2));
-  const y = Math.max(0, Math.min(imgScaledH - tH, imgScaledH * (fpY / 100) - tH / 2));
-  const posX = x && Math.floor(x / (imgScaledW - tW) * 100);
-  const posY = y && Math.floor(y / (imgScaledH - tH) * 100);
-  return `${posX}% ${posY}%`;
-}
-const PLACEHOLDER_IMG_CSS_OVERRIDES = { width: "100%", height: "100%" };
-function getPlaceholder(fittingType, src, target, options = {}) {
-  const { autoEncode = true, isSEOBot: isSEOBot2, shouldLoadHQImage, hasAnimation, allowAnimatedTransform, encoding } = options;
-  if (!isValidRequest(fittingType, src, target)) {
-    return emptyData;
-  }
-  const IS_IN_PLACEHOLDER_FLOW = true;
-  const shouldAllowAnimatedTransformInPlaceholder = allowAnimatedTransform ?? IS_IN_PLACEHOLDER_FLOW;
-  const canTransformImage = isImageTransformApplicable(src.id, hasAnimation, shouldAllowAnimatedTransformInPlaceholder);
-  if (!canTransformImage || shouldLoadHQImage) {
-    return getData(fittingType, src, target, {
-      ...options,
-      autoEncode,
-      useSrcset: canTransformImage
-    });
-  }
-  const newTarget = {
-    ...target,
-    ...validateTargetDimensions(src, target)
-  };
-  const { alignment, htmlTag: htmlTag2 } = newTarget;
-  const isFakeTile = getIsFakeTile(fittingType, src, newTarget);
-  const scaledDimensions = getScaledDimensions(fittingType, src, newTarget, isSEOBot2);
-  const blur = getBlurValue(newTarget.width, fittingType, isSEOBot2);
-  const convertedFittingType = getConvertedFitting(fittingType, isFakeTile);
-  const overrideCSS = getCSSOverrides(fittingType, src, target, alignment);
-  const { uri } = getData(convertedFittingType, src, {
-    ...scaledDimensions,
-    alignment,
-    htmlTag: htmlTag2
-  }, {
-    autoEncode,
-    filters: blur ? { blur } : {},
-    hasAnimation,
-    allowAnimatedTransform: shouldAllowAnimatedTransformInPlaceholder,
-    encoding,
-    isPlaceholderFlow: IS_IN_PLACEHOLDER_FLOW
-  });
-  const { attr = {}, css } = getData(fittingType, src, {
-    ...newTarget,
-    alignment,
-    htmlTag: htmlTag2
-  }, {});
-  css.img = css.img || {};
-  css.container = css.container || {};
-  Object.assign(css.img, overrideCSS.img, PLACEHOLDER_IMG_CSS_OVERRIDES);
-  Object.assign(css.container, overrideCSS.container);
-  return { uri, css, attr, transformed: true };
-}
-function getData(fittingType, src, target, options) {
-  let data = {};
-  if (isValidRequest(fittingType, src, target)) {
-    const targetObj = getTarget(fittingType, src, target);
-    const transformObj = getTransform(fittingType, src, targetObj, options);
-    data.uri = getURI(fittingType, src, targetObj, options, transformObj);
-    if (options == null ? void 0 : options.useSrcset) {
-      data.srcset = getSrcset(fittingType, src, targetObj, options, data);
-    }
-    Object.assign(data, getAttributes(transformObj, targetObj), {
-      transformed: transformObj.transformed
-    });
-  } else {
-    data = emptyData;
-  }
-  return data;
-}
-const wixStaticWithMedia = "https://static.wixstatic.com/media/";
-populateGlobalFeatureSupport();
-populateGlobalFeatureSupport();
-const STATIC_MEDIA_URL = wixStaticWithMedia;
-const imageKit = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  STATIC_MEDIA_URL,
-  alignTypes,
-  fileType,
-  fittingTypes,
-  getData,
-  getFileExtension,
-  getPlaceholder,
-  htmlTag,
-  isWEBP,
-  populateGlobalFeatureSupport,
-  upscaleMethods
-}, Symbol.toStringTag, { value: "Module" }));
+import { d as defineService } from "./index8.js";
+const RenderingContextDefinition = defineService("@wix/site-service-rendering-context");
 export {
-  STATIC_MEDIA_URL as S,
-  getData as a,
-  getFileExtension as b,
-  alignTypes as c,
-  fittingTypes as d,
-  fileType as f,
-  getPlaceholder as g,
-  imageKit as i
+  RenderingContextDefinition as R
 };