@sbb-esta/lyne-elements 4.11.0 → 5.0.0-next.1

package/development/image.component-BuAPmhIt.js

@@ -0,0 +1,772 @@
+import { a as SbbBreakpointUltraMax, c as SbbBreakpointZeroMin, i as SbbBreakpointSmallMin, n as SbbBreakpointLargeMin, o as SbbBreakpointUltraMin, r as SbbBreakpointSmallMax, s as SbbBreakpointZeroMax, t as SbbBreakpointLargeMax } from "./sbb-tokens-CGxax8uX.js";
+import { __esDecorate, __runInitializers } from "tslib";
+import { html, nothing, unsafeCSS } from "lit";
+import { eventOptions, property } from "lit/decorators.js";
+import { SbbElement, boxSizingStyles, forceType } from "./core.js";
+//#region src/elements/image/image.scss?inline
+var image_default = ":host {\n  --sbb-image-aspect-ratio: 16 / 9;\n  --sbb-image-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n  --sbb-image-object-fit: cover;\n  display: block;\n  border-radius: var(--sbb-border-radius-4x);\n}\n\n.sbb-image__img {\n  opacity: 0.000001;\n}\n:host(:is(:state(loaded),[state--loaded])) .sbb-image__img {\n  opacity: 0.999999;\n}\n:host(:not([skip-lqip])) .sbb-image__img {\n  position: absolute;\n  inset: 0;\n}\n\n:host(:is(:state(loaded),[state--loaded])) .sbb-image__blurred {\n  opacity: 0;\n}\n\npicture {\n  display: contents;\n}\n\n:is(.sbb-image__img, .sbb-image__blurred) {\n  width: 100%;\n  height: 100%;\n  object-fit: var(--sbb-image-object-fit);\n  object-position: var(--sbb-image-object-position);\n  transition: opacity var(--sbb-image-animation-duration) var(--sbb-animation-easing);\n}\n\n.sbb-image__wrapper {\n  display: flex;\n  position: relative;\n  width: 100%;\n  height: 100%;\n  aspect-ratio: var(--sbb-image-aspect-ratio);\n  border-radius: inherit;\n  overflow: hidden;\n}";
+//#endregion
+//#region src/elements/image/image.component.ts
+/**
+* we check the structure of the data manually, so it's safe to use `any` as return type
+*/
+var imageHelperGetBreakpoints = (jsonString) => {
+	if (!jsonString || jsonString.length === 0) return [];
+	const logWarning = null;
+	let jsonObject;
+	try {
+		jsonObject = JSON.parse(jsonString);
+	} catch {
+		logWarning?.();
+		return [];
+	}
+	if (!jsonObject.breakpoints || jsonObject.breakpoints.length === 0) {
+		logWarning?.();
+		return [];
+	}
+	if (!Array.isArray(jsonObject.breakpoints)) {
+		logWarning?.();
+		return [];
+	}
+	/**
+	* 1. make sure that each entry within the breakpoints object contains only allowed keys
+	* 2. make sure that all necessary keys are present
+	*/
+	let wrongKeyDetected = false;
+	let missingKeyDetected = false;
+	const allowedKeys = ["image", "mediaQueries"];
+	jsonObject.breakpoints.forEach((breakpoint) => {
+		const breakpointKeys = Object.keys(breakpoint);
+		breakpointKeys.forEach((breakpointKey) => {
+			if (!allowedKeys.includes(breakpointKey)) wrongKeyDetected = true;
+		});
+		allowedKeys.forEach((allowedKey) => {
+			if (!breakpointKeys.includes(allowedKey)) missingKeyDetected = true;
+		});
+	});
+	if (wrongKeyDetected || missingKeyDetected) {
+		logWarning?.();
+		return [];
+	}
+	return jsonObject.breakpoints;
+};
+var eventListenerOptions = { passive: true };
+var breakpointMap = {
+	"sbb-breakpoint-zero-min": SbbBreakpointZeroMin,
+	"sbb-breakpoint-zero-max": SbbBreakpointZeroMax,
+	"sbb-breakpoint-small-min": SbbBreakpointSmallMin,
+	"sbb-breakpoint-small-max": SbbBreakpointSmallMax,
+	"sbb-breakpoint-large-min": SbbBreakpointLargeMin,
+	"sbb-breakpoint-large-max": SbbBreakpointLargeMax,
+	"sbb-breakpoint-ultra-min": SbbBreakpointUltraMin,
+	"sbb-breakpoint-ultra-max": SbbBreakpointUltraMax
+};
+/**
+* It displays an image.
+*
+* @cssprop [--sbb-image-aspect-ratio=auto] - Can be used to override `aspectRatio` property.
+* This way we can have, for example, an image component with an aspect
+* ratio of 4/3 in smaller viewports and 16/9 in larger viewports.
+* @cssprop [--sbb-image-object-position] - Can be used to set the object-position CSS property of the image itself if the image itself is cropped.
+* @cssprop [--sbb-image-object-fit=cover] - Can be used to set the object-fit CSS property of the image itself if the image itself is cropped.
+*/
+var SbbImageElement = (() => {
+	let _classSuper = SbbElement;
+	let _instanceExtraInitializers = [];
+	let _alt_decorators;
+	let _alt_initializers = [];
+	let _alt_extraInitializers = [];
+	let _skipLqip_decorators;
+	let _skipLqip_initializers = [];
+	let _skipLqip_extraInitializers = [];
+	let _customFocalPoint_decorators;
+	let _customFocalPoint_initializers = [];
+	let _customFocalPoint_extraInitializers = [];
+	let _decoding_decorators;
+	let _decoding_initializers = [];
+	let _decoding_extraInitializers = [];
+	let _focalPointDebug_decorators;
+	let _focalPointDebug_initializers = [];
+	let _focalPointDebug_extraInitializers = [];
+	let _focalPointX_decorators;
+	let _focalPointX_initializers = [];
+	let _focalPointX_extraInitializers = [];
+	let _focalPointY_decorators;
+	let _focalPointY_initializers = [];
+	let _focalPointY_extraInitializers = [];
+	let _imageSrc_decorators;
+	let _imageSrc_initializers = [];
+	let _imageSrc_extraInitializers = [];
+	let _importance_decorators;
+	let _importance_initializers = [];
+	let _importance_extraInitializers = [];
+	let _loading_decorators;
+	let _loading_initializers = [];
+	let _loading_extraInitializers = [];
+	let _performanceMark_decorators;
+	let _performanceMark_initializers = [];
+	let _performanceMark_extraInitializers = [];
+	let _pictureSizesConfig_decorators;
+	let _pictureSizesConfig_initializers = [];
+	let _pictureSizesConfig_extraInitializers = [];
+	let __imageLoaded_decorators;
+	return class SbbImageElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_alt_decorators = [forceType(), property()];
+			_skipLqip_decorators = [forceType(), property({
+				attribute: "skip-lqip",
+				type: Boolean,
+				reflect: true
+			})];
+			_customFocalPoint_decorators = [forceType(), property({
+				attribute: "custom-focal-point",
+				type: Boolean
+			})];
+			_decoding_decorators = [property()];
+			_focalPointDebug_decorators = [forceType(), property({
+				attribute: "focal-point-debug",
+				type: Boolean
+			})];
+			_focalPointX_decorators = [forceType(), property({
+				attribute: "focal-point-x",
+				type: Number
+			})];
+			_focalPointY_decorators = [forceType(), property({
+				attribute: "focal-point-y",
+				type: Number
+			})];
+			_imageSrc_decorators = [forceType(), property({ attribute: "image-src" })];
+			_importance_decorators = [property()];
+			_loading_decorators = [property()];
+			_performanceMark_decorators = [forceType(), property({ attribute: "performance-mark" })];
+			_pictureSizesConfig_decorators = [forceType(), property({ attribute: "picture-sizes-config" })];
+			__imageLoaded_decorators = [eventOptions(eventListenerOptions)];
+			__esDecorate(this, null, _alt_decorators, {
+				kind: "accessor",
+				name: "alt",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "alt" in obj,
+					get: (obj) => obj.alt,
+					set: (obj, value) => {
+						obj.alt = value;
+					}
+				},
+				metadata: _metadata
+			}, _alt_initializers, _alt_extraInitializers);
+			__esDecorate(this, null, _skipLqip_decorators, {
+				kind: "accessor",
+				name: "skipLqip",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "skipLqip" in obj,
+					get: (obj) => obj.skipLqip,
+					set: (obj, value) => {
+						obj.skipLqip = value;
+					}
+				},
+				metadata: _metadata
+			}, _skipLqip_initializers, _skipLqip_extraInitializers);
+			__esDecorate(this, null, _customFocalPoint_decorators, {
+				kind: "accessor",
+				name: "customFocalPoint",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "customFocalPoint" in obj,
+					get: (obj) => obj.customFocalPoint,
+					set: (obj, value) => {
+						obj.customFocalPoint = value;
+					}
+				},
+				metadata: _metadata
+			}, _customFocalPoint_initializers, _customFocalPoint_extraInitializers);
+			__esDecorate(this, null, _decoding_decorators, {
+				kind: "accessor",
+				name: "decoding",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "decoding" in obj,
+					get: (obj) => obj.decoding,
+					set: (obj, value) => {
+						obj.decoding = value;
+					}
+				},
+				metadata: _metadata
+			}, _decoding_initializers, _decoding_extraInitializers);
+			__esDecorate(this, null, _focalPointDebug_decorators, {
+				kind: "accessor",
+				name: "focalPointDebug",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "focalPointDebug" in obj,
+					get: (obj) => obj.focalPointDebug,
+					set: (obj, value) => {
+						obj.focalPointDebug = value;
+					}
+				},
+				metadata: _metadata
+			}, _focalPointDebug_initializers, _focalPointDebug_extraInitializers);
+			__esDecorate(this, null, _focalPointX_decorators, {
+				kind: "accessor",
+				name: "focalPointX",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "focalPointX" in obj,
+					get: (obj) => obj.focalPointX,
+					set: (obj, value) => {
+						obj.focalPointX = value;
+					}
+				},
+				metadata: _metadata
+			}, _focalPointX_initializers, _focalPointX_extraInitializers);
+			__esDecorate(this, null, _focalPointY_decorators, {
+				kind: "accessor",
+				name: "focalPointY",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "focalPointY" in obj,
+					get: (obj) => obj.focalPointY,
+					set: (obj, value) => {
+						obj.focalPointY = value;
+					}
+				},
+				metadata: _metadata
+			}, _focalPointY_initializers, _focalPointY_extraInitializers);
+			__esDecorate(this, null, _imageSrc_decorators, {
+				kind: "accessor",
+				name: "imageSrc",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "imageSrc" in obj,
+					get: (obj) => obj.imageSrc,
+					set: (obj, value) => {
+						obj.imageSrc = value;
+					}
+				},
+				metadata: _metadata
+			}, _imageSrc_initializers, _imageSrc_extraInitializers);
+			__esDecorate(this, null, _importance_decorators, {
+				kind: "accessor",
+				name: "importance",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "importance" in obj,
+					get: (obj) => obj.importance,
+					set: (obj, value) => {
+						obj.importance = value;
+					}
+				},
+				metadata: _metadata
+			}, _importance_initializers, _importance_extraInitializers);
+			__esDecorate(this, null, _loading_decorators, {
+				kind: "accessor",
+				name: "loading",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "loading" in obj,
+					get: (obj) => obj.loading,
+					set: (obj, value) => {
+						obj.loading = value;
+					}
+				},
+				metadata: _metadata
+			}, _loading_initializers, _loading_extraInitializers);
+			__esDecorate(this, null, _performanceMark_decorators, {
+				kind: "accessor",
+				name: "performanceMark",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "performanceMark" in obj,
+					get: (obj) => obj.performanceMark,
+					set: (obj, value) => {
+						obj.performanceMark = value;
+					}
+				},
+				metadata: _metadata
+			}, _performanceMark_initializers, _performanceMark_extraInitializers);
+			__esDecorate(this, null, _pictureSizesConfig_decorators, {
+				kind: "accessor",
+				name: "pictureSizesConfig",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "pictureSizesConfig" in obj,
+					get: (obj) => obj.pictureSizesConfig,
+					set: (obj, value) => {
+						obj.pictureSizesConfig = value;
+					}
+				},
+				metadata: _metadata
+			}, _pictureSizesConfig_initializers, _pictureSizesConfig_extraInitializers);
+			__esDecorate(this, null, __imageLoaded_decorators, {
+				kind: "method",
+				name: "_imageLoaded",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_imageLoaded" in obj,
+					get: (obj) => obj._imageLoaded
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-image";
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(image_default)];
+		}
+		static {
+			this.events = {
+				error: "error",
+				load: "load"
+			};
+		}
+		#alt_accessor_storage;
+		/**
+		* An alt text is not always necessary (e.g. in teaser cards when
+		* additional link text is provided). In this case we can leave
+		* the value of the alt attribute blank, but the attribute itself
+		* still needs to be present. That way we can signal assistive
+		* technology, that they can skip the image.
+		*/
+		get alt() {
+			return this.#alt_accessor_storage;
+		}
+		set alt(value) {
+			this.#alt_accessor_storage = value;
+		}
+		#skipLqip_accessor_storage;
+		/**
+		* If set to false, we show a blurred version of the image as
+		* placeholder before the actual image shows up. This will help
+		* to improve the perceived loading performance. Read more about
+		* the idea of lqip here:
+		* https://medium.com/@imgix/lqip-your-images-for-fast-loading-2523d9ee4a62
+		*/
+		get skipLqip() {
+			return this.#skipLqip_accessor_storage;
+		}
+		set skipLqip(value) {
+			this.#skipLqip_accessor_storage = value;
+		}
+		#customFocalPoint_accessor_storage;
+		/**
+		* Set this to true, if you want to pass a custom focal point
+		* for the image. See full documentation here:
+		* https://docs.imgix.com/apis/rendering/focalpoint-crop
+		*/
+		get customFocalPoint() {
+			return this.#customFocalPoint_accessor_storage;
+		}
+		set customFocalPoint(value) {
+			this.#customFocalPoint_accessor_storage = value;
+		}
+		#decoding_accessor_storage;
+		/**
+		* If the lazy property is set to true, the module will automatically
+		* change the decoding to async, otherwise the decoding is set to auto
+		* which leaves the handling up to the browser. Read more about the
+		* decoding attribute here:
+		* https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decoding
+		*/
+		get decoding() {
+			return this.#decoding_accessor_storage;
+		}
+		set decoding(value) {
+			this.#decoding_accessor_storage = value;
+		}
+		#focalPointDebug_accessor_storage;
+		/**
+		* Set this to true, to receive visual guidance where the custom focal
+		* point is currently set.
+		*/
+		get focalPointDebug() {
+			return this.#focalPointDebug_accessor_storage;
+		}
+		set focalPointDebug(value) {
+			this.#focalPointDebug_accessor_storage = value;
+		}
+		#focalPointX_accessor_storage;
+		/**
+		* Pass in a floating number between 0 (left) and 1 (right).
+		*/
+		get focalPointX() {
+			return this.#focalPointX_accessor_storage;
+		}
+		set focalPointX(value) {
+			this.#focalPointX_accessor_storage = value;
+		}
+		#focalPointY_accessor_storage;
+		/**
+		* Pass in a floating number between 0 (top) and 1 (bottom).
+		*/
+		get focalPointY() {
+			return this.#focalPointY_accessor_storage;
+		}
+		set focalPointY(value) {
+			this.#focalPointY_accessor_storage = value;
+		}
+		#imageSrc_accessor_storage;
+		/**
+		* Right now the module is heavily coupled with the image delivery
+		* service imgix and depends on the original files being stored
+		* inside AEM. You can pass in any https://cdn.img.sbb.ch img
+		* src address you find on sbb.ch to play around with it. Just
+		* strip the url parameters and paste in the plain file address.
+		* If you want to know how to best work with this module with
+		* images coming from a different source, please contact the
+		* LYNE Core Team.
+		*/
+		get imageSrc() {
+			return this.#imageSrc_accessor_storage;
+		}
+		set imageSrc(value) {
+			this.#imageSrc_accessor_storage = value;
+		}
+		#importance_accessor_storage;
+		/**
+		* The importance attribute is fairly new attribute which should
+		* help the browser decide which resources it should prioritise
+		* during page load. We will set the attribute value based on the
+		* value, we receive in the loading attribute. 'eager', which we use
+		* for the largest image within the initial viewport, will set the
+		* attribute value to 'high'. 'lazy', which we use for images below
+		* the fold, will set the attribute value to 'low'.
+		*/
+		get importance() {
+			return this.#importance_accessor_storage;
+		}
+		set importance(value) {
+			this.#importance_accessor_storage = value;
+		}
+		#loading_accessor_storage;
+		/**
+		* With the support of native image lazy loading, we can now
+		* decide whether we want to load the image immediately or only
+		* once it is close to the visible viewport. The value eager is
+		* best used for images within the initial viewport. We want to
+		* load these images as fast as possible to improve the Core Web
+		* Vitals values. lazy on the other hand works best for images
+		* which are further down the page or invisible during the loading
+		* of the initial viewport.
+		*/
+		get loading() {
+			return this.#loading_accessor_storage;
+		}
+		set loading(value) {
+			this.#loading_accessor_storage = value;
+		}
+		#performanceMark_accessor_storage;
+		/**
+		* With `performance.mark` you can log a timestamp associated with
+		* the name you define in performanceMark when a certain event is
+		* happening. In our case we will log the `performance.mark` into
+		* the PerformanceEntry API once the image is fully loaded.
+		* Performance monitoring tools like SpeedCurve or Lighthouse are
+		* then able to grab these entries from the PerformanceEntry API
+		* and give us additional information and insights about our page
+		* loading behavior. We are then also able to monitor these
+		* values over a long period to see if our performance
+		* increases or decreases over time. Best to use lowercase strings
+		* here, separate words with underscores or dashes.
+		*/
+		get performanceMark() {
+			return this.#performanceMark_accessor_storage;
+		}
+		set performanceMark(value) {
+			this.#performanceMark_accessor_storage = value;
+		}
+		#pictureSizesConfig_accessor_storage;
+		/**
+		* With the pictureSizesConfig object, you can pass in information
+		* into image about what kind of source elements should get
+		* rendered. mediaQueries accepts multiple Media Query entries
+		* which can get combined by defining a conditionOperator.
+		* Type is: stringified InterfaceImageAttributesSizesConfig-Object
+		* An example could look like this:
+		* {
+		*    "breakpoints": [
+		*      {
+		*        "image": {
+		*          "height": "675",
+		*          "width": "1200"
+		*        },
+		*        "mediaQueries": [
+		*          {
+		*            "conditionFeature": "min-width",
+		*            "conditionFeatureValue": {
+		*              "lyneDesignToken": true,
+		*              "value": "sbb-breakpoint-large-min"
+		*            },
+		*            "conditionOperator": false
+		*          }
+		*        ]
+		*      },
+		*      {
+		*        "image": {
+		*          "height": "549",
+		*          "width": "976"
+		*        },
+		*        "mediaQueries": [
+		*          {
+		*            "conditionFeature": "min-width",
+		*            "conditionFeatureValue": {
+		*              "lyneDesignToken": true,
+		*              "value": "sbb-breakpoint-small-min"
+		*            },
+		*            "conditionOperator": false
+		*          }
+		*        ]
+		*      },
+		*      {
+		*        "image": {
+		*          "height": "180",
+		*          "width": "320"
+		*        },
+		*        "mediaQueries": [
+		*          {
+		*            "conditionFeature": "max-width",
+		*            "conditionFeatureValue": {
+		*              "lyneDesignToken": true,
+		*              "value": "sbb-breakpoint-small-max"
+		*            },
+		*            "conditionOperator": "and"
+		*          },
+		*          {
+		*            "conditionFeature": "orientation",
+		*            "conditionFeatureValue": {
+		*              "lyneDesignToken": false,
+		*              "value": "landscape"
+		*            },
+		*            "conditionOperator": false
+		*          }
+		*        ]
+		*      }
+		*    ]
+		*  }
+		*/
+		get pictureSizesConfig() {
+			return this.#pictureSizesConfig_accessor_storage;
+		}
+		set pictureSizesConfig(value) {
+			this.#pictureSizesConfig_accessor_storage = value;
+		}
+		/** Whether the image is finished loading or failed to load. */
+		get complete() {
+			return this.shadowRoot?.querySelector?.(".sbb-image__img")?.complete ?? false;
+		}
+		updated(changedProperties) {
+			super.updated(changedProperties);
+			if (!this._captionElement) return;
+			this._linksInCaption = this._captionElement.querySelectorAll("a");
+			if (!this._linksInCaption) return;
+			this._addFocusAbilityToLinksInCaption();
+		}
+		_logPerformanceMarks() {
+			if (this.performanceMark) {
+				performance.clearMarks(this.performanceMark);
+				performance.mark(this.performanceMark);
+			}
+		}
+		_addFocusAbilityToLinksInCaption() {
+			this._linksInCaption?.forEach((link) => {
+				link.removeAttribute("tabindex");
+			});
+		}
+		_prepareImageUrl(baseUrl, lquip = false) {
+			if (!baseUrl || baseUrl === "") return "";
+			const isFullyQualifiedUrl = !!baseUrl.match(/^\w+:\/\//);
+			const imageUrlObj = isFullyQualifiedUrl ? new URL(baseUrl) : new URL(`http://noop/${baseUrl}`);
+			if (lquip) {
+				imageUrlObj.searchParams.append("blur", "100");
+				imageUrlObj.searchParams.append("w", "100");
+				imageUrlObj.searchParams.append("h", "56");
+			} else imageUrlObj.searchParams.append("auto", "format,compress,cs=tinysrgb");
+			if (this.customFocalPoint) {
+				imageUrlObj.searchParams.append("fit", "crop");
+				imageUrlObj.searchParams.append("crop", "focalpoint");
+				imageUrlObj.searchParams.append("fp-x", this.focalPointX.toString(10));
+				imageUrlObj.searchParams.append("fp-y", this.focalPointY.toString(10));
+				imageUrlObj.searchParams.append("fp-z", "1");
+			}
+			if (this.focalPointDebug) imageUrlObj.searchParams.append("fp-debug", "true");
+			return isFullyQualifiedUrl ? imageUrlObj.href : imageUrlObj.pathname.substring(1) + imageUrlObj.search;
+		}
+		_preparePictureSizeConfigs() {
+			let pictureSizesConfig;
+			if (this.pictureSizesConfig) pictureSizesConfig = this.pictureSizesConfig;
+			else pictureSizesConfig = `{
+        "breakpoints": [
+          {
+            "image": {
+              "height": 675,
+              "width": 1200
+            },
+            "mediaQueries": [
+              {
+                "conditionFeature": "min-width",
+                "conditionFeatureValue": {
+                  "lyneDesignToken": true,
+                  "value": "sbb-breakpoint-large-min"
+                },
+                "conditionOperator": false
+              }
+            ]
+          },
+          {
+            "image": {
+              "height": 549,
+              "width": 976
+            },
+            "mediaQueries": [
+              {
+                "conditionFeature": "min-width",
+                "conditionFeatureValue": {
+                  "lyneDesignToken": true,
+                  "value": "sbb-breakpoint-small-min"
+                },
+                "conditionOperator": false
+              }
+            ]
+          },
+          {
+            "image": {
+              "height": 180,
+              "width": 320
+            },
+            "mediaQueries": [
+              {
+                "conditionFeature": "max-width",
+                "conditionFeatureValue": {
+                  "lyneDesignToken": true,
+                  "value": "sbb-breakpoint-zero-max"
+                },
+                "conditionOperator": false
+              }
+            ]
+          }
+        ]
+      }`;
+			return imageHelperGetBreakpoints(pictureSizesConfig);
+		}
+		_createMediaQueryString(mediaQueries) {
+			let mediaQuery = "";
+			mediaQueries.forEach((mq) => {
+				const mqCondition = mq.conditionFeature;
+				let mqValue;
+				if (mq.conditionFeatureValue.lyneDesignToken) mqValue = breakpointMap[mq.conditionFeatureValue.value] ?? "";
+				else mqValue = mq.conditionFeatureValue.value;
+				const mqCombiner = mq.conditionOperator ? ` ${mq.conditionOperator} ` : "";
+				mediaQuery += `(${mqCondition}: ${mqValue})${mqCombiner}`;
+			});
+			return mediaQuery;
+		}
+		_imageLoaded() {
+			this._logPerformanceMarks();
+			this.internals.states.add("loaded");
+			/** Emits each time an image loads. E.g. loading image for a different viewport, triggers the load event again. */
+			this.dispatchEvent(new Event("load"));
+		}
+		render() {
+			const imageUrlLQIP = this._prepareImageUrl(this.imageSrc, true);
+			const imageUrlWithParams = this._prepareImageUrl(this.imageSrc, false);
+			if (this.loading === "lazy") {
+				this.decoding = "async";
+				this.importance = "low";
+			}
+			const pictureSizeConfigs = this._preparePictureSizeConfigs();
+			/**
+			* The alt attribute should always be present for the img element.
+			* If it has an empty string as its value, it is simply ignored
+			* by assistive technologies. If we leave it out completely,
+			* they might try to interpret the img element.
+			*/
+			return html`
+      <div class="sbb-image__wrapper">
+        ${!this.skipLqip ? html`<img
+              alt=""
+              class="sbb-image__blurred"
+              src=${imageUrlLQIP}
+              width="1000"
+              height="562"
+              loading=${this.loading ?? nothing}
+              decoding=${this.decoding ?? nothing}
+            />` : nothing}
+
+        <picture>
+          <!-- render picture element sources -->
+          ${pictureSizeConfigs.map((config) => {
+				const imageHeight = config.image.height;
+				const imageWidth = config.image.width;
+				return html`
+              <source
+                media=${`${this._createMediaQueryString(config.mediaQueries)}`}
+                sizes=${`${imageWidth}px`}
+                srcset=${`${imageUrlWithParams}&w=${imageWidth}&h=${imageHeight}&q=${this._config.nonRetinaQuality} ${imageWidth}w, ${imageUrlWithParams}&w=${imageWidth * 2}&h=${imageHeight * 2}&q=${this._config.retinaQuality} ${imageWidth * 2}w`}
+              ></source>`;
+			})}
+          <img
+            alt=${this.alt || ""}
+            @load=${this._imageLoaded}
+            @error=${() => {
+				/** Emits when the image loading ended in an error. */
+				return this.dispatchEvent(new Event("error"));
+			}}
+            class="sbb-image__img"
+            src=${this.imageSrc}
+            width="1000"
+            height="562"
+            loading=${this.loading ?? nothing}
+            decoding=${this.decoding ?? nothing}
+            .fetchPriority=${this.importance ?? nothing}
+          />
+        </picture>
+      </div>
+    `;
+		}
+		constructor() {
+			super(...arguments);
+			this._captionElement = __runInitializers(this, _instanceExtraInitializers);
+			this._config = {
+				nonRetinaQuality: "45",
+				retinaQuality: "20"
+			};
+			this.#alt_accessor_storage = __runInitializers(this, _alt_initializers, "");
+			this.#skipLqip_accessor_storage = (__runInitializers(this, _alt_extraInitializers), __runInitializers(this, _skipLqip_initializers, false));
+			this.#customFocalPoint_accessor_storage = (__runInitializers(this, _skipLqip_extraInitializers), __runInitializers(this, _customFocalPoint_initializers, false));
+			this.#decoding_accessor_storage = (__runInitializers(this, _customFocalPoint_extraInitializers), __runInitializers(this, _decoding_initializers, "auto"));
+			this.#focalPointDebug_accessor_storage = (__runInitializers(this, _decoding_extraInitializers), __runInitializers(this, _focalPointDebug_initializers, false));
+			this.#focalPointX_accessor_storage = (__runInitializers(this, _focalPointDebug_extraInitializers), __runInitializers(this, _focalPointX_initializers, 1));
+			this.#focalPointY_accessor_storage = (__runInitializers(this, _focalPointX_extraInitializers), __runInitializers(this, _focalPointY_initializers, 1));
+			this.#imageSrc_accessor_storage = (__runInitializers(this, _focalPointY_extraInitializers), __runInitializers(this, _imageSrc_initializers, ""));
+			this.#importance_accessor_storage = (__runInitializers(this, _imageSrc_extraInitializers), __runInitializers(this, _importance_initializers, "high"));
+			this.#loading_accessor_storage = (__runInitializers(this, _importance_extraInitializers), __runInitializers(this, _loading_initializers, "eager"));
+			this.#performanceMark_accessor_storage = (__runInitializers(this, _loading_extraInitializers), __runInitializers(this, _performanceMark_initializers, ""));
+			this.#pictureSizesConfig_accessor_storage = (__runInitializers(this, _performanceMark_extraInitializers), __runInitializers(this, _pictureSizesConfig_initializers, ""));
+			__runInitializers(this, _pictureSizesConfig_extraInitializers);
+		}
+	};
+})();
+//#endregion
+export { SbbImageElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"image.component-BuAPmhIt.js","names":[],"sources":["../../../src/elements/image/image.scss?inline","../../../src/elements/image/image.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  --sbb-image-aspect-ratio: 16 / 9;\n  --sbb-image-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n  --sbb-image-object-fit: cover;\n\n  display: block;\n  border-radius: var(--sbb-border-radius-4x);\n}\n\n.sbb-image__img {\n  opacity: 0.000001;\n\n  :host(:state(loaded)) & {\n    opacity: 0.999999;\n  }\n\n  :host(:not([skip-lqip])) & {\n    position: absolute;\n    inset: 0;\n  }\n}\n\n.sbb-image__blurred {\n  :host(:state(loaded)) & {\n    opacity: 0;\n  }\n}\n\n// Avoids unwanted space or small cropping\npicture {\n  display: contents;\n}\n\n// After successful loading an image, the loaded image is faded in over the blurred lqip image with a short transition.\n// To support transparent images, we need also to fade out the blurred lqip image.\n// This is not perfect in the case of a non transparent image, but does not look that bad.\n:is(.sbb-image__img, .sbb-image__blurred) {\n  width: 100%;\n  height: 100%;\n  object-fit: var(--sbb-image-object-fit);\n  object-position: var(--sbb-image-object-position);\n  transition: opacity var(--sbb-image-animation-duration) var(--sbb-animation-easing);\n}\n\n.sbb-image__wrapper {\n  display: flex;\n  position: relative;\n  width: 100%;\n  height: 100%;\n  aspect-ratio: var(--sbb-image-aspect-ratio);\n  border-radius: inherit;\n  overflow: hidden;\n}\n","import {\n  SbbBreakpointLargeMax,\n  SbbBreakpointLargeMin,\n  SbbBreakpointSmallMax,\n  SbbBreakpointSmallMin,\n  SbbBreakpointUltraMax,\n  SbbBreakpointUltraMin,\n  SbbBreakpointZeroMax,\n  SbbBreakpointZeroMin,\n} from '@sbb-esta/lyne-design-tokens';\nimport {\n  type CSSResultGroup,\n  html,\n  nothing,\n  type PropertyValues,\n  type TemplateResult,\n  unsafeCSS,\n} from 'lit';\nimport { eventOptions, property } from 'lit/decorators.js';\n\nimport { boxSizingStyles, forceType, SbbElement } from '../core.ts';\n\nimport style from './image.scss?inline';\n\nexport interface InterfaceImageAttributesSizesConfig {\n  breakpoints: InterfaceImageAttributesSizesConfigBreakpoint[];\n}\n\nexport interface InterfaceImageAttributesSizesConfigBreakpoint {\n  image: {\n    height: number;\n    width: number;\n  };\n  mediaQueries: InterfaceImageAttributesSizesConfigMediaQuery[];\n}\n\nexport interface InterfaceImageAttributesSizesConfigMediaQuery {\n  conditionFeature: string;\n  conditionFeatureValue: {\n    lyneDesignToken: boolean;\n    value: string;\n  };\n  conditionOperator: false;\n}\n\n/**\n * we check the structure of the data manually, so it's safe to use `any` as return type\n */\nconst imageHelperGetBreakpoints = (\n  jsonString: string,\n): InterfaceImageAttributesSizesConfigBreakpoint[] => {\n  if (!jsonString || jsonString.length === 0) {\n    return [];\n  }\n\n  // make sure that we have `breakpoints` key in object\n  const logWarning = import.meta.env.DEV\n    ? () =>\n        console.warn(\n          'sbb-image error: attribute breakpoints has wrong data format. Reference the documentation to see how you should format the data for this attribute.',\n        )\n    : null;\n  let jsonObject: InterfaceImageAttributesSizesConfig;\n\n  try {\n    jsonObject = JSON.parse(jsonString);\n  } catch {\n    logWarning?.();\n    return [];\n  }\n\n  if (!jsonObject.breakpoints || jsonObject.breakpoints.length === 0) {\n    logWarning?.();\n    return [];\n  }\n\n  // make sure we get an array of breakpoints\n  if (!Array.isArray(jsonObject.breakpoints)) {\n    logWarning?.();\n    return [];\n  }\n\n  /**\n   * 1. make sure that each entry within the breakpoints object contains only allowed keys\n   * 2. make sure that all necessary keys are present\n   */\n  let wrongKeyDetected = false;\n  let missingKeyDetected = false;\n\n  const allowedKeys = ['image', 'mediaQueries'];\n\n  jsonObject.breakpoints.forEach((breakpoint) => {\n    const breakpointKeys = Object.keys(breakpoint);\n\n    breakpointKeys.forEach((breakpointKey) => {\n      if (!allowedKeys.includes(breakpointKey)) {\n        wrongKeyDetected = true;\n      }\n    });\n\n    allowedKeys.forEach((allowedKey) => {\n      if (!breakpointKeys.includes(allowedKey)) {\n        missingKeyDetected = true;\n      }\n    });\n  });\n\n  if (wrongKeyDetected || missingKeyDetected) {\n    logWarning?.();\n    return [];\n  }\n\n  return jsonObject.breakpoints;\n};\n\nconst eventListenerOptions = {\n  passive: true,\n};\n\nconst breakpointMap: Record<string, string> = {\n  'sbb-breakpoint-zero-min': SbbBreakpointZeroMin,\n  'sbb-breakpoint-zero-max': SbbBreakpointZeroMax,\n  'sbb-breakpoint-small-min': SbbBreakpointSmallMin,\n  'sbb-breakpoint-small-max': SbbBreakpointSmallMax,\n  'sbb-breakpoint-large-min': SbbBreakpointLargeMin,\n  'sbb-breakpoint-large-max': SbbBreakpointLargeMax,\n  'sbb-breakpoint-ultra-min': SbbBreakpointUltraMin,\n  'sbb-breakpoint-ultra-max': SbbBreakpointUltraMax,\n};\n\n/**\n * It displays an image.\n *\n * @cssprop [--sbb-image-aspect-ratio=auto] - Can be used to override `aspectRatio` property.\n * This way we can have, for example, an image component with an aspect\n * ratio of 4/3 in smaller viewports and 16/9 in larger viewports.\n * @cssprop [--sbb-image-object-position] - Can be used to set the object-position CSS property of the image itself if the image itself is cropped.\n * @cssprop [--sbb-image-object-fit=cover] - Can be used to set the object-fit CSS property of the image itself if the image itself is cropped.\n */\nexport class SbbImageElement extends SbbElement {\n  public static override readonly elementName: string = 'sbb-image';\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n  public static readonly events = {\n    error: 'error',\n    load: 'load',\n  } as const;\n\n  private _captionElement?: HTMLElement;\n  private _linksInCaption?: NodeListOf<HTMLLinkElement>;\n  private _config = {\n    nonRetinaQuality: '45',\n    retinaQuality: '20',\n  };\n\n  /**\n   * An alt text is not always necessary (e.g. in teaser cards when\n   * additional link text is provided). In this case we can leave\n   * the value of the alt attribute blank, but the attribute itself\n   * still needs to be present. That way we can signal assistive\n   * technology, that they can skip the image.\n   */\n  @forceType()\n  @property()\n  public accessor alt: string = '';\n\n  /**\n   * If set to false, we show a blurred version of the image as\n   * placeholder before the actual image shows up. This will help\n   * to improve the perceived loading performance. Read more about\n   * the idea of lqip here:\n   * https://medium.com/@imgix/lqip-your-images-for-fast-loading-2523d9ee4a62\n   */\n  @forceType()\n  @property({ attribute: 'skip-lqip', type: Boolean, reflect: true })\n  public accessor skipLqip: boolean = false;\n\n  /**\n   * Set this to true, if you want to pass a custom focal point\n   * for the image. See full documentation here:\n   * https://docs.imgix.com/apis/rendering/focalpoint-crop\n   */\n  @forceType()\n  @property({ attribute: 'custom-focal-point', type: Boolean })\n  public accessor customFocalPoint: boolean = false;\n\n  /**\n   * If the lazy property is set to true, the module will automatically\n   * change the decoding to async, otherwise the decoding is set to auto\n   * which leaves the handling up to the browser. Read more about the\n   * decoding attribute here:\n   * https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decoding\n   */\n  @property() public accessor decoding: 'sync' | 'async' | 'auto' = 'auto';\n\n  /**\n   * Set this to true, to receive visual guidance where the custom focal\n   * point is currently set.\n   */\n  @forceType()\n  @property({ attribute: 'focal-point-debug', type: Boolean })\n  public accessor focalPointDebug: boolean = false;\n\n  /**\n   * Pass in a floating number between 0 (left) and 1 (right).\n   */\n  @forceType()\n  @property({ attribute: 'focal-point-x', type: Number })\n  public accessor focalPointX: number = 1;\n\n  /**\n   * Pass in a floating number between 0 (top) and 1 (bottom).\n   */\n  @forceType()\n  @property({ attribute: 'focal-point-y', type: Number })\n  public accessor focalPointY: number = 1;\n\n  /**\n   * Right now the module is heavily coupled with the image delivery\n   * service imgix and depends on the original files being stored\n   * inside AEM. You can pass in any https://cdn.img.sbb.ch img\n   * src address you find on sbb.ch to play around with it. Just\n   * strip the url parameters and paste in the plain file address.\n   * If you want to know how to best work with this module with\n   * images coming from a different source, please contact the\n   * LYNE Core Team.\n   */\n  @forceType()\n  @property({ attribute: 'image-src' })\n  public accessor imageSrc: string = '';\n\n  /**\n   * The importance attribute is fairly new attribute which should\n   * help the browser decide which resources it should prioritise\n   * during page load. We will set the attribute value based on the\n   * value, we receive in the loading attribute. 'eager', which we use\n   * for the largest image within the initial viewport, will set the\n   * attribute value to 'high'. 'lazy', which we use for images below\n   * the fold, will set the attribute value to 'low'.\n   */\n  @property() public accessor importance: 'auto' | 'high' | 'low' = 'high';\n\n  /**\n   * With the support of native image lazy loading, we can now\n   * decide whether we want to load the image immediately or only\n   * once it is close to the visible viewport. The value eager is\n   * best used for images within the initial viewport. We want to\n   * load these images as fast as possible to improve the Core Web\n   * Vitals values. lazy on the other hand works best for images\n   * which are further down the page or invisible during the loading\n   * of the initial viewport.\n   */\n  @property() public accessor loading: 'eager' | 'lazy' = 'eager';\n\n  /**\n   * With `performance.mark` you can log a timestamp associated with\n   * the name you define in performanceMark when a certain event is\n   * happening. In our case we will log the `performance.mark` into\n   * the PerformanceEntry API once the image is fully loaded.\n   * Performance monitoring tools like SpeedCurve or Lighthouse are\n   * then able to grab these entries from the PerformanceEntry API\n   * and give us additional information and insights about our page\n   * loading behavior. We are then also able to monitor these\n   * values over a long period to see if our performance\n   * increases or decreases over time. Best to use lowercase strings\n   * here, separate words with underscores or dashes.\n   */\n  @forceType()\n  @property({ attribute: 'performance-mark' })\n  public accessor performanceMark: string = '';\n\n  /**\n   * With the pictureSizesConfig object, you can pass in information\n   * into image about what kind of source elements should get\n   * rendered. mediaQueries accepts multiple Media Query entries\n   * which can get combined by defining a conditionOperator.\n   * Type is: stringified InterfaceImageAttributesSizesConfig-Object\n   * An example could look like this:\n   * {\n   *    \"breakpoints\": [\n   *      {\n   *        \"image\": {\n   *          \"height\": \"675\",\n   *          \"width\": \"1200\"\n   *        },\n   *        \"mediaQueries\": [\n   *          {\n   *            \"conditionFeature\": \"min-width\",\n   *            \"conditionFeatureValue\": {\n   *              \"lyneDesignToken\": true,\n   *              \"value\": \"sbb-breakpoint-large-min\"\n   *            },\n   *            \"conditionOperator\": false\n   *          }\n   *        ]\n   *      },\n   *      {\n   *        \"image\": {\n   *          \"height\": \"549\",\n   *          \"width\": \"976\"\n   *        },\n   *        \"mediaQueries\": [\n   *          {\n   *            \"conditionFeature\": \"min-width\",\n   *            \"conditionFeatureValue\": {\n   *              \"lyneDesignToken\": true,\n   *              \"value\": \"sbb-breakpoint-small-min\"\n   *            },\n   *            \"conditionOperator\": false\n   *          }\n   *        ]\n   *      },\n   *      {\n   *        \"image\": {\n   *          \"height\": \"180\",\n   *          \"width\": \"320\"\n   *        },\n   *        \"mediaQueries\": [\n   *          {\n   *            \"conditionFeature\": \"max-width\",\n   *            \"conditionFeatureValue\": {\n   *              \"lyneDesignToken\": true,\n   *              \"value\": \"sbb-breakpoint-small-max\"\n   *            },\n   *            \"conditionOperator\": \"and\"\n   *          },\n   *          {\n   *            \"conditionFeature\": \"orientation\",\n   *            \"conditionFeatureValue\": {\n   *              \"lyneDesignToken\": false,\n   *              \"value\": \"landscape\"\n   *            },\n   *            \"conditionOperator\": false\n   *          }\n   *        ]\n   *      }\n   *    ]\n   *  }\n   */\n  @forceType()\n  @property({ attribute: 'picture-sizes-config' })\n  public accessor pictureSizesConfig: string = '';\n\n  /** Whether the image is finished loading or failed to load. */\n  public get complete(): boolean {\n    return this.shadowRoot?.querySelector?.<HTMLImageElement>('.sbb-image__img')?.complete ?? false;\n  }\n\n  protected override updated(changedProperties: PropertyValues<this>): void {\n    super.updated(changedProperties);\n\n    if (!this._captionElement) {\n      return;\n    }\n\n    this._linksInCaption = this._captionElement.querySelectorAll<HTMLLinkElement>('a');\n\n    if (!this._linksInCaption) {\n      return;\n    }\n\n    this._addFocusAbilityToLinksInCaption();\n  }\n\n  private _logPerformanceMarks(): void {\n    if (this.performanceMark) {\n      performance.clearMarks(this.performanceMark);\n      performance.mark(this.performanceMark);\n    }\n  }\n  private _addFocusAbilityToLinksInCaption(): void {\n    this._linksInCaption?.forEach((link) => {\n      link.removeAttribute('tabindex');\n    });\n  }\n\n  private _prepareImageUrl(baseUrl: string | undefined, lquip = false): string {\n    if (!baseUrl || baseUrl === '') {\n      return '';\n    }\n\n    // Creating a URL without a schema will fail, but is a valid input for baseUrl.\n    // e.g. image-src can be https://example.com/my-image.png or /my-image.png\n    const isFullyQualifiedUrl = !!baseUrl.match(/^\\w+:\\/\\//);\n    const imageUrlObj = isFullyQualifiedUrl ? new URL(baseUrl) : new URL(`http://noop/${baseUrl}`);\n\n    if (lquip) {\n      // blur and size: ?blur=100&w=100&h=56\n      imageUrlObj.searchParams.append('blur', '100');\n      imageUrlObj.searchParams.append('w', '100');\n      imageUrlObj.searchParams.append('h', '56');\n    } else {\n      // CDN Information: https://docs.imgix.com/apis/rendering\n      // param.auto: ?auto=format,compress,cs=tinysrgb\n      imageUrlObj.searchParams.append('auto', 'format,compress,cs=tinysrgb');\n    }\n\n    if (this.customFocalPoint) {\n      // crop: `&fit=crop&crop=focalpoint&fp-x=${this.focalPointX}&fp-y=${this.focalPointY}&fp-z=1`,\n      imageUrlObj.searchParams.append('fit', 'crop');\n      imageUrlObj.searchParams.append('crop', 'focalpoint');\n      imageUrlObj.searchParams.append('fp-x', this.focalPointX.toString(10));\n      imageUrlObj.searchParams.append('fp-y', this.focalPointY.toString(10));\n      imageUrlObj.searchParams.append('fp-z', '1');\n    }\n\n    if (this.focalPointDebug) {\n      // focalPointDebug: '&fp-debug=true'\n      imageUrlObj.searchParams.append('fp-debug', 'true');\n    }\n\n    // In case of \"noop\" host, we don't return the host and must remove the\n    // starting `/` of the pathname.\n    return isFullyQualifiedUrl\n      ? imageUrlObj.href\n      : imageUrlObj.pathname.substring(1) + imageUrlObj.search;\n  }\n\n  private _preparePictureSizeConfigs(): InterfaceImageAttributesSizesConfigBreakpoint[] {\n    let pictureSizesConfig;\n\n    if (this.pictureSizesConfig) {\n      pictureSizesConfig = this.pictureSizesConfig;\n    } else {\n      // default config\n      pictureSizesConfig = `{\n        \"breakpoints\": [\n          {\n            \"image\": {\n              \"height\": 675,\n              \"width\": 1200\n            },\n            \"mediaQueries\": [\n              {\n                \"conditionFeature\": \"min-width\",\n                \"conditionFeatureValue\": {\n                  \"lyneDesignToken\": true,\n                  \"value\": \"sbb-breakpoint-large-min\"\n                },\n                \"conditionOperator\": false\n              }\n            ]\n          },\n          {\n            \"image\": {\n              \"height\": 549,\n              \"width\": 976\n            },\n            \"mediaQueries\": [\n              {\n                \"conditionFeature\": \"min-width\",\n                \"conditionFeatureValue\": {\n                  \"lyneDesignToken\": true,\n                  \"value\": \"sbb-breakpoint-small-min\"\n                },\n                \"conditionOperator\": false\n              }\n            ]\n          },\n          {\n            \"image\": {\n              \"height\": 180,\n              \"width\": 320\n            },\n            \"mediaQueries\": [\n              {\n                \"conditionFeature\": \"max-width\",\n                \"conditionFeatureValue\": {\n                  \"lyneDesignToken\": true,\n                  \"value\": \"sbb-breakpoint-zero-max\"\n                },\n                \"conditionOperator\": false\n              }\n            ]\n          }\n        ]\n      }`;\n    }\n\n    return imageHelperGetBreakpoints(pictureSizesConfig);\n  }\n\n  private _createMediaQueryString(\n    mediaQueries: InterfaceImageAttributesSizesConfigMediaQuery[],\n  ): string {\n    let mediaQuery = '';\n\n    mediaQueries.forEach((mq) => {\n      const mqCondition = mq.conditionFeature;\n      let mqValue;\n\n      if (mq.conditionFeatureValue.lyneDesignToken) {\n        mqValue = breakpointMap[mq.conditionFeatureValue.value] ?? '';\n      } else {\n        mqValue = mq.conditionFeatureValue.value;\n      }\n\n      const mqCombiner = mq.conditionOperator ? ` ${mq.conditionOperator} ` : '';\n\n      mediaQuery += `(${mqCondition}: ${mqValue})${mqCombiner}`;\n    });\n\n    return mediaQuery;\n  }\n\n  @eventOptions(eventListenerOptions)\n  private _imageLoaded(): void {\n    this._logPerformanceMarks();\n    this.internals.states.add('loaded');\n\n    /** Emits each time an image loads. E.g. loading image for a different viewport, triggers the load event again. */\n    this.dispatchEvent(new Event('load'));\n  }\n\n  protected override render(): TemplateResult {\n    const imageUrlLQIP = this._prepareImageUrl(this.imageSrc, true);\n    const imageUrlWithParams = this._prepareImageUrl(this.imageSrc, false);\n\n    if (this.loading === 'lazy') {\n      this.decoding = 'async';\n      this.importance = 'low';\n    }\n\n    const pictureSizeConfigs = this._preparePictureSizeConfigs();\n\n    /**\n     * The alt attribute should always be present for the img element.\n     * If it has an empty string as its value, it is simply ignored\n     * by assistive technologies. If we leave it out completely,\n     * they might try to interpret the img element.\n     */\n    return html`\n      <div class=\"sbb-image__wrapper\">\n        ${!this.skipLqip\n          ? html`<img\n              alt=\"\"\n              class=\"sbb-image__blurred\"\n              src=${imageUrlLQIP}\n              width=\"1000\"\n              height=\"562\"\n              loading=${this.loading ?? nothing}\n              decoding=${this.decoding ?? nothing}\n            />`\n          : nothing}\n\n        <picture>\n          <!-- render picture element sources -->\n          ${pictureSizeConfigs.map((config) => {\n            const imageHeight = config.image.height;\n            const imageWidth = config.image.width;\n            const mediaQuery = this._createMediaQueryString(config.mediaQueries);\n            return html`\n              <source\n                media=${`${mediaQuery}`}\n                sizes=${`${imageWidth}px`}\n                srcset=${\n                  `${imageUrlWithParams}&w=${imageWidth}&h=${imageHeight}&q=${this._config.nonRetinaQuality} ${imageWidth}w, ` +\n                  `${imageUrlWithParams}&w=${imageWidth * 2}&h=${imageHeight * 2}&q=${\n                    this._config.retinaQuality\n                  } ${imageWidth * 2}w`\n                }\n              ></source>`;\n          })}\n          <img\n            alt=${this.alt || ''}\n            @load=${this._imageLoaded}\n            @error=${() => {\n              /** Emits when the image loading ended in an error. */\n              return this.dispatchEvent(new Event('error'));\n            }}\n            class=\"sbb-image__img\"\n            src=${this.imageSrc!}\n            width=\"1000\"\n            height=\"562\"\n            loading=${this.loading ?? nothing}\n            decoding=${this.decoding ?? nothing}\n            .fetchPriority=${this.importance ?? nothing}\n          />\n        </picture>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-image': SbbImageElement;\n  }\n}\n"],"mappings":"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"}