@incodetech/web 2.0.1 → 2.1.0-rc.1

package/dist/bottomSheet-F1GJfQx_.js

@@ -0,0 +1,39 @@
+import { h as q, l as A, v as u } from "./vendor-preact-DThS2ZQ_.js";
+import { i as useModalFocusCapture, n as useModalBodyScrollLock, o as useModalTabCycle, r as useModalEscapeDismiss, s as useModalVisualViewportBounds } from "./modal.hooks-D2xhIuHA.js";
+//#region src/shared/bottomSheet/bottomSheet.tsx
+var BottomSheet = ({ isOpen = false, onClose, labelledById, children }) => {
+	const dialogRef = A(null);
+	const overlayRef = A(null);
+	const requestClose = q(() => {
+		onClose?.();
+	}, [onClose]);
+	useModalBodyScrollLock(isOpen);
+	useModalEscapeDismiss(isOpen, true, requestClose);
+	useModalFocusCapture(isOpen, dialogRef);
+	useModalTabCycle(isOpen, dialogRef);
+	useModalVisualViewportBounds(isOpen, overlayRef);
+	if (!isOpen) return null;
+	return /* @__PURE__ */ u("div", {
+		ref: overlayRef,
+		class: "IncodeBottomSheetOverlay",
+		onClick: (event) => {
+			if (event.target === event.currentTarget) requestClose();
+		},
+		children: /* @__PURE__ */ u("div", {
+			class: "IncodeBottomSheetContainer",
+			onClick: requestClose,
+			children: /* @__PURE__ */ u("div", {
+				ref: dialogRef,
+				class: "IncodeBottomSheet",
+				role: "dialog",
+				"aria-modal": "true",
+				"aria-labelledby": labelledById,
+				tabIndex: -1,
+				onClick: (event) => event.stopPropagation(),
+				children
+			})
+		})
+	});
+};
+//#endregion
+export { BottomSheet as t };

package/dist/browser-ponyfill-CLLvZCVg.js

