@incodetech/web 2.1.1 → 2.2.0-rc.0

package/dist/spacer-CDlQd12V.js

@@ -0,0 +1,2344 @@
+import { r as __toESM } from "./rolldown-runtime--E5BIlTp.js";
+import { i as useTranslation, n as useUiConfig } from "./uiConfig-B5ASPUL4.js";
+import { _ as y, b as Q, d as T, f as _, g as x, h as q, l as A, p as d, v as u } from "./vendor-preact-mvwZ8mJj.js";
+//#region src/styles/cn.tsx
+var cn = (...classes) => {
+	const result = [];
+	for (const cls of classes) {
+		if (!cls) continue;
+		if (typeof cls === "string") result.push(cls);
+		else if (typeof cls === "object") {
+			for (const [key, value] of Object.entries(cls)) if (value) result.push(key);
+		}
+	}
+	return result.join(" ");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/dompurify@3.3.3/node_modules/dompurify/dist/purify.es.mjs
+/*! @license DOMPurify 3.3.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.3/LICENSE */
+var { entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor } = Object;
+var { freeze, seal, create } = Object;
+var { apply, construct } = typeof Reflect !== "undefined" && Reflect;
+if (!freeze) freeze = function freeze(x) {
+	return x;
+};
+if (!seal) seal = function seal(x) {
+	return x;
+};
+if (!apply) apply = function apply(func, thisArg) {
+	for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) args[_key - 2] = arguments[_key];
+	return func.apply(thisArg, args);
+};
+if (!construct) construct = function construct(Func) {
+	for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
+	return new Func(...args);
+};
+var arrayForEach = unapply(Array.prototype.forEach);
+var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+var arrayPop = unapply(Array.prototype.pop);
+var arrayPush = unapply(Array.prototype.push);
+var arraySplice = unapply(Array.prototype.splice);
+var stringToLowerCase = unapply(String.prototype.toLowerCase);
+var stringToString = unapply(String.prototype.toString);
+var stringMatch = unapply(String.prototype.match);
+var stringReplace = unapply(String.prototype.replace);
+var stringIndexOf = unapply(String.prototype.indexOf);
+var stringTrim = unapply(String.prototype.trim);
+var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+var regExpTest = unapply(RegExp.prototype.test);
+var typeErrorCreate = unconstruct(TypeError);
+/**
+* Creates a new function that calls the given function with a specified thisArg and arguments.
+*
+* @param func - The function to be wrapped and called.
+* @returns A new function that calls the given function with a specified thisArg and arguments.
+*/
+function unapply(func) {
+	return function(thisArg) {
+		if (thisArg instanceof RegExp) thisArg.lastIndex = 0;
+		for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) args[_key3 - 1] = arguments[_key3];
+		return apply(func, thisArg, args);
+	};
+}
+/**
+* Creates a new function that constructs an instance of the given constructor function with the provided arguments.
+*
+* @param func - The constructor function to be wrapped and called.
+* @returns A new function that constructs an instance of the given constructor function with the provided arguments.
+*/
+function unconstruct(Func) {
+	return function() {
+		for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) args[_key4] = arguments[_key4];
+		return construct(Func, args);
+	};
+}
+/**
+* Add properties to a lookup table
+*
+* @param set - The set to which elements will be added.
+* @param array - The array containing elements to be added to the set.
+* @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
+* @returns The modified set with added elements.
+*/
+function addToSet(set, array) {
+	let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+	if (setPrototypeOf) setPrototypeOf(set, null);
+	let l = array.length;
+	while (l--) {
+		let element = array[l];
+		if (typeof element === "string") {
+			const lcElement = transformCaseFunc(element);
+			if (lcElement !== element) {
+				if (!isFrozen(array)) array[l] = lcElement;
+				element = lcElement;
+			}
+		}
+		set[element] = true;
+	}
+	return set;
+}
+/**
+* Clean up an array to harden against CSPP
+*
+* @param array - The array to be cleaned.
+* @returns The cleaned version of the array
+*/
+function cleanArray(array) {
+	for (let index = 0; index < array.length; index++) if (!objectHasOwnProperty(array, index)) array[index] = null;
+	return array;
+}
+/**
+* Shallow clone an object
+*
+* @param object - The object to be cloned.
+* @returns A new object that copies the original.
+*/
+function clone(object) {
+	const newObject = create(null);
+	for (const [property, value] of entries(object)) if (objectHasOwnProperty(object, property)) if (Array.isArray(value)) newObject[property] = cleanArray(value);
+	else if (value && typeof value === "object" && value.constructor === Object) newObject[property] = clone(value);
+	else newObject[property] = value;
+	return newObject;
+}
+/**
+* This method automatically checks if the prop is function or getter and behaves accordingly.
+*
+* @param object - The object to look up the getter function in its prototype chain.
+* @param prop - The property name for which to find the getter function.
+* @returns The getter function found in the prototype chain or a fallback function.
+*/
+function lookupGetter(object, prop) {
+	while (object !== null) {
+		const desc = getOwnPropertyDescriptor(object, prop);
+		if (desc) {
+			if (desc.get) return unapply(desc.get);
+			if (typeof desc.value === "function") return unapply(desc.value);
+		}
+		object = getPrototypeOf(object);
+	}
+	function fallbackValue() {
+		return null;
+	}
+	return fallbackValue;
+}
+var html$1 = freeze([
+	"a",
+	"abbr",
+	"acronym",
+	"address",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blink",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"center",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"content",
+	"data",
+	"datalist",
+	"dd",
+	"decorator",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"dir",
+	"div",
+	"dl",
+	"dt",
+	"element",
+	"em",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"font",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"head",
+	"header",
+	"hgroup",
+	"hr",
+	"html",
+	"i",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"main",
+	"map",
+	"mark",
+	"marquee",
+	"menu",
+	"menuitem",
+	"meter",
+	"nav",
+	"nobr",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rp",
+	"rt",
+	"ruby",
+	"s",
+	"samp",
+	"search",
+	"section",
+	"select",
+	"shadow",
+	"slot",
+	"small",
+	"source",
+	"spacer",
+	"span",
+	"strike",
+	"strong",
+	"style",
+	"sub",
+	"summary",
+	"sup",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"tr",
+	"track",
+	"tt",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr"
+]);
+var svg$1 = freeze([
+	"svg",
+	"a",
+	"altglyph",
+	"altglyphdef",
+	"altglyphitem",
+	"animatecolor",
+	"animatemotion",
+	"animatetransform",
+	"circle",
+	"clippath",
+	"defs",
+	"desc",
+	"ellipse",
+	"enterkeyhint",
+	"exportparts",
+	"filter",
+	"font",
+	"g",
+	"glyph",
+	"glyphref",
+	"hkern",
+	"image",
+	"inputmode",
+	"line",
+	"lineargradient",
+	"marker",
+	"mask",
+	"metadata",
+	"mpath",
+	"part",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialgradient",
+	"rect",
+	"stop",
+	"style",
+	"switch",
+	"symbol",
+	"text",
+	"textpath",
+	"title",
+	"tref",
+	"tspan",
+	"view",
+	"vkern"
+]);
+var svgFilters = freeze([
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence"
+]);
+var svgDisallowed = freeze([
+	"animate",
+	"color-profile",
+	"cursor",
+	"discard",
+	"font-face",
+	"font-face-format",
+	"font-face-name",
+	"font-face-src",
+	"font-face-uri",
+	"foreignobject",
+	"hatch",
+	"hatchpath",
+	"mesh",
+	"meshgradient",
+	"meshpatch",
+	"meshrow",
+	"missing-glyph",
+	"script",
+	"set",
+	"solidcolor",
+	"unknown",
+	"use"
+]);
+var mathMl$1 = freeze([
+	"math",
+	"menclose",
+	"merror",
+	"mfenced",
+	"mfrac",
+	"mglyph",
+	"mi",
+	"mlabeledtr",
+	"mmultiscripts",
+	"mn",
+	"mo",
+	"mover",
+	"mpadded",
+	"mphantom",
+	"mroot",
+	"mrow",
+	"ms",
+	"mspace",
+	"msqrt",
+	"mstyle",
+	"msub",
+	"msup",
+	"msubsup",
+	"mtable",
+	"mtd",
+	"mtext",
+	"mtr",
+	"munder",
+	"munderover",
+	"mprescripts"
+]);
+var mathMlDisallowed = freeze([
+	"maction",
+	"maligngroup",
+	"malignmark",
+	"mlongdiv",
+	"mscarries",
+	"mscarry",
+	"msgroup",
+	"mstack",
+	"msline",
+	"msrow",
+	"semantics",
+	"annotation",
+	"annotation-xml",
+	"mprescripts",
+	"none"
+]);
+var text = freeze(["#text"]);
+var html = freeze([
+	"accept",
+	"action",
+	"align",
+	"alt",
+	"autocapitalize",
+	"autocomplete",
+	"autopictureinpicture",
+	"autoplay",
+	"background",
+	"bgcolor",
+	"border",
+	"capture",
+	"cellpadding",
+	"cellspacing",
+	"checked",
+	"cite",
+	"class",
+	"clear",
+	"color",
+	"cols",
+	"colspan",
+	"controls",
+	"controlslist",
+	"coords",
+	"crossorigin",
+	"datetime",
+	"decoding",
+	"default",
+	"dir",
+	"disabled",
+	"disablepictureinpicture",
+	"disableremoteplayback",
+	"download",
+	"draggable",
+	"enctype",
+	"enterkeyhint",
+	"exportparts",
+	"face",
+	"for",
+	"headers",
+	"height",
+	"hidden",
+	"high",
+	"href",
+	"hreflang",
+	"id",
+	"inert",
+	"inputmode",
+	"integrity",
+	"ismap",
+	"kind",
+	"label",
+	"lang",
+	"list",
+	"loading",
+	"loop",
+	"low",
+	"max",
+	"maxlength",
+	"media",
+	"method",
+	"min",
+	"minlength",
+	"multiple",
+	"muted",
+	"name",
+	"nonce",
+	"noshade",
+	"novalidate",
+	"nowrap",
+	"open",
+	"optimum",
+	"part",
+	"pattern",
+	"placeholder",
+	"playsinline",
+	"popover",
+	"popovertarget",
+	"popovertargetaction",
+	"poster",
+	"preload",
+	"pubdate",
+	"radiogroup",
+	"readonly",
+	"rel",
+	"required",
+	"rev",
+	"reversed",
+	"role",
+	"rows",
+	"rowspan",
+	"spellcheck",
+	"scope",
+	"selected",
+	"shape",
+	"size",
+	"sizes",
+	"slot",
+	"span",
+	"srclang",
+	"start",
+	"src",
+	"srcset",
+	"step",
+	"style",
+	"summary",
+	"tabindex",
+	"title",
+	"translate",
+	"type",
+	"usemap",
+	"valign",
+	"value",
+	"width",
+	"wrap",
+	"xmlns",
+	"slot"
+]);
+var svg = freeze([
+	"accent-height",
+	"accumulate",
+	"additive",
+	"alignment-baseline",
+	"amplitude",
+	"ascent",
+	"attributename",
+	"attributetype",
+	"azimuth",
+	"basefrequency",
+	"baseline-shift",
+	"begin",
+	"bias",
+	"by",
+	"class",
+	"clip",
+	"clippathunits",
+	"clip-path",
+	"clip-rule",
+	"color",
+	"color-interpolation",
+	"color-interpolation-filters",
+	"color-profile",
+	"color-rendering",
+	"cx",
+	"cy",
+	"d",
+	"dx",
+	"dy",
+	"diffuseconstant",
+	"direction",
+	"display",
+	"divisor",
+	"dur",
+	"edgemode",
+	"elevation",
+	"end",
+	"exponent",
+	"fill",
+	"fill-opacity",
+	"fill-rule",
+	"filter",
+	"filterunits",
+	"flood-color",
+	"flood-opacity",
+	"font-family",
+	"font-size",
+	"font-size-adjust",
+	"font-stretch",
+	"font-style",
+	"font-variant",
+	"font-weight",
+	"fx",
+	"fy",
+	"g1",
+	"g2",
+	"glyph-name",
+	"glyphref",
+	"gradientunits",
+	"gradienttransform",
+	"height",
+	"href",
+	"id",
+	"image-rendering",
+	"in",
+	"in2",
+	"intercept",
+	"k",
+	"k1",
+	"k2",
+	"k3",
+	"k4",
+	"kerning",
+	"keypoints",
+	"keysplines",
+	"keytimes",
+	"lang",
+	"lengthadjust",
+	"letter-spacing",
+	"kernelmatrix",
+	"kernelunitlength",
+	"lighting-color",
+	"local",
+	"marker-end",
+	"marker-mid",
+	"marker-start",
+	"markerheight",
+	"markerunits",
+	"markerwidth",
+	"maskcontentunits",
+	"maskunits",
+	"max",
+	"mask",
+	"mask-type",
+	"media",
+	"method",
+	"mode",
+	"min",
+	"name",
+	"numoctaves",
+	"offset",
+	"operator",
+	"opacity",
+	"order",
+	"orient",
+	"orientation",
+	"origin",
+	"overflow",
+	"paint-order",
+	"path",
+	"pathlength",
+	"patterncontentunits",
+	"patterntransform",
+	"patternunits",
+	"points",
+	"preservealpha",
+	"preserveaspectratio",
+	"primitiveunits",
+	"r",
+	"rx",
+	"ry",
+	"radius",
+	"refx",
+	"refy",
+	"repeatcount",
+	"repeatdur",
+	"restart",
+	"result",
+	"rotate",
+	"scale",
+	"seed",
+	"shape-rendering",
+	"slope",
+	"specularconstant",
+	"specularexponent",
+	"spreadmethod",
+	"startoffset",
+	"stddeviation",
+	"stitchtiles",
+	"stop-color",
+	"stop-opacity",
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-linecap",
+	"stroke-linejoin",
+	"stroke-miterlimit",
+	"stroke-opacity",
+	"stroke",
+	"stroke-width",
+	"style",
+	"surfacescale",
+	"systemlanguage",
+	"tabindex",
+	"tablevalues",
+	"targetx",
+	"targety",
+	"transform",
+	"transform-origin",
+	"text-anchor",
+	"text-decoration",
+	"text-rendering",
+	"textlength",
+	"type",
+	"u1",
+	"u2",
+	"unicode",
+	"values",
+	"viewbox",
+	"visibility",
+	"version",
+	"vert-adv-y",
+	"vert-origin-x",
+	"vert-origin-y",
+	"width",
+	"word-spacing",
+	"wrap",
+	"writing-mode",
+	"xchannelselector",
+	"ychannelselector",
+	"x",
+	"x1",
+	"x2",
+	"xmlns",
+	"y",
+	"y1",
+	"y2",
+	"z",
+	"zoomandpan"
+]);
+var mathMl = freeze([
+	"accent",
+	"accentunder",
+	"align",
+	"bevelled",
+	"close",
+	"columnsalign",
+	"columnlines",
+	"columnspan",
+	"denomalign",
+	"depth",
+	"dir",
+	"display",
+	"displaystyle",
+	"encoding",
+	"fence",
+	"frame",
+	"height",
+	"href",
+	"id",
+	"largeop",
+	"length",
+	"linethickness",
+	"lspace",
+	"lquote",
+	"mathbackground",
+	"mathcolor",
+	"mathsize",
+	"mathvariant",
+	"maxsize",
+	"minsize",
+	"movablelimits",
+	"notation",
+	"numalign",
+	"open",
+	"rowalign",
+	"rowlines",
+	"rowspacing",
+	"rowspan",
+	"rspace",
+	"rquote",
+	"scriptlevel",
+	"scriptminsize",
+	"scriptsizemultiplier",
+	"selection",
+	"separator",
+	"separators",
+	"stretchy",
+	"subscriptshift",
+	"supscriptshift",
+	"symmetric",
+	"voffset",
+	"width",
+	"xmlns"
+]);
+var xml = freeze([
+	"xlink:href",
+	"xml:id",
+	"xlink:title",
+	"xml:space",
+	"xmlns:xlink"
+]);
+var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+var TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
+var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+var DOCTYPE_NAME = seal(/^html$/i);
+var CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+var EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+	__proto__: null,
+	ARIA_ATTR,
+	ATTR_WHITESPACE,
+	CUSTOM_ELEMENT,
+	DATA_ATTR,
+	DOCTYPE_NAME,
+	ERB_EXPR,
+	IS_ALLOWED_URI,
+	IS_SCRIPT_OR_DATA,
+	MUSTACHE_EXPR,
+	TMPLIT_EXPR
+});
+var NODE_TYPE = {
+	element: 1,
+	attribute: 2,
+	text: 3,
+	cdataSection: 4,
+	entityReference: 5,
+	entityNode: 6,
+	progressingInstruction: 7,
+	comment: 8,
+	document: 9,
+	documentType: 10,
+	documentFragment: 11,
+	notation: 12
+};
+var getGlobal = function getGlobal() {
+	return typeof window === "undefined" ? null : window;
+};
+/**
+* Creates a no-op policy for internal use only.
+* Don't export this function outside this module!
+* @param trustedTypes The policy factory.
+* @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
+* @return The policy created (or null, if Trusted Types
+* are not supported or creating the policy failed).
+*/
+var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
+	if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") return null;
+	let suffix = null;
+	const ATTR_NAME = "data-tt-policy-suffix";
+	if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) suffix = purifyHostElement.getAttribute(ATTR_NAME);
+	const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+	try {
+		return trustedTypes.createPolicy(policyName, {
+			createHTML(html) {
+				return html;
+			},
+			createScriptURL(scriptUrl) {
+				return scriptUrl;
+			}
+		});
+	} catch (_) {
+		console.warn("TrustedTypes policy " + policyName + " could not be created.");
+		return null;
+	}
+};
+var _createHooksMap = function _createHooksMap() {
+	return {
+		afterSanitizeAttributes: [],
+		afterSanitizeElements: [],
+		afterSanitizeShadowDOM: [],
+		beforeSanitizeAttributes: [],
+		beforeSanitizeElements: [],
+		beforeSanitizeShadowDOM: [],
+		uponSanitizeAttribute: [],
+		uponSanitizeElement: [],
+		uponSanitizeShadowNode: []
+	};
+};
+function createDOMPurify() {
+	let window = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+	const DOMPurify = (root) => createDOMPurify(root);
+	DOMPurify.version = "3.3.3";
+	DOMPurify.removed = [];
+	if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
+		DOMPurify.isSupported = false;
+		return DOMPurify;
+	}
+	let { document } = window;
+	const originalDocument = document;
+	const currentScript = originalDocument.currentScript;
+	const { DocumentFragment, HTMLTemplateElement, Node, Element, NodeFilter, NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap, HTMLFormElement, DOMParser, trustedTypes } = window;
+	const ElementPrototype = Element.prototype;
+	const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+	const remove = lookupGetter(ElementPrototype, "remove");
+	const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+	const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+	const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+	if (typeof HTMLTemplateElement === "function") {
+		const template = document.createElement("template");
+		if (template.content && template.content.ownerDocument) document = template.content.ownerDocument;
+	}
+	let trustedTypesPolicy;
+	let emptyHTML = "";
+	const { implementation, createNodeIterator, createDocumentFragment, getElementsByTagName } = document;
+	const { importNode } = originalDocument;
+	let hooks = _createHooksMap();
+	/**
+	* Expose whether this browser supports running the full DOMPurify.
+	*/
+	DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+	const { MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, CUSTOM_ELEMENT } = EXPRESSIONS;
+	let { IS_ALLOWED_URI: IS_ALLOWED_URI$1 } = EXPRESSIONS;
+	/**
+	* We consider the elements and attributes below to be safe. Ideally
+	* don't add any new ones but feel free to remove unwanted ones.
+	*/
+	let ALLOWED_TAGS = null;
+	const DEFAULT_ALLOWED_TAGS = addToSet({}, [
+		...html$1,
+		...svg$1,
+		...svgFilters,
+		...mathMl$1,
+		...text
+	]);
+	let ALLOWED_ATTR = null;
+	const DEFAULT_ALLOWED_ATTR = addToSet({}, [
+		...html,
+		...svg,
+		...mathMl,
+		...xml
+	]);
+	let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+		tagNameCheck: {
+			writable: true,
+			configurable: false,
+			enumerable: true,
+			value: null
+		},
+		attributeNameCheck: {
+			writable: true,
+			configurable: false,
+			enumerable: true,
+			value: null
+		},
+		allowCustomizedBuiltInElements: {
+			writable: true,
+			configurable: false,
+			enumerable: true,
+			value: false
+		}
+	}));
+	let FORBID_TAGS = null;
+	let FORBID_ATTR = null;
+	const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+		tagCheck: {
+			writable: true,
+			configurable: false,
+			enumerable: true,
+			value: null
+		},
+		attributeCheck: {
+			writable: true,
+			configurable: false,
+			enumerable: true,
+			value: null
+		}
+	}));
+	let ALLOW_ARIA_ATTR = true;
+	let ALLOW_DATA_ATTR = true;
+	let ALLOW_UNKNOWN_PROTOCOLS = false;
+	let ALLOW_SELF_CLOSE_IN_ATTR = true;
+	let SAFE_FOR_TEMPLATES = false;
+	let SAFE_FOR_XML = true;
+	let WHOLE_DOCUMENT = false;
+	let SET_CONFIG = false;
+	let FORCE_BODY = false;
+	let RETURN_DOM = false;
+	let RETURN_DOM_FRAGMENT = false;
+	let RETURN_TRUSTED_TYPE = false;
+	let SANITIZE_DOM = true;
+	let SANITIZE_NAMED_PROPS = false;
+	const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+	let KEEP_CONTENT = true;
+	let IN_PLACE = false;
+	let USE_PROFILES = {};
+	let FORBID_CONTENTS = null;
+	const DEFAULT_FORBID_CONTENTS = addToSet({}, [
+		"annotation-xml",
+		"audio",
+		"colgroup",
+		"desc",
+		"foreignobject",
+		"head",
+		"iframe",
+		"math",
+		"mi",
+		"mn",
+		"mo",
+		"ms",
+		"mtext",
+		"noembed",
+		"noframes",
+		"noscript",
+		"plaintext",
+		"script",
+		"style",
+		"svg",
+		"template",
+		"thead",
+		"title",
+		"video",
+		"xmp"
+	]);
+	let DATA_URI_TAGS = null;
+	const DEFAULT_DATA_URI_TAGS = addToSet({}, [
+		"audio",
+		"video",
+		"img",
+		"source",
+		"image",
+		"track"
+	]);
+	let URI_SAFE_ATTRIBUTES = null;
+	const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [
+		"alt",
+		"class",
+		"for",
+		"id",
+		"label",
+		"name",
+		"pattern",
+		"placeholder",
+		"role",
+		"summary",
+		"title",
+		"value",
+		"style",
+		"xmlns"
+	]);
+	const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+	const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+	const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+	let NAMESPACE = HTML_NAMESPACE;
+	let IS_EMPTY_INPUT = false;
+	let ALLOWED_NAMESPACES = null;
+	const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [
+		MATHML_NAMESPACE,
+		SVG_NAMESPACE,
+		HTML_NAMESPACE
+	], stringToString);
+	let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, [
+		"mi",
+		"mo",
+		"mn",
+		"ms",
+		"mtext"
+	]);
+	let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+	const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, [
+		"title",
+		"style",
+		"font",
+		"a",
+		"script"
+	]);
+	let PARSER_MEDIA_TYPE = null;
+	const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+	const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+	let transformCaseFunc = null;
+	let CONFIG = null;
+	const formElement = document.createElement("form");
+	const isRegexOrFunction = function isRegexOrFunction(testValue) {
+		return testValue instanceof RegExp || testValue instanceof Function;
+	};
+	/**
+	* _parseConfig
+	*
+	* @param cfg optional config literal
+	*/
+	const _parseConfig = function _parseConfig() {
+		let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+		if (CONFIG && CONFIG === cfg) return;
+		if (!cfg || typeof cfg !== "object") cfg = {};
+		cfg = clone(cfg);
+		PARSER_MEDIA_TYPE = SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+		transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+		ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+		ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+		ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+		URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+		DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+		FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+		FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
+		FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+		USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES : false;
+		ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+		ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+		ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+		ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+		SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+		SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+		WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+		RETURN_DOM = cfg.RETURN_DOM || false;
+		RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+		RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+		FORCE_BODY = cfg.FORCE_BODY || false;
+		SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+		SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+		KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+		IN_PLACE = cfg.IN_PLACE || false;
+		IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+		NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+		MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+		HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+		CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+		if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+		if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+		if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+		if (SAFE_FOR_TEMPLATES) ALLOW_DATA_ATTR = false;
+		if (RETURN_DOM_FRAGMENT) RETURN_DOM = true;
+		if (USE_PROFILES) {
+			ALLOWED_TAGS = addToSet({}, text);
+			ALLOWED_ATTR = create(null);
+			if (USE_PROFILES.html === true) {
+				addToSet(ALLOWED_TAGS, html$1);
+				addToSet(ALLOWED_ATTR, html);
+			}
+			if (USE_PROFILES.svg === true) {
+				addToSet(ALLOWED_TAGS, svg$1);
+				addToSet(ALLOWED_ATTR, svg);
+				addToSet(ALLOWED_ATTR, xml);
+			}
+			if (USE_PROFILES.svgFilters === true) {
+				addToSet(ALLOWED_TAGS, svgFilters);
+				addToSet(ALLOWED_ATTR, svg);
+				addToSet(ALLOWED_ATTR, xml);
+			}
+			if (USE_PROFILES.mathMl === true) {
+				addToSet(ALLOWED_TAGS, mathMl$1);
+				addToSet(ALLOWED_ATTR, mathMl);
+				addToSet(ALLOWED_ATTR, xml);
+			}
+		}
+		if (!objectHasOwnProperty(cfg, "ADD_TAGS")) EXTRA_ELEMENT_HANDLING.tagCheck = null;
+		if (!objectHasOwnProperty(cfg, "ADD_ATTR")) EXTRA_ELEMENT_HANDLING.attributeCheck = null;
+		if (cfg.ADD_TAGS) if (typeof cfg.ADD_TAGS === "function") EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+		else {
+			if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) ALLOWED_TAGS = clone(ALLOWED_TAGS);
+			addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+		}
+		if (cfg.ADD_ATTR) if (typeof cfg.ADD_ATTR === "function") EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+		else {
+			if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) ALLOWED_ATTR = clone(ALLOWED_ATTR);
+			addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+		}
+		if (cfg.ADD_URI_SAFE_ATTR) addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+		if (cfg.FORBID_CONTENTS) {
+			if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) FORBID_CONTENTS = clone(FORBID_CONTENTS);
+			addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+		}
+		if (cfg.ADD_FORBID_CONTENTS) {
+			if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) FORBID_CONTENTS = clone(FORBID_CONTENTS);
+			addToSet(FORBID_CONTENTS, cfg.ADD_FORBID_CONTENTS, transformCaseFunc);
+		}
+		if (KEEP_CONTENT) ALLOWED_TAGS["#text"] = true;
+		if (WHOLE_DOCUMENT) addToSet(ALLOWED_TAGS, [
+			"html",
+			"head",
+			"body"
+		]);
+		if (ALLOWED_TAGS.table) {
+			addToSet(ALLOWED_TAGS, ["tbody"]);
+			delete FORBID_TAGS.tbody;
+		}
+		if (cfg.TRUSTED_TYPES_POLICY) {
+			if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") throw typeErrorCreate("TRUSTED_TYPES_POLICY configuration option must provide a \"createHTML\" hook.");
+			if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") throw typeErrorCreate("TRUSTED_TYPES_POLICY configuration option must provide a \"createScriptURL\" hook.");
+			trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+			emptyHTML = trustedTypesPolicy.createHTML("");
+		} else {
+			if (trustedTypesPolicy === void 0) trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+			if (trustedTypesPolicy !== null && typeof emptyHTML === "string") emptyHTML = trustedTypesPolicy.createHTML("");
+		}
+		if (freeze) freeze(cfg);
+		CONFIG = cfg;
+	};
+	const ALL_SVG_TAGS = addToSet({}, [
+		...svg$1,
+		...svgFilters,
+		...svgDisallowed
+	]);
+	const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+	/**
+	* @param element a DOM element whose namespace is being checked
+	* @returns Return false if the element has a
+	*  namespace that a spec-compliant parser would never
+	*  return. Return true otherwise.
+	*/
+	const _checkValidNamespace = function _checkValidNamespace(element) {
+		let parent = getParentNode(element);
+		if (!parent || !parent.tagName) parent = {
+			namespaceURI: NAMESPACE,
+			tagName: "template"
+		};
+		const tagName = stringToLowerCase(element.tagName);
+		const parentTagName = stringToLowerCase(parent.tagName);
+		if (!ALLOWED_NAMESPACES[element.namespaceURI]) return false;
+		if (element.namespaceURI === SVG_NAMESPACE) {
+			if (parent.namespaceURI === HTML_NAMESPACE) return tagName === "svg";
+			if (parent.namespaceURI === MATHML_NAMESPACE) return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+			return Boolean(ALL_SVG_TAGS[tagName]);
+		}
+		if (element.namespaceURI === MATHML_NAMESPACE) {
+			if (parent.namespaceURI === HTML_NAMESPACE) return tagName === "math";
+			if (parent.namespaceURI === SVG_NAMESPACE) return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+			return Boolean(ALL_MATHML_TAGS[tagName]);
+		}
+		if (element.namespaceURI === HTML_NAMESPACE) {
+			if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) return false;
+			if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) return false;
+			return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+		}
+		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) return true;
+		return false;
+	};
+	/**
+	* _forceRemove
+	*
+	* @param node a DOM node
+	*/
+	const _forceRemove = function _forceRemove(node) {
+		arrayPush(DOMPurify.removed, { element: node });
+		try {
+			getParentNode(node).removeChild(node);
+		} catch (_) {
+			remove(node);
+		}
+	};
+	/**
+	* _removeAttribute
+	*
+	* @param name an Attribute name
+	* @param element a DOM node
+	*/
+	const _removeAttribute = function _removeAttribute(name, element) {
+		try {
+			arrayPush(DOMPurify.removed, {
+				attribute: element.getAttributeNode(name),
+				from: element
+			});
+		} catch (_) {
+			arrayPush(DOMPurify.removed, {
+				attribute: null,
+				from: element
+			});
+		}
+		element.removeAttribute(name);
+		if (name === "is") if (RETURN_DOM || RETURN_DOM_FRAGMENT) try {
+			_forceRemove(element);
+		} catch (_) {}
+		else try {
+			element.setAttribute(name, "");
+		} catch (_) {}
+	};
+	/**
+	* _initDocument
+	*
+	* @param dirty - a string of dirty markup
+	* @return a DOM, filled with the dirty markup
+	*/
+	const _initDocument = function _initDocument(dirty) {
+		let doc = null;
+		let leadingWhitespace = null;
+		if (FORCE_BODY) dirty = "<remove></remove>" + dirty;
+		else {
+			const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+			leadingWhitespace = matches && matches[0];
+		}
+		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) dirty = "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>" + dirty + "</body></html>";
+		const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+		if (NAMESPACE === HTML_NAMESPACE) try {
+			doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+		} catch (_) {}
+		if (!doc || !doc.documentElement) {
+			doc = implementation.createDocument(NAMESPACE, "template", null);
+			try {
+				doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+			} catch (_) {}
+		}
+		const body = doc.body || doc.documentElement;
+		if (dirty && leadingWhitespace) body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+		if (NAMESPACE === HTML_NAMESPACE) return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+		return WHOLE_DOCUMENT ? doc.documentElement : body;
+	};
+	/**
+	* Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
+	*
+	* @param root The root element or node to start traversing on.
+	* @return The created NodeIterator
+	*/
+	const _createNodeIterator = function _createNodeIterator(root) {
+		return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
+	};
+	/**
+	* _isClobbered
+	*
+	* @param element element to check for clobbering attacks
+	* @return true if clobbered, false if safe
+	*/
+	const _isClobbered = function _isClobbered(element) {
+		return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+	};
+	/**
+	* Checks whether the given object is a DOM node.
+	*
+	* @param value object to check whether it's a DOM node
+	* @return true is object is a DOM node
+	*/
+	const _isNode = function _isNode(value) {
+		return typeof Node === "function" && value instanceof Node;
+	};
+	function _executeHooks(hooks, currentNode, data) {
+		arrayForEach(hooks, (hook) => {
+			hook.call(DOMPurify, currentNode, data, CONFIG);
+		});
+	}
+	/**
+	* _sanitizeElements
+	*
+	* @protect nodeName
+	* @protect textContent
+	* @protect removeChild
+	* @param currentNode to check for permission to exist
+	* @return true if node was killed, false if left alive
+	*/
+	const _sanitizeElements = function _sanitizeElements(currentNode) {
+		let content = null;
+		_executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+		if (_isClobbered(currentNode)) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		const tagName = transformCaseFunc(currentNode.nodeName);
+		_executeHooks(hooks.uponSanitizeElement, currentNode, {
+			tagName,
+			allowedTags: ALLOWED_TAGS
+		});
+		if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		if (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName])) {
+			if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+				if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
+				if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) return false;
+			}
+			if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+				const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+				const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+				if (childNodes && parentNode) {
+					const childCount = childNodes.length;
+					for (let i = childCount - 1; i >= 0; --i) {
+						const childClone = cloneNode(childNodes[i], true);
+						childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+						parentNode.insertBefore(childClone, getNextSibling(currentNode));
+					}
+				}
+			}
+			_forceRemove(currentNode);
+			return true;
+		}
+		if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+			_forceRemove(currentNode);
+			return true;
+		}
+		if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+			content = currentNode.textContent;
+			arrayForEach([
+				MUSTACHE_EXPR,
+				ERB_EXPR,
+				TMPLIT_EXPR
+			], (expr) => {
+				content = stringReplace(content, expr, " ");
+			});
+			if (currentNode.textContent !== content) {
+				arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+				currentNode.textContent = content;
+			}
+		}
+		_executeHooks(hooks.afterSanitizeElements, currentNode, null);
+		return false;
+	};
+	/**
+	* _isValidAttribute
+	*
+	* @param lcTag Lowercase tag name of containing element.
+	* @param lcName Lowercase attribute name.
+	* @param value Attribute value.
+	* @return Returns true if `value` is valid, otherwise false.
+	*/
+	const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+		if (FORBID_ATTR[lcName]) return false;
+		if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document || value in formElement)) return false;
+		if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName));
+		else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName));
+		else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag));
+		else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) if (_isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) || lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)));
+		else return false;
+		else if (URI_SAFE_ATTRIBUTES[lcName]);
+		else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, "")));
+		else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]);
+		else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, "")));
+		else if (value) return false;
+		return true;
+	};
+	/**
+	* _isBasicCustomElement
+	* checks if at least one dash is included in tagName, and it's not the first char
+	* for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
+	*
+	* @param tagName name of the tag of the node to sanitize
+	* @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+	*/
+	const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
+		return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT);
+	};
+	/**
+	* _sanitizeAttributes
+	*
+	* @protect attributes
+	* @protect nodeName
+	* @protect removeAttribute
+	* @protect setAttribute
+	*
+	* @param currentNode to sanitize
+	*/
+	const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+		_executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+		const { attributes } = currentNode;
+		if (!attributes || _isClobbered(currentNode)) return;
+		const hookEvent = {
+			attrName: "",
+			attrValue: "",
+			keepAttr: true,
+			allowedAttributes: ALLOWED_ATTR,
+			forceKeepAttr: void 0
+		};
+		let l = attributes.length;
+		while (l--) {
+			const { name, namespaceURI, value: attrValue } = attributes[l];
+			const lcName = transformCaseFunc(name);
+			const initValue = attrValue;
+			let value = name === "value" ? initValue : stringTrim(initValue);
+			hookEvent.attrName = lcName;
+			hookEvent.attrValue = value;
+			hookEvent.keepAttr = true;
+			hookEvent.forceKeepAttr = void 0;
+			_executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+			value = hookEvent.attrValue;
+			if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name")) {
+				_removeAttribute(name, currentNode);
+				value = SANITIZE_NAMED_PROPS_PREFIX + value;
+			}
+			if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
+				_removeAttribute(name, currentNode);
+				continue;
+			}
+			if (lcName === "attributename" && stringMatch(value, "href")) {
+				_removeAttribute(name, currentNode);
+				continue;
+			}
+			if (hookEvent.forceKeepAttr) continue;
+			if (!hookEvent.keepAttr) {
+				_removeAttribute(name, currentNode);
+				continue;
+			}
+			if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+				_removeAttribute(name, currentNode);
+				continue;
+			}
+			if (SAFE_FOR_TEMPLATES) arrayForEach([
+				MUSTACHE_EXPR,
+				ERB_EXPR,
+				TMPLIT_EXPR
+			], (expr) => {
+				value = stringReplace(value, expr, " ");
+			});
+			const lcTag = transformCaseFunc(currentNode.nodeName);
+			if (!_isValidAttribute(lcTag, lcName, value)) {
+				_removeAttribute(name, currentNode);
+				continue;
+			}
+			if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") if (namespaceURI);
+			else switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+				case "TrustedHTML":
+					value = trustedTypesPolicy.createHTML(value);
+					break;
+				case "TrustedScriptURL":
+					value = trustedTypesPolicy.createScriptURL(value);
+					break;
+			}
+			if (value !== initValue) try {
+				if (namespaceURI) currentNode.setAttributeNS(namespaceURI, name, value);
+				else currentNode.setAttribute(name, value);
+				if (_isClobbered(currentNode)) _forceRemove(currentNode);
+				else arrayPop(DOMPurify.removed);
+			} catch (_) {
+				_removeAttribute(name, currentNode);
+			}
+		}
+		_executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+	};
+	/**
+	* _sanitizeShadowDOM
+	*
+	* @param fragment to iterate over recursively
+	*/
+	const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+		let shadowNode = null;
+		const shadowIterator = _createNodeIterator(fragment);
+		_executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+		while (shadowNode = shadowIterator.nextNode()) {
+			_executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+			_sanitizeElements(shadowNode);
+			_sanitizeAttributes(shadowNode);
+			if (shadowNode.content instanceof DocumentFragment) _sanitizeShadowDOM(shadowNode.content);
+		}
+		_executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+	};
+	DOMPurify.sanitize = function(dirty) {
+		let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+		let body = null;
+		let importedNode = null;
+		let currentNode = null;
+		let returnNode = null;
+		IS_EMPTY_INPUT = !dirty;
+		if (IS_EMPTY_INPUT) dirty = "<!-->";
+		if (typeof dirty !== "string" && !_isNode(dirty)) if (typeof dirty.toString === "function") {
+			dirty = dirty.toString();
+			if (typeof dirty !== "string") throw typeErrorCreate("dirty is not a string, aborting");
+		} else throw typeErrorCreate("toString is not a function");
+		if (!DOMPurify.isSupported) return dirty;
+		if (!SET_CONFIG) _parseConfig(cfg);
+		DOMPurify.removed = [];
+		if (typeof dirty === "string") IN_PLACE = false;
+		if (IN_PLACE) {
+			if (dirty.nodeName) {
+				const tagName = transformCaseFunc(dirty.nodeName);
+				if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+			}
+		} else if (dirty instanceof Node) {
+			body = _initDocument("<!---->");
+			importedNode = body.ownerDocument.importNode(dirty, true);
+			if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") body = importedNode;
+			else if (importedNode.nodeName === "HTML") body = importedNode;
+			else body.appendChild(importedNode);
+		} else {
+			if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+			body = _initDocument(dirty);
+			if (!body) return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+		}
+		if (body && FORCE_BODY) _forceRemove(body.firstChild);
+		const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+		while (currentNode = nodeIterator.nextNode()) {
+			_sanitizeElements(currentNode);
+			_sanitizeAttributes(currentNode);
+			if (currentNode.content instanceof DocumentFragment) _sanitizeShadowDOM(currentNode.content);
+		}
+		if (IN_PLACE) return dirty;
+		if (RETURN_DOM) {
+			if (RETURN_DOM_FRAGMENT) {
+				returnNode = createDocumentFragment.call(body.ownerDocument);
+				while (body.firstChild) returnNode.appendChild(body.firstChild);
+			} else returnNode = body;
+			if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) returnNode = importNode.call(originalDocument, returnNode, true);
+			return returnNode;
+		}
+		let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+		if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+		if (SAFE_FOR_TEMPLATES) arrayForEach([
+			MUSTACHE_EXPR,
+			ERB_EXPR,
+			TMPLIT_EXPR
+		], (expr) => {
+			serializedHTML = stringReplace(serializedHTML, expr, " ");
+		});
+		return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+	};
+	DOMPurify.setConfig = function() {
+		_parseConfig(arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {});
+		SET_CONFIG = true;
+	};
+	DOMPurify.clearConfig = function() {
+		CONFIG = null;
+		SET_CONFIG = false;
+	};
+	DOMPurify.isValidAttribute = function(tag, attr, value) {
+		if (!CONFIG) _parseConfig({});
+		return _isValidAttribute(transformCaseFunc(tag), transformCaseFunc(attr), value);
+	};
+	DOMPurify.addHook = function(entryPoint, hookFunction) {
+		if (typeof hookFunction !== "function") return;
+		arrayPush(hooks[entryPoint], hookFunction);
+	};
+	DOMPurify.removeHook = function(entryPoint, hookFunction) {
+		if (hookFunction !== void 0) {
+			const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+			return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+		}
+		return arrayPop(hooks[entryPoint]);
+	};
+	DOMPurify.removeHooks = function(entryPoint) {
+		hooks[entryPoint] = [];
+	};
+	DOMPurify.removeAllHooks = function() {
+		hooks = _createHooksMap();
+	};
+	return DOMPurify;
+}
+var purify$1 = createDOMPurify();
+//#endregion
+//#region src/shared/assets/sanitizeSvg.ts
+var SVG_SANITIZE_CONFIG = {
+	USE_PROFILES: {
+		svg: true,
+		svgFilters: true
+	},
+	FORBID_TAGS: ["foreignObject"],
+	ADD_TAGS: ["use"]
+};
+var purify = purify$1(window);
+var strippedHref = false;
+purify.addHook("uponSanitizeAttribute", (_node, data) => {
+	if ((data.attrName === "href" || data.attrName === "xlink:href") && !String(data.attrValue).startsWith("#")) {
+		data.keepAttr = false;
+		strippedHref = true;
+	}
+});
+/**
+* Sanitizes untrusted SVG markup for safe inline injection. Strips scripts,
+* event handlers, `<foreignObject>`, and external `href` / `xlink:href` (while
+* keeping in-document `#fragment` references SVGs rely on for gradients and
+* filters). An all-stripped payload yields `markup: ''`; the caller treats
+* both that and `strippedHref` as a failed override and falls back to the
+* built-in default.
+*/
+function sanitizeSvg(raw) {
+	strippedHref = false;
+	return {
+		markup: purify.sanitize(raw, SVG_SANITIZE_CONFIG),
+		strippedHref
+	};
+}
+//#endregion
+//#region src/shared/assets/instanceOverrides.ts
+var InstanceOverridesContext = Q({});
+var InstanceOverridesProvider = InstanceOverridesContext.Provider;
+function useInstanceOverrides() {
+	return x(InstanceOverridesContext);
+}
+//#endregion
+//#region src/shared/assets/assetRegistry.ts
+var defaultExport = (module) => module.default;
+var decorative = { ariaHidden: true };
+var assetRegistry = {
+	"faceMatch.success": { a11y: decorative },
+	"faceMatch.fail": { a11y: decorative },
+	"documentCapture.tutorial": { a11y: decorative },
+	"id.uploadScreen": { a11y: decorative },
+	"id.ageVerification.dob": { a11y: decorative },
+	"id.ageVerification.scan": { a11y: decorative },
+	"id.ageVerification.privacy": { a11y: decorative },
+	"videoSelfie.success": { a11y: decorative },
+	"videoSelfie.fail": { a11y: decorative },
+	"videoSelfie.tutorial.permission": { a11y: decorative },
+	"videoSelfie.tutorial.selfie": { a11y: decorative },
+	"videoSelfie.tutorial.frontId": { a11y: decorative },
+	"videoSelfie.tutorial.backId": { a11y: decorative },
+	"videoSelfie.tutorial.poa": { a11y: decorative },
+	"videoSelfie.tutorial.questions": { a11y: decorative },
+	"videoSelfie.tutorial.speech": { a11y: decorative },
+	"loader.spinner": { a11y: decorative }
+};
+var animationRegistry = {
+	"id.tutorial.front": {
+		default: () => import("./id-tutorial-BOOsXlAJ.js").then(defaultExport),
+		a11y: decorative
+	},
+	"id.tutorial.back": {
+		default: () => import("./back-tutorial-BHyRHyET.js").then(defaultExport),
+		a11y: decorative
+	},
+	"id.tutorial.passport": {
+		default: () => import("./passport-tutorial-CeSup6m9.js").then(defaultExport),
+		a11y: decorative
+	},
+	"id.flip": {
+		default: () => import("./flip-animation-CvN8FLNc.js").then(defaultExport),
+		a11y: decorative
+	},
+	"id.processing": {
+		default: {
+			horizontal: () => import("./id-laser-h-BaUHzX-d.js").then(defaultExport),
+			vertical: () => import("./id-laser-v-Dv9yEYJE.js").then(defaultExport)
+		},
+		a11y: decorative
+	},
+	"selfie.tutorial": {
+		default: () => import("./selfieTutorial-CYa8bq6B.js").then(defaultExport),
+		a11y: decorative
+	},
+	"loader.spinner": {
+		default: null,
+		a11y: decorative
+	}
+};
+//#endregion
+//#region src/shared/assets/resolveAsset.ts
+/**
+* Whether a resolved value represents an active override, as opposed to no
+* override at all (`type === 'default'`).
+*/
+function isActiveOverride(resolved) {
+	return resolved !== null && resolved.type !== "default";
+}
+function warnUnknownKey(key) {
+	`${key}`;
+}
+function isValidUrl(url) {
+	const SCHEME_PREFIX = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+	if (url === "" || /\s/.test(url)) return false;
+	if (!SCHEME_PREFIX.test(url)) return true;
+	try {
+		new URL(url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeAssetOverride(override) {
+	if (override === void 0) return null;
+	if (typeof override === "string") {
+		const value = override.trim();
+		if (value === "") return null;
+		if (value.startsWith("<")) return {
+			type: "override-raw",
+			raw: value
+		};
+		if (!isValidUrl(value)) return null;
+		return {
+			type: "override-url",
+			url: value
+		};
+	}
+	if ("svg" in override) return {
+		type: "override-component",
+		component: override.svg
+	};
+	if ("raw" in override) {
+		const raw = override.raw.trim();
+		return raw === "" ? null : {
+			type: "override-raw",
+			raw
+		};
+	}
+	if ("url" in override) {
+		const url = override.url.trim();
+		if (url === "") return null;
+		if (!isValidUrl(url)) return null;
+		return {
+			type: "override-url",
+			url
+		};
+	}
+	return null;
+}
+function normalizeAnimationOverride(override) {
+	if (override === void 0) return null;
+	if ("url" in override) {
+		const url = override.url.trim();
+		if (url === "") return null;
+		if (!isValidUrl(url)) return null;
+		return {
+			type: "override-url",
+			url
+		};
+	}
+	if ("animationData" in override) return {
+		type: "override-data",
+		animationData: override.animationData
+	};
+	return {
+		type: "override-data",
+		animationData: override
+	};
+}
+function resolveAsset(key, scopes = {}) {
+	scopes.instance;
+	scopes.global;
+	const entry = assetRegistry[key];
+	if (entry === void 0) {
+		warnUnknownKey(key);
+		return null;
+	}
+	const override = normalizeAssetOverride(scopes.instance?.[key]) ?? normalizeAssetOverride(scopes.global?.[key]);
+	if (override !== null) return {
+		...override,
+		a11y: entry.a11y
+	};
+	return {
+		type: "default",
+		a11y: entry.a11y
+	};
+}
+function resolveAnimation(key, scopes = {}) {
+	scopes.instance;
+	scopes.global;
+	const entry = animationRegistry[key];
+	if (entry === void 0) {
+		warnUnknownKey(key);
+		return null;
+	}
+	const override = normalizeAnimationOverride(scopes.instance?.[key]) ?? normalizeAnimationOverride(scopes.global?.[key]);
+	if (override !== null) return {
+		...override,
+		a11y: entry.a11y
+	};
+	return {
+		type: "default",
+		default: entry.default,
+		a11y: entry.a11y
+	};
+}
+//#endregion
+//#region src/shared/assets/useAsset.ts
+function useAsset(key) {
+	const instance = useInstanceOverrides();
+	const uiConfig = useUiConfig();
+	return T(() => {
+		return resolveAsset(key, {
+			instance: instance.assets,
+			global: uiConfig.assets
+		});
+	}, [
+		key,
+		instance.assets,
+		uiConfig.assets
+	]);
+}
+function useAnimation(key) {
+	const instance = useInstanceOverrides();
+	const uiConfig = useUiConfig();
+	return T(() => {
+		return resolveAnimation(key, {
+			instance: instance.animations,
+			global: uiConfig.animations
+		});
+	}, [
+		key,
+		instance.animations,
+		uiConfig.animations
+	]);
+}
+//#endregion
+//#region src/shared/assets/asset.tsx
+function altText(a11y, t) {
+	return "altKey" in a11y ? t(a11y.altKey) : "";
+}
+function svgA11y(a11y, t) {
+	return "altKey" in a11y ? {
+		role: "img",
+		"aria-label": t(a11y.altKey)
+	} : { "aria-hidden": "true" };
+}
+/**
+* Normalizes the call-site `default` into a renderable shape. Trusted (it is a
+* bundled SDK asset), so raw markup is not sanitized — unlike a customer raw
+* override.
+*/
+function defaultToRenderable(value) {
+	if (value === void 0) return null;
+	if (typeof value === "function") return {
+		kind: "component",
+		value
+	};
+	return value.trim().startsWith("<") ? {
+		kind: "raw",
+		value
+	} : {
+		kind: "url",
+		value
+	};
+}
+function useAssetContent(key, defaultAsset, onFallback) {
+	const resolved = useAsset(key);
+	const [failedUrl, setFailedUrl] = d(null);
+	const rawOverride = resolved?.type === "override-raw" ? resolved.raw : null;
+	const sanitizedRaw = T(() => rawOverride === null ? null : sanitizeSvg(rawOverride), [rawOverride]);
+	const urlFailed = resolved?.type === "override-url" && resolved.url === failedUrl;
+	const rawStripped = rawOverride !== null && (sanitizedRaw?.strippedHref === true || (sanitizedRaw?.markup ?? "").trim() === "");
+	y(() => {
+		if (urlFailed || rawStripped) onFallback?.();
+	}, [
+		urlFailed,
+		rawStripped,
+		onFallback
+	]);
+	if (resolved === null) return null;
+	const useDefault = resolved.type === "default" || urlFailed || rawStripped;
+	const { a11y } = resolved;
+	if (!useDefault) switch (resolved.type) {
+		case "override-component": return {
+			content: {
+				kind: "component",
+				value: resolved.component
+			},
+			a11y
+		};
+		case "override-url": return {
+			content: {
+				kind: "url",
+				value: resolved.url,
+				onError: () => setFailedUrl(resolved.url)
+			},
+			a11y
+		};
+		case "override-raw": return {
+			content: {
+				kind: "raw",
+				value: sanitizedRaw?.markup ?? ""
+			},
+			a11y
+		};
+	}
+	const content = defaultToRenderable(defaultAsset);
+	return content ? {
+		content,
+		a11y
+	} : null;
+}
+function renderAsset(content, a11y, t, className) {
+	switch (content.kind) {
+		case "component": {
+			const Svg = content.value;
+			return /* @__PURE__ */ u(Svg, {
+				class: className,
+				...svgA11y(a11y, t)
+			});
+		}
+		case "url": return /* @__PURE__ */ u("img", {
+			src: content.value,
+			alt: altText(a11y, t),
+			"aria-hidden": "altKey" in a11y ? void 0 : "true",
+			class: className,
+			onError: content.onError
+		});
+		case "raw": return /* @__PURE__ */ u("span", {
+			class: cn("IncodeAssetRaw", className),
+			...svgA11y(a11y, t),
+			dangerouslySetInnerHTML: { __html: content.value }
+		});
+		default: return content;
+	}
+}
+/**
+* Renders a branded illustration by catalog key, honoring the resolved
+* precedence (per-instance → global → built-in default). The built-in default
+* is supplied by the call site via `default` (imported on-site).
+*/
+function Asset({ name, class: className, default: defaultAsset, onFallback }) {
+	const { t } = useTranslation();
+	const result = useAssetContent(name, defaultAsset, onFallback);
+	if (result === null) return null;
+	return renderAsset(result.content, result.a11y, t, className);
+}
+//#endregion
+//#region src/shared/lottie/lottie.tsx
+var lottiePromise = null;
+async function loadLottie() {
+	if (lottiePromise) return lottiePromise;
+	lottiePromise = import("./lottie_light-Bv56F2Ae.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)).then((mod) => mod.default);
+	return lottiePromise;
+}
+var AUTO_STOP_AFTER_MS = 5e3;
+function Lottie({ animationData, loop = true, autoplay = true, reverse = false, style, className, onComplete, autoStop = false, stopFramePosition }) {
+	const containerRef = A(null);
+	const effectiveAutoplay = reverse ? false : autoplay;
+	const animationOptionsRef = A({
+		container: containerRef.current,
+		renderer: "svg",
+		loop,
+		autoplay: effectiveAutoplay,
+		animationData
+	});
+	y(() => {
+		animationOptionsRef.current = {
+			container: containerRef.current,
+			renderer: "svg",
+			loop,
+			autoplay: effectiveAutoplay,
+			animationData
+		};
+	}, [
+		animationData,
+		loop,
+		effectiveAutoplay
+	]);
+	y(() => {
+		if (!containerRef.current) return;
+		let anim;
+		let stopTimer;
+		let isMounted = true;
+		loadLottie().then((lottie) => {
+			if (!isMounted) return;
+			anim = lottie.loadAnimation(animationOptionsRef.current);
+			if (reverse) {
+				anim.setDirection(-1);
+				anim.goToAndPlay(anim.totalFrames - 1, true);
+			}
+			if (onComplete) anim.addEventListener("complete", onComplete);
+			if (autoStop) stopTimer = window.setTimeout(() => {
+				const current = anim;
+				if (!current) return;
+				if (!stopFramePosition) {
+					current.pause();
+					return;
+				}
+				const totalFrames = current.totalFrames;
+				if (!totalFrames || totalFrames <= 0) {
+					current.stop();
+					return;
+				}
+				const targetFrame = stopFramePosition === "last" ? Math.max(totalFrames - 1, 0) : stopFramePosition === "first" ? 0 : Math.floor((totalFrames - 1) / 2);
+				current.goToAndStop(targetFrame, true);
+			}, AUTO_STOP_AFTER_MS);
+		});
+		return () => {
+			isMounted = false;
+			if (stopTimer !== void 0) window.clearTimeout(stopTimer);
+			if (anim) {
+				if (onComplete) anim.removeEventListener("complete", onComplete);
+				anim.destroy();
+			}
+		};
+	}, [
+		onComplete,
+		reverse,
+		autoStop,
+		stopFramePosition
+	]);
+	return /* @__PURE__ */ u("div", {
+		ref: containerRef,
+		style,
+		className,
+		"aria-hidden": "true"
+	});
+}
+//#endregion
+//#region src/shared/assets/animatedAsset.tsx
+var overrideUrlCache = /* @__PURE__ */ new Map();
+function fetchAnimation(url) {
+	const cached = overrideUrlCache.get(url);
+	if (cached) return cached;
+	const pending = fetch(url).then((response) => {
+		if (!response.ok) throw new Error(`Request for "${url}" failed with status ${response.status}.`);
+		return response.json();
+	});
+	overrideUrlCache.set(url, pending);
+	pending.catch(() => overrideUrlCache.delete(url));
+	return pending;
+}
+function loadAnimationDefault(def, orientation) {
+	if (def === null) return Promise.resolve(null);
+	if (typeof def === "function") return def();
+	return def[orientation]();
+}
+var defaultCache = /* @__PURE__ */ new Map();
+function defaultCacheKey(name, orientation) {
+	return `${name}|${orientation}`;
+}
+function loadDefaultCached(name, orientation) {
+	const cacheKey = defaultCacheKey(name, orientation);
+	if (defaultCache.has(cacheKey)) return Promise.resolve(defaultCache.get(cacheKey) ?? null);
+	return loadAnimationDefault(animationRegistry[name]?.default ?? null, orientation).then((value) => {
+		defaultCache.set(cacheKey, value);
+		return value;
+	});
+}
+/**
+* Warms the built-in animation cache for the given catalog keys so a later
+* render is synchronous (no flash). Best-effort; call it before the screen
+* mounts.
+*/
+function preloadAnimations(keys, orientation = "vertical") {
+	for (const key of keys) loadDefaultCached(key, orientation).catch(() => {});
+}
+/**
+* Resolves the winning animation to parsed `animationData` plus whether it came
+* from a customer override. Reads the default cache synchronously on first
+* render, so a preloaded animation shows with no flash. A failed override URL
+* silently falls back to the built-in default.
+*
+* Shared by `AnimatedAsset` and by tutorial surfaces that render Lottie
+* themselves (e.g. `BaseTutorial`, which recolors only built-in defaults).
+*
+* `onFallback`, if given, fires only when a *configured* override actually
+* fails to load (never when there was simply no override to begin with) —
+* for a caller whose true fallback lives outside this system entirely, so it
+* can react to a real failure instead of committing to render this component before
+* knowing whether the override will actually work.
+*/
+function useAnimationData(name, orientation = "vertical", onFallback) {
+	const resolved = useAnimation(name);
+	const type = resolved?.type;
+	const isOverride = isActiveOverride(resolved);
+	const overrideUrl = resolved?.type === "override-url" ? resolved.url : void 0;
+	const overrideData = resolved?.type === "override-data" ? resolved.animationData : void 0;
+	const [data, setData] = d(() => {
+		if (type === "override-data") return overrideData ?? null;
+		if (type === "default") return defaultCache.get(defaultCacheKey(name, orientation)) ?? null;
+		return null;
+	});
+	const [overrideFailed, setOverrideFailed] = d(false);
+	y(() => {
+		let active = true;
+		setOverrideFailed(false);
+		if (type === void 0) setData(null);
+		else if (type === "override-data") setData(overrideData ?? null);
+		else if (type === "override-url" && overrideUrl !== void 0) fetchAnimation(overrideUrl).then((value) => {
+			if (active) setData(value);
+		}, (error) => {
+			`${name}`;
+			if (active) {
+				setOverrideFailed(true);
+				loadDefaultCached(name, orientation).then((value) => {
+					if (active) setData(value);
+				}, () => {});
+			}
+		});
+		else loadDefaultCached(name, orientation).then((value) => {
+			if (active) setData(value);
+		}, (error) => {
+			if (active) {
+				setData(null);
+				`${name}`;
+			}
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		name,
+		orientation,
+		type,
+		overrideUrl,
+		overrideData
+	]);
+	y(() => {
+		if (overrideFailed) onFallback?.();
+	}, [overrideFailed, onFallback]);
+	return {
+		data,
+		isOverride
+	};
+}
+/**
+* Renders a Lottie animation by catalog key, honoring the resolved precedence
+* (per-instance → global → built-in default). Renders nothing while pending or
+* when there is no Lottie to show; the container is `aria-hidden` (all catalog
+* animations are decorative).
+*/
+function AnimatedAsset({ name, autoStop, stopFramePosition, orientation = "vertical", loop, reverse, onComplete, class: className, onFallback }) {
+	const { data } = useAnimationData(name, orientation, onFallback);
+	if (data === null) return null;
+	return /* @__PURE__ */ u(Lottie, {
+		animationData: data,
+		autoStop,
+		stopFramePosition,
+		loop,
+		reverse,
+		onComplete,
+		className
+	});
+}
+//#endregion
+//#region src/shared/loader/loadingIcon.tsx
+/**
+* Duration of the CSS spin animation on `.IncodeLoadingIcon`.
+* Must stay in sync with the `animation-duration` declared in the stylesheet.
+*/
+var SPIN_DURATION_MS = 1e3;
+var SpinnerPrimary = ({ size, className }) => {
+	return /* @__PURE__ */ u("svg", {
+		width: size,
+		height: size,
+		viewBox: "0 0 31 31",
+		fill: "none",
+		xmlns: "http://www.w3.org/2000/svg",
+		class: cn("IncodeLoadingIconPrimaryIcon", className),
+		"aria-hidden": "true",
+		children: /* @__PURE__ */ u("path", { d: "M28.1614 15.2837C29.453 15.2837 30.5186 14.2304 30.3181 12.9545C30.1344 11.7862 29.8129 10.6411 29.3582 9.54344C28.6044 7.72356 27.4995 6.06997 26.1066 4.67709C24.7137 3.28421 23.0601 2.17932 21.2403 1.4255C20.1426 0.970841 18.9974 0.649265 17.8292 0.46563C16.5533 0.265073 15.5 1.33073 15.5 2.62232C15.5 3.91391 16.5601 4.93461 17.8187 5.22473C18.3748 5.35291 18.9206 5.52729 19.4503 5.74672C20.7028 6.26548 21.8407 7.02585 22.7993 7.98441C23.7578 8.94296 24.5182 10.0809 25.037 11.3333C25.2564 11.8631 25.4308 12.4089 25.559 12.965C25.8491 14.2236 26.8698 15.2837 28.1614 15.2837Z" })
+	});
+};
+var SpinnerSecondary = ({ size, className }) => {
+	return /* @__PURE__ */ u("svg", {
+		width: size,
+		height: size,
+		viewBox: "0 0 31 31",
+		fill: "none",
+		xmlns: "http://www.w3.org/2000/svg",
+		class: cn("IncodeLoadingIconSecondaryIcon", className),
+		"aria-hidden": "true",
+		children: [/* @__PURE__ */ u("title", { children: "Spinner Outer part" }), /* @__PURE__ */ u("path", { d: "M30.5 15.2837C30.5 23.568 23.7843 30.2837 15.5 30.2837C7.21573 30.2837 0.5 23.568 0.5 15.2837C0.5 6.99942 7.21573 0.283691 15.5 0.283691C23.7843 0.283691 30.5 6.99942 30.5 15.2837ZM5.17725 15.2837C5.17725 20.9848 9.7989 25.6064 15.5 25.6064C21.2011 25.6064 25.8227 20.9848 25.8227 15.2837C25.8227 9.5826 21.2011 4.96095 15.5 4.96095C9.7989 4.96095 5.17725 9.5826 5.17725 15.2837Z" })]
+	});
+};
+var LoadingIcon = ({ size = 30, secondaryClass, primaryClass }) => {
+	const ref = A(null);
+	const overrideRef = A(null);
+	const animation = useAnimation("loader.spinner");
+	const svg = useAsset("loader.spinner");
+	const hasAnimationOverride = isActiveOverride(animation);
+	const hasSvgOverride = isActiveOverride(svg);
+	const [overrideFailed, setOverrideFailed] = d(false);
+	const handleFallback = q(() => setOverrideFailed(true), []);
+	const hasOverride = (hasAnimationOverride || hasSvgOverride) && !overrideFailed;
+	/**
+	* Cross-module loaders (e.g. ID processing → selfie initialising) unmount
+	* and remount this component as the user moves between flow steps. By
+	* default each remount restarts the CSS spin animation from frame 0, which
+	* reads as a visible "stutter" or reset of the spinner during otherwise
+	* seamless transitions.
+	*
+	* To keep the rotation continuous across remounts we anchor the animation
+	* to a wall-clock offset: `performance.now() % SPIN_DURATION_MS` tells us
+	* how far into the current spin cycle we are, and applying it as a
+	* negative `animation-delay` makes the new instance pick up exactly where
+	* the previous one left off. (Built-in default only.)
+	*/
+	_(() => {
+		if (hasOverride || !ref.current) return;
+		const offsetMs = performance.now() % SPIN_DURATION_MS;
+		ref.current.style.animationDelay = `-${offsetMs}ms`;
+	}, [hasOverride]);
+	_(() => {
+		if (!overrideRef.current) return;
+		overrideRef.current.style.width = `${size}px`;
+		overrideRef.current.style.height = `${size}px`;
+	}, [size, hasOverride]);
+	if (hasOverride) return /* @__PURE__ */ u("div", {
+		ref: overrideRef,
+		class: "IncodeLoadingIconOverride",
+		children: hasAnimationOverride ? /* @__PURE__ */ u(AnimatedAsset, {
+			name: "loader.spinner",
+			loop: true,
+			onFallback: handleFallback
+		}) : /* @__PURE__ */ u(Asset, {
+			name: "loader.spinner",
+			onFallback: handleFallback
+		})
+	});
+	return /* @__PURE__ */ u("div", {
+		ref,
+		class: "IncodeLoadingIcon",
+		children: [/* @__PURE__ */ u(SpinnerSecondary, {
+			size,
+			className: secondaryClass
+		}), /* @__PURE__ */ u("div", {
+			class: "IncodeLoadingIconPrimary",
+			children: /* @__PURE__ */ u(SpinnerPrimary, {
+				size,
+				className: primaryClass
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/shared/spacer/spacer.tsx
+var scaleTokens = new Set([
+	0,
+	2,
+	4,
+	8,
+	12,
+	16,
+	20,
+	24,
+	32,
+	40,
+	48,
+	64,
+	80,
+	96,
+	104,
+	120,
+	200
+]);
+var scaleToClassName = (size, direction) => {
+	if (direction === "horizontal") return {
+		0: "IncodeSpacerHorizontal0",
+		2: "IncodeSpacerHorizontal2",
+		4: "IncodeSpacerHorizontal4",
+		8: "IncodeSpacerHorizontal8",
+		12: "IncodeSpacerHorizontal12",
+		16: "IncodeSpacerHorizontal16",
+		20: "IncodeSpacerHorizontal20",
+		24: "IncodeSpacerHorizontal24",
+		32: "IncodeSpacerHorizontal32",
+		40: "IncodeSpacerHorizontal40",
+		48: "IncodeSpacerHorizontal48",
+		64: "IncodeSpacerHorizontal64",
+		80: "IncodeSpacerHorizontal80",
+		96: "IncodeSpacerHorizontal96",
+		104: "IncodeSpacerHorizontal104",
+		120: "IncodeSpacerHorizontal120",
+		200: "IncodeSpacerHorizontal200"
+	}[size];
+	return {
+		0: "IncodeSpacerVertical0",
+		2: "IncodeSpacerVertical2",
+		4: "IncodeSpacerVertical4",
+		8: "IncodeSpacerVertical8",
+		12: "IncodeSpacerVertical12",
+		16: "IncodeSpacerVertical16",
+		20: "IncodeSpacerVertical20",
+		24: "IncodeSpacerVertical24",
+		32: "IncodeSpacerVertical32",
+		40: "IncodeSpacerVertical40",
+		48: "IncodeSpacerVertical48",
+		64: "IncodeSpacerVertical64",
+		80: "IncodeSpacerVertical80",
+		96: "IncodeSpacerVertical96",
+		104: "IncodeSpacerVertical104",
+		120: "IncodeSpacerVertical120",
+		200: "IncodeSpacerVertical200"
+	}[size];
+};
+var Spacer = ({ size, className, direction = "vertical" }) => {
+	if (size === void 0) return /* @__PURE__ */ u("div", { class: `IncodeSpacerFlex ${className || ""}` });
+	if (!(direction === "horizontal" ? "w" : direction === "vertical" ? "h" : void 0)) return /* @__PURE__ */ u("div", { class: `${className || ""}` });
+	if (typeof size === "number" && scaleTokens.has(size)) return /* @__PURE__ */ u("div", { class: `${scaleToClassName(size, direction)} ${className || ""}` });
+	return /* @__PURE__ */ u("div", { class: `${className || ""}` });
+};
+//#endregion
+export { useAnimationData as a, InstanceOverridesProvider as c, preloadAnimations as i, purify$1 as l, LoadingIcon as n, Lottie as o, AnimatedAsset as r, Asset as s, Spacer as t, cn as u };