@stencil/core 4.43.2 → 5.0.0-next.0

package/dist/serialize-BJvhE9aQ.mjs

@@ -0,0 +1,775 @@
+//#region src/utils/constants.ts
+const MF_String = 1;
+const MF_Number = 2;
+const MF_Boolean = 4;
+const MF_Any = 8;
+const MF_Unknown = 16;
+const MF_State = 32;
+const MEMBER_FLAGS = {
+	String: MF_String,
+	Number: MF_Number,
+	Boolean: MF_Boolean,
+	Any: MF_Any,
+	Unknown: MF_Unknown,
+	State: MF_State,
+	Method: 64,
+	Event: 128,
+	Element: 256,
+	ReflectAttr: 512,
+	Mutable: 1024,
+	Getter: 2048,
+	Setter: 4096,
+	Prop: 31,
+	HasAttribute: 31,
+	PropLike: 63
+};
+const WATCH_FLAGS = { Immediate: 1 };
+const EVENT_FLAGS = {
+	Cancellable: 1,
+	Composed: 2,
+	Bubbles: 4
+};
+const LISTENER_FLAGS = {
+	Passive: 1,
+	Capture: 2,
+	TargetDocument: 4,
+	TargetWindow: 8,
+	TargetBody: 16,
+	TargetParent: 32
+};
+const HOST_FLAGS = {
+	hasConnected: 1,
+	hasRendered: 2,
+	isWaitingForChildren: 4,
+	isConstructingInstance: 8,
+	isQueuedForUpdate: 16,
+	hasInitializedComponent: 32,
+	hasLoadedComponent: 64,
+	isWatchReady: 128,
+	isListenReady: 256,
+	needsRerender: 512,
+	devOnRender: 1024,
+	devOnDidLoad: 2048
+};
+const CF_scopedCssEncapsulation = 2;
+const CF_needsShadowDomShim = 8;
+/**
+* A set of flags used for bitwise calculations against {@link ComponentRuntimeMeta#$flags$}.
+*
+* These flags should only be used in conjunction with {@link ComponentRuntimeMeta#$flags$}.
+* They should _not_ be used for calculations against other fields/numbers
+*/
+const CMP_FLAGS = {
+	shadowDomEncapsulation: 1,
+	scopedCssEncapsulation: CF_scopedCssEncapsulation,
+	hasSlotRelocation: 4,
+	needsShadowDomShim: CF_needsShadowDomShim,
+	shadowDelegatesFocus: 16,
+	hasMode: 32,
+	needsScopedEncapsulation: CF_scopedCssEncapsulation | CF_needsShadowDomShim,
+	formAssociated: 64,
+	shadowNeedsScopedCss: 128,
+	hasSlot: 256,
+	hasModernPropertyDecls: 512,
+	shadowSlotAssignmentManual: 1024
+};
+/**
+* Default style mode id
+*/
+const DEFAULT_STYLE_MODE = "$";
+/**
+* Namespaces
+*/
+const SVG_NS = "http://www.w3.org/2000/svg";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const XLINK_NS = "http://www.w3.org/1999/xlink";
+/**
+* File names and value
+*/
+const COLLECTION_MANIFEST_FILE_NAME = "collection-manifest.json";
+/**
+* Constant for the 'copy' output target
+*/
+const COPY = "copy";
+/**
+* Constant for the 'custom' output target
+*/
+const CUSTOM = "custom";
+/**
+* Constant for the 'dist' output target
+*/
+const DIST = "dist";
+/**
+* Constant for the 'dist-collection' output target
+*/
+const DIST_COLLECTION = "dist-collection";
+/**
+* Constant for the 'dist-custom-elements' output target
+*/
+const DIST_CUSTOM_ELEMENTS = "dist-custom-elements";
+/**
+* Constant for the 'dist-types' output target
+*/
+const DIST_TYPES = "dist-types";
+/**
+* Constant for the 'dist-hydrate-script' output target
+*/
+const DIST_HYDRATE_SCRIPT = "dist-hydrate-script";
+/**
+* Constant for the 'dist-lazy' output target
+*/
+const DIST_LAZY = "dist-lazy";
+/**
+* Constant for the 'dist-lazy-loader' output target
+*/
+const DIST_LAZY_LOADER = "dist-lazy-loader";
+/**
+* Constant for the 'dist-global-styles' output target
+*/
+const DIST_GLOBAL_STYLES = "dist-global-styles";
+/**
+* Constant for the 'docs-custom' output target
+*/
+const DOCS_CUSTOM = "docs-custom";
+/**
+* Constant for the 'docs-json' output target
+*/
+const DOCS_JSON = "docs-json";
+/**
+* Constant for the 'docs-readme' output target
+*/
+const DOCS_README = "docs-readme";
+/**
+* Constant for the 'docs-vscode' output target
+*/
+const DOCS_VSCODE = "docs-vscode";
+/**
+* Constant for the 'docs-custom-elements-manifest' output target
+*/
+const DOCS_CUSTOM_ELEMENTS_MANIFEST = "docs-custom-elements-manifest";
+/**
+* Constant for the 'stats' output target
+*/
+const STATS = "stats";
+/**
+* Constant for the 'www' output target
+*/
+const WWW = "www";
+/**
+* Valid output targets to specify in a Stencil config.
+*
+* Note that there are some output targets (e.g. `DIST_TYPES`) which are
+* programmatically set as output targets by the compiler when other output
+* targets (in that case `DIST`) are set, but which are _not_ supported in a
+* Stencil config. This is enforced in the output target validation code.
+*/
+const VALID_CONFIG_OUTPUT_TARGETS = [
+	WWW,
+	DIST,
+	DIST_COLLECTION,
+	DIST_CUSTOM_ELEMENTS,
+	DIST_LAZY,
+	DIST_HYDRATE_SCRIPT,
+	DOCS_JSON,
+	DOCS_README,
+	DOCS_VSCODE,
+	DOCS_CUSTOM,
+	DOCS_CUSTOM_ELEMENTS_MANIFEST,
+	COPY,
+	CUSTOM,
+	STATS
+];
+const GENERATED_DTS = "components.d.ts";
+/**
+* DOM Node types
+*
+* See https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+*
+* Note: this is a duplicate of the `NODE_TYPES` enum in mock-doc, it's
+* copied over here so that we do not need to introduce a dependency on the
+* mock-doc bundle in the runtime. See
+* https://github.com/stenciljs/core/pull/5705 for more details.
+*/
+const NODE_TYPES = {
+	ELEMENT_NODE: 1,
+	ATTRIBUTE_NODE: 2,
+	TEXT_NODE: 3,
+	CDATA_SECTION_NODE: 4,
+	ENTITY_REFERENCE_NODE: 5,
+	ENTITY_NODE: 6,
+	PROCESSING_INSTRUCTION_NODE: 7,
+	COMMENT_NODE: 8,
+	DOCUMENT_NODE: 9,
+	DOCUMENT_TYPE_NODE: 10,
+	DOCUMENT_FRAGMENT_NODE: 11,
+	NOTATION_NODE: 12
+};
+/**
+* Represents a primitive type.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-PrimitiveProtocolValue.
+*/
+const PrimitiveType = {
+	Undefined: "undefined",
+	Null: "null",
+	String: "string",
+	Number: "number",
+	SpecialNumber: "number",
+	Boolean: "boolean",
+	BigInt: "bigint"
+};
+/**
+* Represents a non-primitive type.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-RemoteValue.
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+const NonPrimitiveType = {
+	Array: "array",
+	Date: "date",
+	Map: "map",
+	Object: "object",
+	RegularExpression: "regexp",
+	Set: "set",
+	Channel: "channel",
+	Symbol: "symbol"
+};
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const TYPE_CONSTANT = "type";
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const VALUE_CONSTANT = "value";
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const SERIALIZED_PREFIX = "serialized:";
+
+//#endregion
+//#region src/utils/query-nonce-meta-tag-content.ts
+/**
+* Helper method for querying a `meta` tag that contains a nonce value
+* out of a DOM's head.
+*
+* @param doc The DOM containing the `head` to query against
+* @returns The content of the meta tag representing the nonce value, or `undefined` if no tag
+* exists or the tag has no content.
+*/
+function queryNonceMetaTagContent(doc) {
+	return doc.head?.querySelector("meta[name=\"csp-nonce\"]")?.getAttribute("content") ?? void 0;
+}
+
+//#endregion
+//#region src/utils/helpers.ts
+const isDef = (v) => v != null && v !== void 0;
+/**
+* Convert a string from PascalCase to dash-case
+*
+* @param str the string to convert
+* @returns a converted string
+*/
+const toDashCase = (str) => str.replace(/([A-Z0-9])/g, (match) => ` ${match[0]}`).trim().split(" ").join("-").toLowerCase();
+/**
+* Convert a string from dash-case / kebab-case to PascalCase (or CamelCase,
+* or whatever you call it!)
+*
+* @param str a string to convert
+* @returns a converted string
+*/
+const dashToPascalCase = (str) => str.toLowerCase().split("-").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+/**
+* Convert a string to 'camelCase'
+*
+* @param str the string to convert
+* @returns the converted string
+*/
+const toCamelCase = (str) => {
+	const pascalCase = dashToPascalCase(str);
+	return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+};
+/**
+* Capitalize the first letter of a string
+*
+* @param str the string to capitalize
+* @returns a capitalized string
+*/
+const toTitleCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+/**
+* Escapes all occurrences of a specified pattern in a string.
+* @description This function replaces all matches of a given pattern in the input text with a specified replacement string.
+* It can handle both string and regular expression patterns and allows toggling between global and single-match replacements.
+* @param {string} text - The input string to process.
+* @param {RegExp | string} pattern - The pattern to search for in the input string. Can be a regular expression or a string.
+* @param {string} replacement - The string to replace each match with.
+* @param {boolean} [replaceAll=true] - Whether to replace all occurrences (`true`) or just the first occurrence (`false`). Defaults to `true`.
+* @returns {string} The processed string with the replacements applied.
+* @example
+* @see src\utils\util.ts
+*/
+const escapeWithPattern = (text, pattern, replacement, replaceAll = true) => {
+	let regex;
+	if (typeof pattern === "string") {
+		const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		regex = new RegExp(escaped, replaceAll ? "g" : "");
+	} else {
+		const flags = pattern.flags;
+		const hasG = flags.includes("g");
+		const newFlags = replaceAll ? hasG ? flags : flags + "g" : hasG ? flags.replace(/g/g, "") : flags;
+		regex = new RegExp(pattern.source, newFlags);
+	}
+	return text.replace(regex, replacement);
+};
+/**
+* This is just a no-op, don't expect it to do anything.
+*/
+const noop = () => {};
+/**
+* Check whether a value is a 'complex type', defined here as an object or a
+* function.
+*
+* @param o the value to check
+* @returns whether it's a complex type or not
+*/
+const isComplexType = (o) => {
+	o = typeof o;
+	return o === "object" || o === "function";
+};
+/**
+* Sort an array without mutating it in-place (as `Array.prototype.sort`
+* unfortunately does)
+*
+* @param array the array you'd like to sort
+* @param prop a function for deriving sortable values (strings or numbers)
+* from array members
+* @returns a new array of all items `x` in `array` ordered by `prop(x)`
+*/
+const sortBy = (array, prop) => {
+	return array.slice().sort((a, b) => {
+		const nameA = prop(a);
+		const nameB = prop(b);
+		if (nameA < nameB) return -1;
+		if (nameA > nameB) return 1;
+		return 0;
+	});
+};
+/**
+* A polyfill of sorts for `Array.prototype.flat` which will return the result
+* of calling that method if present and, if not, return an equivalent based on
+* `Array.prototype.reduce`.
+*
+* @param array the array to flatten (one level)
+* @returns a flattened array
+*/
+const flatOne = (array) => {
+	if (array.flat) return array.flat(1);
+	return array.reduce((result, item) => {
+		result.push(...item);
+		return result;
+	}, []);
+};
+/**
+* Deduplicate an array, retaining items at the earliest position in which
+* they appear.
+*
+* So `unique([1,3,2,1,1,4])` would be `[1,3,2,4]`.
+*
+* @param array the array to deduplicate
+* @param predicate an optional function used to generate the key used to
+* determine uniqueness
+* @returns a new, deduplicated array
+*/
+const unique = (array, predicate = (i) => i) => {
+	const set = /* @__PURE__ */ new Set();
+	return array.filter((item) => {
+		const key = predicate(item);
+		if (key == null) return true;
+		if (set.has(key)) return false;
+		set.add(key);
+		return true;
+	});
+};
+/**
+* Merge elements of an array into an existing array, using a predicate to
+* determine uniqueness and only adding elements when they are not present in
+* the first array.
+*
+* **Note**: this mutates the target array! This is intentional to avoid
+* unnecessary array allocation, but be sure that it's what you want!
+*
+* @param target the target array, to which new unique items should be added
+* @param newItems a list of new items, some (or all!) of which may be added
+* @param mergeWith a predicate function which reduces the items in `target`
+* and `newItems` to a value which can be equated with `===` for the purposes
+* of determining uniqueness
+*/
+function mergeIntoWith(target, newItems, mergeWith) {
+	for (const item of newItems) if (!target.find((existingItem) => mergeWith(existingItem) === mergeWith(item))) target.push(item);
+}
+/**
+* A utility for building an object from an iterable very similar to
+* `Object.fromEntries`
+*
+* @param entries an iterable object holding entries (key-value tuples) to
+* plop into a new object
+* @returns an object containing those entries
+*/
+const fromEntries = (entries) => {
+	const object = {};
+	for (const [key, value] of entries) object[key] = value;
+	return object;
+};
+/**
+* Based on a given object, create a new object which has only the specified
+* key-value pairs included in it.
+*
+* @param obj the object from which to take values
+* @param keys a set of keys to take
+* @returns an object mapping `key` to `obj[key]` if `obj[key]` is truthy for
+* every `key` in `keys`
+*/
+const pluck = (obj, keys) => {
+	return keys.reduce((final, key) => {
+		if (obj[key]) final[key] = obj[key];
+		return final;
+	}, {});
+};
+const isDefined = (v) => v !== null && v !== void 0;
+const isBoolean = (v) => typeof v === "boolean";
+const isFunction = (v) => typeof v === "function";
+const isNumber = (v) => typeof v === "number";
+const isObject = (val) => val != null && typeof val === "object" && Array.isArray(val) === false;
+const isString = (v) => typeof v === "string";
+const isIterable = (v) => isDefined(v) && isFunction(v[Symbol.iterator]);
+
+//#endregion
+//#region src/utils/regular-expression.ts
+/**
+* Utility function that will escape all regular expression special characters in a string.
+*
+* @param text The string potentially containing special characters.
+* @returns The string with all special characters escaped.
+*/
+const escapeRegExpSpecialCharacters = (text) => {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+
+//#endregion
+//#region src/utils/local-value.ts
+/**
+* Represents a local value with a specified type and optional value.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-LocalValue
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+var LocalValue = class LocalValue {
+	type;
+	value;
+	constructor(type, value) {
+		if (type === PrimitiveType.Undefined || type === PrimitiveType.Null) this.type = type;
+		else {
+			this.type = type;
+			this.value = value;
+		}
+	}
+	/**
+	* Creates a new LocalValue object with a string value.
+	*
+	* @param {string} value - The string value to be stored in the LocalValue object.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createStringValue(value) {
+		return new LocalValue(PrimitiveType.String, value);
+	}
+	/**
+	* Creates a new LocalValue object with a number value.
+	*
+	* @param {number} value - The number value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createNumberValue(value) {
+		return new LocalValue(PrimitiveType.Number, value);
+	}
+	/**
+	* Creates a new LocalValue object with a special number value.
+	*
+	* @param {number} value - The value of the special number.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createSpecialNumberValue(value) {
+		if (Number.isNaN(value)) return new LocalValue(PrimitiveType.SpecialNumber, "NaN");
+		if (Object.is(value, -0)) return new LocalValue(PrimitiveType.SpecialNumber, "-0");
+		if (value === Infinity) return new LocalValue(PrimitiveType.SpecialNumber, "Infinity");
+		if (value === -Infinity) return new LocalValue(PrimitiveType.SpecialNumber, "-Infinity");
+		return new LocalValue(PrimitiveType.SpecialNumber, value);
+	}
+	/**
+	* Creates a new LocalValue object with an undefined value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createUndefinedValue() {
+		return new LocalValue(PrimitiveType.Undefined);
+	}
+	/**
+	* Creates a new LocalValue object with a null value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createNullValue() {
+		return new LocalValue(PrimitiveType.Null);
+	}
+	/**
+	* Creates a new LocalValue object with a boolean value.
+	*
+	* @param {boolean} value - The boolean value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createBooleanValue(value) {
+		return new LocalValue(PrimitiveType.Boolean, value);
+	}
+	/**
+	* Creates a new LocalValue object with a BigInt value.
+	*
+	* @param {BigInt} value - The BigInt value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createBigIntValue(value) {
+		return new LocalValue(PrimitiveType.BigInt, value.toString());
+	}
+	/**
+	* Creates a new LocalValue object with an array.
+	*
+	* @param {Array} value - The array.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createArrayValue(value) {
+		return new LocalValue(NonPrimitiveType.Array, value);
+	}
+	/**
+	* Creates a new LocalValue object with date value.
+	*
+	* @param {string} value - The date.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createDateValue(value) {
+		return new LocalValue(NonPrimitiveType.Date, value);
+	}
+	/**
+	* Creates a new LocalValue object of map value.
+	* @param {Map} map - The map.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createMapValue(map) {
+		const value = [];
+		Array.from(map.entries()).forEach(([key, val]) => {
+			value.push([LocalValue.getArgument(key), LocalValue.getArgument(val)]);
+		});
+		return new LocalValue(NonPrimitiveType.Map, value);
+	}
+	/**
+	* Creates a new LocalValue object from the passed object.
+	*
+	* @param object the object to create a LocalValue from
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createObjectValue(object) {
+		const value = [];
+		Object.entries(object).forEach(([key, val]) => {
+			value.push([key, LocalValue.getArgument(val)]);
+		});
+		return new LocalValue(NonPrimitiveType.Object, value);
+	}
+	/**
+	* Creates a new LocalValue object of regular expression value.
+	*
+	* @param {string} value - The value of the regular expression.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createRegularExpressionValue(value) {
+		return new LocalValue(NonPrimitiveType.RegularExpression, value);
+	}
+	/**
+	* Creates a new LocalValue object with the specified value.
+	* @param {Set} value - The value to be set.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createSetValue(value) {
+		return new LocalValue(NonPrimitiveType.Set, value);
+	}
+	/**
+	* Creates a new LocalValue object with the given channel value
+	*
+	* @param {ChannelValue} value - The channel value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createChannelValue(value) {
+		return new LocalValue(NonPrimitiveType.Channel, value);
+	}
+	/**
+	* Creates a new LocalValue object with a Symbol value.
+	*
+	* @param {Symbol} symbol - The Symbol value
+	* @returns {LocalValue} - The created LocalValue object
+	*/
+	static createSymbolValue(symbol) {
+		const description = symbol.description || "Symbol()";
+		return new LocalValue(NonPrimitiveType.Symbol, description);
+	}
+	static getArgument(argument) {
+		const type = typeof argument;
+		switch (type) {
+			case PrimitiveType.String: return LocalValue.createStringValue(argument);
+			case PrimitiveType.Number:
+				if (Number.isNaN(argument) || Object.is(argument, -0) || !Number.isFinite(argument)) return LocalValue.createSpecialNumberValue(argument);
+				return LocalValue.createNumberValue(argument);
+			case PrimitiveType.Boolean: return LocalValue.createBooleanValue(argument);
+			case PrimitiveType.BigInt: return LocalValue.createBigIntValue(argument);
+			case PrimitiveType.Undefined: return LocalValue.createUndefinedValue();
+			case NonPrimitiveType.Symbol: return LocalValue.createSymbolValue(argument);
+			case NonPrimitiveType.Object:
+				if (argument === null) return LocalValue.createNullValue();
+				if (argument instanceof Date) return LocalValue.createDateValue(argument);
+				if (argument instanceof Map) {
+					const map = [];
+					argument.forEach((value, key) => {
+						const objectKey = typeof key === "string" ? key : LocalValue.getArgument(key);
+						const objectValue = LocalValue.getArgument(value);
+						map.push([objectKey, objectValue]);
+					});
+					return LocalValue.createMapValue(argument);
+				}
+				if (argument instanceof Set) {
+					const set = [];
+					argument.forEach((value) => {
+						set.push(LocalValue.getArgument(value));
+					});
+					return LocalValue.createSetValue(set);
+				}
+				if (argument instanceof Array) {
+					const arr = [];
+					argument.forEach((value) => {
+						arr.push(LocalValue.getArgument(value));
+					});
+					return LocalValue.createArrayValue(arr);
+				}
+				if (argument instanceof RegExp) return LocalValue.createRegularExpressionValue({
+					pattern: argument.source,
+					flags: argument.flags
+				});
+				return LocalValue.createObjectValue(argument);
+		}
+		throw new Error(`Unsupported type: ${type}`);
+	}
+	asMap() {
+		return {
+			[TYPE_CONSTANT]: this.type,
+			...!(this.type === PrimitiveType.Null || this.type === PrimitiveType.Undefined) ? { [VALUE_CONSTANT]: this.value } : {}
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/remote-value.ts
+/**
+* RemoteValue class for deserializing LocalValue serialized objects back into their original form
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+var RemoteValue = class RemoteValue {
+	/**
+	* Deserializes a LocalValue serialized object back to its original JavaScript representation
+	*
+	* @param serialized The serialized LocalValue object
+	* @returns The original JavaScript value/object
+	*/
+	static fromLocalValue(serialized) {
+		const type = serialized[TYPE_CONSTANT];
+		const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
+		switch (type) {
+			case PrimitiveType.String: return value;
+			case PrimitiveType.Boolean: return value;
+			case PrimitiveType.BigInt: return BigInt(value);
+			case PrimitiveType.Undefined: return;
+			case PrimitiveType.Null: return null;
+			case PrimitiveType.Number:
+				if (value === "NaN") return NaN;
+				if (value === "-0") return -0;
+				if (value === "Infinity") return Infinity;
+				if (value === "-Infinity") return -Infinity;
+				return value;
+			case NonPrimitiveType.Array: return value.map((item) => RemoteValue.fromLocalValue(item));
+			case NonPrimitiveType.Date: return new Date(value);
+			case NonPrimitiveType.Map:
+				const map = /* @__PURE__ */ new Map();
+				for (const [key, val] of value) {
+					const deserializedKey = typeof key === "object" && key !== null ? RemoteValue.fromLocalValue(key) : key;
+					const deserializedValue = RemoteValue.fromLocalValue(val);
+					map.set(deserializedKey, deserializedValue);
+				}
+				return map;
+			case NonPrimitiveType.Object:
+				const obj = {};
+				for (const [key, val] of value) obj[key] = RemoteValue.fromLocalValue(val);
+				return obj;
+			case NonPrimitiveType.RegularExpression:
+				const { pattern, flags } = value;
+				return new RegExp(pattern, flags);
+			case NonPrimitiveType.Set:
+				const set = /* @__PURE__ */ new Set();
+				for (const item of value) set.add(RemoteValue.fromLocalValue(item));
+				return set;
+			case NonPrimitiveType.Symbol: return Symbol(value);
+			default: throw new Error(`Unsupported type: ${type}`);
+		}
+	}
+	/**
+	* Utility method to deserialize multiple LocalValues at once
+	*
+	* @param serializedValues Array of serialized LocalValue objects
+	* @returns Array of deserialized JavaScript values
+	*/
+	static fromLocalValueArray(serializedValues) {
+		return serializedValues.map((value) => RemoteValue.fromLocalValue(value));
+	}
+	/**
+	* Verifies if the given object matches the structure of a serialized LocalValue
+	*
+	* @param obj Object to verify
+	* @returns boolean indicating if the object has LocalValue structure
+	*/
+	static isLocalValueObject(obj) {
+		if (typeof obj !== "object" || obj === null) return false;
+		if (!obj.hasOwnProperty(TYPE_CONSTANT)) return false;
+		const type = obj[TYPE_CONSTANT];
+		if (!Object.values({
+			...PrimitiveType,
+			...NonPrimitiveType
+		}).includes(type)) return false;
+		if (type !== PrimitiveType.Null && type !== PrimitiveType.Undefined) return obj.hasOwnProperty(VALUE_CONSTANT);
+		return true;
+	}
+};
+
+//#endregion
+//#region src/utils/serialize.ts
+/**
+* Serialize a value to a string that can be deserialized later.
+* @param {unknown} value - The value to serialize.
+* @returns {string} A string that can be deserialized later.
+* @deprecated will be removed in v5. Use `@PropSerialize()` decorator instead.
+*/
+function serializeProperty(value) {
+	/**
+	* If the value is a primitive type, return it as is.
+	*/
+	if ([
+		"string",
+		"boolean",
+		"undefined"
+	].includes(typeof value) || typeof value === "number" && value !== Infinity && value !== -Infinity && !isNaN(value)) return value;
+	const arg = LocalValue.getArgument(value);
+	return SERIALIZED_PREFIX + btoa(JSON.stringify(arg));
+}
+/**
+* Deserialize a value from a string that was serialized earlier.
+* @param {string} value - The string to deserialize.
+* @returns {unknown} The deserialized value.
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` decorator instead.
+*/
+function deserializeProperty(value) {
+	if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) return value;
+	return RemoteValue.fromLocalValue(JSON.parse(atob(value.slice(SERIALIZED_PREFIX.length))));
+}
+
+//#endregion
+export { PrimitiveType as $, CUSTOM as A, DOCS_CUSTOM as B, toDashCase as C, CMP_FLAGS as D, queryNonceMetaTagContent as E, DIST_GLOBAL_STYLES as F, EVENT_FLAGS as G, DOCS_JSON as H, DIST_HYDRATE_SCRIPT as I, HTML_NS as J, GENERATED_DTS as K, DIST_LAZY as L, DIST as M, DIST_COLLECTION as N, COLLECTION_MANIFEST_FILE_NAME as O, DIST_CUSTOM_ELEMENTS as P, NonPrimitiveType as Q, DIST_LAZY_LOADER as R, toCamelCase as S, unique as T, DOCS_README as U, DOCS_CUSTOM_ELEMENTS_MANIFEST as V, DOCS_VSCODE as W, MEMBER_FLAGS as X, LISTENER_FLAGS as Y, NODE_TYPES as Z, isString as _, escapeRegExpSpecialCharacters as a, VALUE_CONSTANT as at, pluck as b, flatOne as c, XLINK_NS as ct, isComplexType as d, SERIALIZED_PREFIX as et, isDef as f, isObject as g, isNumber as h, LocalValue as i, VALID_CONFIG_OUTPUT_TARGETS as it, DEFAULT_STYLE_MODE as j, COPY as k, fromEntries as l, isIterable as m, serializeProperty as n, SVG_NS as nt, dashToPascalCase as o, WATCH_FLAGS as ot, isFunction as p, HOST_FLAGS as q, RemoteValue as r, TYPE_CONSTANT as rt, escapeWithPattern as s, WWW as st, deserializeProperty as t, STATS as tt, isBoolean as u, mergeIntoWith as v, toTitleCase as w, sortBy as x, noop as y, DIST_TYPES as z };