@@ -0,0 +1,441 @@
+import { t as __commonJSMin } from "./rolldown-runtime--E5BIlTp.js";
+//#region ../../node_modules/.pnpm/cross-fetch@4.0.0/node_modules/cross-fetch/dist/browser-ponyfill.js
+var require_browser_ponyfill = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __global__ = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof global !== "undefined" && global;
+	var __globalThis__ = (function() {
+		function F() {
+			this.fetch = false;
+			this.DOMException = __global__.DOMException;
+		}
+		F.prototype = __global__;
+		return new F();
+	})();
+	(function(globalThis) {
+		(function(exports$1) {
+			var global = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof global !== "undefined" && global;
+			var support = {
+				searchParams: "URLSearchParams" in global,
+				iterable: "Symbol" in global && "iterator" in Symbol,
+				blob: "FileReader" in global && "Blob" in global && (function() {
+					try {
+						new Blob();
+						return true;
+					} catch (e) {
+						return false;
+					}
+				})(),
+				formData: "FormData" in global,
+				arrayBuffer: "ArrayBuffer" in global
+			};
+			function isDataView(obj) {
+				return obj && DataView.prototype.isPrototypeOf(obj);
+			}
+			if (support.arrayBuffer) {
+				var viewClasses = [
+					"[object Int8Array]",
+					"[object Uint8Array]",
+					"[object Uint8ClampedArray]",
+					"[object Int16Array]",
+					"[object Uint16Array]",
+					"[object Int32Array]",
+					"[object Uint32Array]",
+					"[object Float32Array]",
+					"[object Float64Array]"
+				];
+				var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+					return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+				};
+			}
+			function normalizeName(name) {
+				if (typeof name !== "string") name = String(name);
+				if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") throw new TypeError("Invalid character in header field name: \"" + name + "\"");
+				return name.toLowerCase();
+			}
+			function normalizeValue(value) {
+				if (typeof value !== "string") value = String(value);
+				return value;
+			}
+			function iteratorFor(items) {
+				var iterator = { next: function() {
+					var value = items.shift();
+					return {
+						done: value === void 0,
+						value
+					};
+				} };
+				if (support.iterable) iterator[Symbol.iterator] = function() {
+					return iterator;
+				};
+				return iterator;
+			}
+			function Headers(headers) {
+				this.map = {};
+				if (headers instanceof Headers) headers.forEach(function(value, name) {
+					this.append(name, value);
+				}, this);
+				else if (Array.isArray(headers)) headers.forEach(function(header) {
+					this.append(header[0], header[1]);
+				}, this);
+				else if (headers) Object.getOwnPropertyNames(headers).forEach(function(name) {
+					this.append(name, headers[name]);
+				}, this);
+			}
+			Headers.prototype.append = function(name, value) {
+				name = normalizeName(name);
+				value = normalizeValue(value);
+				var oldValue = this.map[name];
+				this.map[name] = oldValue ? oldValue + ", " + value : value;
+			};
+			Headers.prototype["delete"] = function(name) {
+				delete this.map[normalizeName(name)];
+			};
+			Headers.prototype.get = function(name) {
+				name = normalizeName(name);
+				return this.has(name) ? this.map[name] : null;
+			};
+			Headers.prototype.has = function(name) {
+				return this.map.hasOwnProperty(normalizeName(name));
+			};
+			Headers.prototype.set = function(name, value) {
+				this.map[normalizeName(name)] = normalizeValue(value);
+			};
+			Headers.prototype.forEach = function(callback, thisArg) {
+				for (var name in this.map) if (this.map.hasOwnProperty(name)) callback.call(thisArg, this.map[name], name, this);
+			};
+			Headers.prototype.keys = function() {
+				var items = [];
+				this.forEach(function(value, name) {
+					items.push(name);
+				});
+				return iteratorFor(items);
+			};
+			Headers.prototype.values = function() {
+				var items = [];
+				this.forEach(function(value) {
+					items.push(value);
+				});
+				return iteratorFor(items);
+			};
+			Headers.prototype.entries = function() {
+				var items = [];
+				this.forEach(function(value, name) {
+					items.push([name, value]);
+				});
+				return iteratorFor(items);
+			};
+			if (support.iterable) Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+			function consumed(body) {
+				if (body.bodyUsed) return Promise.reject(/* @__PURE__ */ new TypeError("Already read"));
+				body.bodyUsed = true;
+			}
+			function fileReaderReady(reader) {
+				return new Promise(function(resolve, reject) {
+					reader.onload = function() {
+						resolve(reader.result);
+					};
+					reader.onerror = function() {
+						reject(reader.error);
+					};
+				});
+			}
+			function readBlobAsArrayBuffer(blob) {
+				var reader = new FileReader();
+				var promise = fileReaderReady(reader);
+				reader.readAsArrayBuffer(blob);
+				return promise;
+			}
+			function readBlobAsText(blob) {
+				var reader = new FileReader();
+				var promise = fileReaderReady(reader);
+				reader.readAsText(blob);
+				return promise;
+			}
+			function readArrayBufferAsText(buf) {
+				var view = new Uint8Array(buf);
+				var chars = new Array(view.length);
+				for (var i = 0; i < view.length; i++) chars[i] = String.fromCharCode(view[i]);
+				return chars.join("");
+			}
+			function bufferClone(buf) {
+				if (buf.slice) return buf.slice(0);
+				else {
+					var view = new Uint8Array(buf.byteLength);
+					view.set(new Uint8Array(buf));
+					return view.buffer;
+				}
+			}
+			function Body() {
+				this.bodyUsed = false;
+				this._initBody = function(body) {
+					this.bodyUsed = this.bodyUsed;
+					this._bodyInit = body;
+					if (!body) this._bodyText = "";
+					else if (typeof body === "string") this._bodyText = body;
+					else if (support.blob && Blob.prototype.isPrototypeOf(body)) this._bodyBlob = body;
+					else if (support.formData && FormData.prototype.isPrototypeOf(body)) this._bodyFormData = body;
+					else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) this._bodyText = body.toString();
+					else if (support.arrayBuffer && support.blob && isDataView(body)) {
+						this._bodyArrayBuffer = bufferClone(body.buffer);
+						this._bodyInit = new Blob([this._bodyArrayBuffer]);
+					} else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) this._bodyArrayBuffer = bufferClone(body);
+					else this._bodyText = body = Object.prototype.toString.call(body);
+					if (!this.headers.get("content-type")) {
+						if (typeof body === "string") this.headers.set("content-type", "text/plain;charset=UTF-8");
+						else if (this._bodyBlob && this._bodyBlob.type) this.headers.set("content-type", this._bodyBlob.type);
+						else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+					}
+				};
+				if (support.blob) {
+					this.blob = function() {
+						var rejected = consumed(this);
+						if (rejected) return rejected;
+						if (this._bodyBlob) return Promise.resolve(this._bodyBlob);
+						else if (this._bodyArrayBuffer) return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+						else if (this._bodyFormData) throw new Error("could not read FormData body as blob");
+						else return Promise.resolve(new Blob([this._bodyText]));
+					};
+					this.arrayBuffer = function() {
+						if (this._bodyArrayBuffer) {
+							var isConsumed = consumed(this);
+							if (isConsumed) return isConsumed;
+							if (ArrayBuffer.isView(this._bodyArrayBuffer)) return Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset, this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength));
+							else return Promise.resolve(this._bodyArrayBuffer);
+						} else return this.blob().then(readBlobAsArrayBuffer);
+					};
+				}
+				this.text = function() {
+					var rejected = consumed(this);
+					if (rejected) return rejected;
+					if (this._bodyBlob) return readBlobAsText(this._bodyBlob);
+					else if (this._bodyArrayBuffer) return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+					else if (this._bodyFormData) throw new Error("could not read FormData body as text");
+					else return Promise.resolve(this._bodyText);
+				};
+				if (support.formData) this.formData = function() {
+					return this.text().then(decode);
+				};
+				this.json = function() {
+					return this.text().then(JSON.parse);
+				};
+				return this;
+			}
+			var methods = [
+				"DELETE",
+				"GET",
+				"HEAD",
+				"OPTIONS",
+				"POST",
+				"PUT"
+			];
+			function normalizeMethod(method) {
+				var upcased = method.toUpperCase();
+				return methods.indexOf(upcased) > -1 ? upcased : method;
+			}
+			function Request(input, options) {
+				if (!(this instanceof Request)) throw new TypeError("Please use the \"new\" operator, this DOM object constructor cannot be called as a function.");
+				options = options || {};
+				var body = options.body;
+				if (input instanceof Request) {
+					if (input.bodyUsed) throw new TypeError("Already read");
+					this.url = input.url;
+					this.credentials = input.credentials;
+					if (!options.headers) this.headers = new Headers(input.headers);
+					this.method = input.method;
+					this.mode = input.mode;
+					this.signal = input.signal;
+					if (!body && input._bodyInit != null) {
+						body = input._bodyInit;
+						input.bodyUsed = true;
+					}
+				} else this.url = String(input);
+				this.credentials = options.credentials || this.credentials || "same-origin";
+				if (options.headers || !this.headers) this.headers = new Headers(options.headers);
+				this.method = normalizeMethod(options.method || this.method || "GET");
+				this.mode = options.mode || this.mode || null;
+				this.signal = options.signal || this.signal;
+				this.referrer = null;
+				if ((this.method === "GET" || this.method === "HEAD") && body) throw new TypeError("Body not allowed for GET or HEAD requests");
+				this._initBody(body);
+				if (this.method === "GET" || this.method === "HEAD") {
+					if (options.cache === "no-store" || options.cache === "no-cache") {
+						var reParamSearch = /([?&])_=[^&]*/;
+						if (reParamSearch.test(this.url)) this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
+						else this.url += (/\?/.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
+					}
+				}
+			}
+			Request.prototype.clone = function() {
+				return new Request(this, { body: this._bodyInit });
+			};
+			function decode(body) {
+				var form = new FormData();
+				body.trim().split("&").forEach(function(bytes) {
+					if (bytes) {
+						var split = bytes.split("=");
+						var name = split.shift().replace(/\+/g, " ");
+						var value = split.join("=").replace(/\+/g, " ");
+						form.append(decodeURIComponent(name), decodeURIComponent(value));
+					}
+				});
+				return form;
+			}
+			function parseHeaders(rawHeaders) {
+				var headers = new Headers();
+				rawHeaders.replace(/\r?\n[\t ]+/g, " ").split("\r").map(function(header) {
+					return header.indexOf("\n") === 0 ? header.substr(1, header.length) : header;
+				}).forEach(function(line) {
+					var parts = line.split(":");
+					var key = parts.shift().trim();
+					if (key) {
+						var value = parts.join(":").trim();
+						headers.append(key, value);
+					}
+				});
+				return headers;
+			}
+			Body.call(Request.prototype);
+			function Response(bodyInit, options) {
+				if (!(this instanceof Response)) throw new TypeError("Please use the \"new\" operator, this DOM object constructor cannot be called as a function.");
+				if (!options) options = {};
+				this.type = "default";
+				this.status = options.status === void 0 ? 200 : options.status;
+				this.ok = this.status >= 200 && this.status < 300;
+				this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
+				this.headers = new Headers(options.headers);
+				this.url = options.url || "";
+				this._initBody(bodyInit);
+			}
+			Body.call(Response.prototype);
+			Response.prototype.clone = function() {
+				return new Response(this._bodyInit, {
+					status: this.status,
+					statusText: this.statusText,
+					headers: new Headers(this.headers),
+					url: this.url
+				});
+			};
+			Response.error = function() {
+				var response = new Response(null, {
+					status: 0,
+					statusText: ""
+				});
+				response.type = "error";
+				return response;
+			};
+			var redirectStatuses = [
+				301,
+				302,
+				303,
+				307,
+				308
+			];
+			Response.redirect = function(url, status) {
+				if (redirectStatuses.indexOf(status) === -1) throw new RangeError("Invalid status code");
+				return new Response(null, {
+					status,
+					headers: { location: url }
+				});
+			};
+			exports$1.DOMException = global.DOMException;
+			try {
+				new exports$1.DOMException();
+			} catch (err) {
+				exports$1.DOMException = function(message, name) {
+					this.message = message;
+					this.name = name;
+					this.stack = Error(message).stack;
+				};
+				exports$1.DOMException.prototype = Object.create(Error.prototype);
+				exports$1.DOMException.prototype.constructor = exports$1.DOMException;
+			}
+			function fetch(input, init) {
+				return new Promise(function(resolve, reject) {
+					var request = new Request(input, init);
+					if (request.signal && request.signal.aborted) return reject(new exports$1.DOMException("Aborted", "AbortError"));
+					var xhr = new XMLHttpRequest();
+					function abortXhr() {
+						xhr.abort();
+					}
+					xhr.onload = function() {
+						var options = {
+							status: xhr.status,
+							statusText: xhr.statusText,
+							headers: parseHeaders(xhr.getAllResponseHeaders() || "")
+						};
+						options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
+						var body = "response" in xhr ? xhr.response : xhr.responseText;
+						setTimeout(function() {
+							resolve(new Response(body, options));
+						}, 0);
+					};
+					xhr.onerror = function() {
+						setTimeout(function() {
+							reject(/* @__PURE__ */ new TypeError("Network request failed"));
+						}, 0);
+					};
+					xhr.ontimeout = function() {
+						setTimeout(function() {
+							reject(/* @__PURE__ */ new TypeError("Network request failed"));
+						}, 0);
+					};
+					xhr.onabort = function() {
+						setTimeout(function() {
+							reject(new exports$1.DOMException("Aborted", "AbortError"));
+						}, 0);
+					};
+					function fixUrl(url) {
+						try {
+							return url === "" && global.location.href ? global.location.href : url;
+						} catch (e) {
+							return url;
+						}
+					}
+					xhr.open(request.method, fixUrl(request.url), true);
+					if (request.credentials === "include") xhr.withCredentials = true;
+					else if (request.credentials === "omit") xhr.withCredentials = false;
+					if ("responseType" in xhr) {
+						if (support.blob) xhr.responseType = "blob";
+						else if (support.arrayBuffer && request.headers.get("Content-Type") && request.headers.get("Content-Type").indexOf("application/octet-stream") !== -1) xhr.responseType = "arraybuffer";
+					}
+					if (init && typeof init.headers === "object" && !(init.headers instanceof Headers)) Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+						xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+					});
+					else request.headers.forEach(function(value, name) {
+						xhr.setRequestHeader(name, value);
+					});
+					if (request.signal) {
+						request.signal.addEventListener("abort", abortXhr);
+						xhr.onreadystatechange = function() {
+							if (xhr.readyState === 4) request.signal.removeEventListener("abort", abortXhr);
+						};
+					}
+					xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
+				});
+			}
+			fetch.polyfill = true;
+			if (!global.fetch) {
+				global.fetch = fetch;
+				global.Headers = Headers;
+				global.Request = Request;
+				global.Response = Response;
+			}
+			exports$1.Headers = Headers;
+			exports$1.Request = Request;
+			exports$1.Response = Response;
+			exports$1.fetch = fetch;
+			return exports$1;
+		})({});
+	})(__globalThis__);
+	__globalThis__.fetch.ponyfill = true;
+	delete __globalThis__.fetch.polyfill;
+	var ctx = __global__.fetch ? __global__ : __globalThis__;
+	exports = ctx.fetch;
+	exports.default = ctx.fetch;
+	exports.fetch = ctx.fetch;
+	exports.Headers = ctx.Headers;
+	exports.Request = ctx.Request;
+	exports.Response = ctx.Response;
+	module.exports = exports;
+}));
+//#endregion
+export default require_browser_ponyfill();

package/dist/button-CM_hgyIP.js

@@ -0,0 +1,35 @@
+import { a as D, v as u, x as k } from "./vendor-preact-DThS2ZQ_.js";
+import { n as cn, t as LoadingIcon } from "./loadingIcon-B0ysgiNq.js";
+//#region src/shared/button/button.tsx
+var LOADER_SIZE = 30;
+var variantClass = {
+	primary: "IncodeButtonPrimary",
+	secondary: "IncodeButtonSecondary",
+	link: "IncodeButtonLink"
+};
+var sizeClass = {
+	L: "IncodeButtonL",
+	M: "IncodeButtonM",
+	S: "IncodeButtonS"
+};
+var Button = D((props, ref) => {
+	const { isLoading = false, variant = "primary", size = "L", icon, class: className, type = "button", children, disabled, ...rest } = props;
+	const iconOnly = !children && !!icon;
+	const showLoader = isLoading && size === "L";
+	const renderContent = () => {
+		if (showLoader) return /* @__PURE__ */ u(LoadingIcon, { size: LOADER_SIZE });
+		if (iconOnly) return icon;
+		if (icon) return /* @__PURE__ */ u(k, { children: [children, icon] });
+		return children;
+	};
+	return /* @__PURE__ */ u("button", {
+		ref,
+		...rest,
+		class: cn("IncodeButton", variantClass[variant], sizeClass[size], showLoader ? "IncodeButtonLoading" : "", iconOnly ? "IncodeButtonIconOnly" : "", className),
+		disabled: disabled || showLoader,
+		type,
+		children: renderContent()
+	});
+});
+//#endregion
+export { Button as t };

package/dist/checkbox-BoeLHKgp.js

@@ -0,0 +1,96 @@
+import { a as D, p as d, v as u } from "./vendor-preact-DThS2ZQ_.js";
+import { n as cn } from "./loadingIcon-B0ysgiNq.js";
+import { t as ErrorIcon } from "./errorIcon-DJRZpd8j.js";
+import { d as CheckmarkIcon } from "./icons-Dbs9ZfYM.js";
+//#region src/shared/checkbox/checkbox.tsx
+var Checkbox = D(({ id, label, labelHint, size = "m", checked, defaultChecked, disabled = false, required = false, name, value, onChange, error, helper, showErrorIcon = true, class: className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, ...restProps }, ref) => {
+	const [internalChecked, setInternalChecked] = d(!!defaultChecked);
+	const isControlled = checked !== void 0;
+	const isChecked = isControlled ? !!checked : internalChecked;
+	const isDisabled = !!disabled;
+	const isRequired = !!required;
+	const classStr = typeof className === "string" ? className : void 0;
+	const handleChange = (event) => {
+		if (!isControlled) setInternalChecked(event.target.checked);
+		onChange?.(event);
+	};
+	const helperTextId = helper ? `${id}-helper` : void 0;
+	const errorTextId = error ? `${id}-error` : void 0;
+	const describedBy = [
+		ariaDescribedBy,
+		errorTextId,
+		helperTextId
+	].filter(Boolean).join(" ") || void 0;
+	return /* @__PURE__ */ u("div", {
+		class: cn("IncodeCheckbox", classStr),
+		children: [
+			/* @__PURE__ */ u("label", {
+				class: cn("IncodeCheckboxLabel", { IncodeCheckboxLabelDisabled: isDisabled }),
+				htmlFor: id,
+				children: [/* @__PURE__ */ u("div", {
+					class: "relative inline-flex",
+					children: [/* @__PURE__ */ u("input", {
+						ref,
+						type: "checkbox",
+						class: "IncodeCheckboxInput",
+						id,
+						name,
+						value,
+						...isControlled ? { checked } : { defaultChecked },
+						disabled,
+						required,
+						onChange: handleChange,
+						"aria-label": ariaLabel,
+						"aria-labelledby": ariaLabelledBy,
+						"aria-describedby": describedBy,
+						"aria-invalid": ariaInvalid || !!error,
+						"aria-required": isRequired,
+						...restProps
+					}), /* @__PURE__ */ u("div", {
+						class: cn("IncodeCheckboxVisual", {
+							IncodeCheckboxVisualChecked: isChecked,
+							IncodeCheckboxVisualDisabled: isDisabled,
+							IncodeCheckboxVisualError: !!error
+						}),
+						children: isChecked && /* @__PURE__ */ u(CheckmarkIcon, { size: 28 })
+					})]
+				}), label && /* @__PURE__ */ u("span", {
+					class: cn("IncodeCheckboxText", {
+						IncodeCheckboxTextS: size === "s",
+						IncodeCheckboxTextM: size === "m",
+						IncodeCheckboxTextDisabled: isDisabled
+					}),
+					"aria-hidden": ariaLabelledBy ? "true" : void 0,
+					children: [label, labelHint && /* @__PURE__ */ u("span", {
+						class: "IncodeCheckboxLabelHint",
+						"data-testid": `${id}-label-hint`,
+						children: labelHint
+					})]
+				})]
+			}),
+			error && /* @__PURE__ */ u("div", {
+				class: "IncodeCheckboxMessageWrapper",
+				"data-testid": `${id}-error-wrapper`,
+				children: [showErrorIcon && /* @__PURE__ */ u("div", {
+					class: "IncodeCheckboxIconWrapper",
+					children: /* @__PURE__ */ u(ErrorIcon, { size: 17 })
+				}), /* @__PURE__ */ u("p", {
+					id: errorTextId,
+					class: "IncodeCheckboxErrorText",
+					children: error
+				})]
+			}),
+			helper && !error && /* @__PURE__ */ u("div", {
+				class: "IncodeCheckboxMessageWrapper",
+				"data-testid": `${id}-helper-wrapper`,
+				children: /* @__PURE__ */ u("p", {
+					id: helperTextId,
+					class: "IncodeCheckboxHelperText",
+					children: helper
+				})
+			})
+		]
+	});
+});
+//#endregion
+export { Checkbox as t };