@stencil/core 5.0.0-alpha.2 → 5.0.0-alpha.3

package/dist/index.d.mts

@@ -44,6 +44,7 @@ export {
   getElement,
   getMode,
   getRenderingRef,
+  getShadowRoot,
   h,
   Host,
   Listen,

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { A as Event, D as AttrDeserialize, E as AttachInternals, F as State, I as Watch, L as resolveVar, M as Method, N as Prop, O as Component, P as PropSerialize, R as Build, S as setPlatformHelpers, _ as h, a as Mixin, b as readTask, c as forceUpdate, f as getElement, g as Host, i as render, j as Listen, k as Element, l as getRenderingRef, m as setMode, n as setTagTransformer, o as Fragment, p as getMode, r as transformTag, v as getAssetPath, w as setErrorHandler, x as writeTask, y as setAssetPath } from "./client-DucyoZT4.mjs";
-export { AttachInternals, AttrDeserialize, Build, Component, Element, Event, Fragment, Host, Listen, Method, Mixin, Prop, PropSerialize, State, Watch, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, h, readTask, render, resolveVar, setAssetPath, setErrorHandler, setMode, setPlatformHelpers, setTagTransformer, transformTag, writeTask };
+import { A as Element, C as setPlatformHelpers, D as AttachInternals, F as PropSerialize, I as State, L as Watch, M as Listen, N as Method, O as AttrDeserialize, P as Prop, R as resolveVar, S as writeTask, T as setErrorHandler, _ as getElement, a as Mixin, b as setAssetPath, c as forceUpdate, f as getMode, g as h, h as Host, i as render, j as Event, k as Component, l as getRenderingRef, n as setTagTransformer, o as Fragment, p as setMode, r as transformTag, v as getShadowRoot, x as readTask, y as getAssetPath, z as Build } from "./client-CSm3x5ke.mjs";
+export { AttachInternals, AttrDeserialize, Build, Component, Element, Event, Fragment, Host, Listen, Method, Mixin, Prop, PropSerialize, State, Watch, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, getShadowRoot, h, readTask, render, resolveVar, setAssetPath, setErrorHandler, setMode, setPlatformHelpers, setTagTransformer, transformTag, writeTask };

package/dist/{jsx-runtime-DBzBJLKk.d.ts → jsx-runtime-DlDkTqps.d.ts}

@@ -1,4 +1,4 @@
-import { m as FunctionalComponent, y as VNode } from "./index-BONzXKJt.js";
+import { m as FunctionalComponent, y as VNode } from "./index-CyrGY82h.js";
 
 //#region src/runtime/fragment.d.ts
 declare const Fragment: FunctionalComponent;

package/dist/jsx-runtime.d.ts

@@ -1,2 +1,2 @@
-import { n as jsxs, r as Fragment, t as jsx } from "./jsx-runtime-DBzBJLKk.js";
+import { n as jsxs, r as Fragment, t as jsx } from "./jsx-runtime-DlDkTqps.js";
 export { Fragment, jsx, jsxs };

package/dist/jsx-runtime.js

@@ -1,2 +1,2 @@
-import { d as Fragment, n as jsx, r as jsxs } from "./runtime-CqlPYKjW.js";
+import { d as Fragment, n as jsx, r as jsxs } from "./runtime-BBCnuprF.js";
 export { Fragment, jsx, jsxs };

package/dist/{node-BWBQAh8C.mjs → node-Bg-mO5dw.mjs}

@@ -1,7 +1,7 @@
 import { n as __require } from "./chunk-CjcI7cDX.mjs";
-import "./client-DucyoZT4.mjs";
-import { _ as isString, c as flatOne, p as isFunction, y as noop } from "./serialize-o-Sj1lvg.mjs";
-import { bt as isGlob, dt as TASK_CANCELED_MSG, ft as buildError, ht as catchError, rt as normalizePath, vt as shouldIgnoreError } from "./validation-BR7tMYEv.mjs";
+import "./client-CSm3x5ke.mjs";
+import { h as noop, i as flatOne, l as isFunction, p as isString } from "./regular-expression-D5pGVpCu.mjs";
+import { bt as isGlob, dt as TASK_CANCELED_MSG, ft as buildError, ht as catchError, rt as normalizePath, vt as shouldIgnoreError } from "./validation-Byxie0Uk.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import path$1 from "path";
@@ -1494,17 +1494,6 @@ function createNodeSys(c = {}) {
 		encodeToBase64(str) {
 			return Buffer.from(str).toString("base64");
 		},
-		async ensureDependencies() {
-			console.warn(`ensureDependencies will be removed in a future version of Stencil.`);
-			console.warn(`To get the stencilPath, please use getCompilerExecutingPath().`);
-			return {
-				stencilPath: sys.getCompilerExecutingPath(),
-				diagnostics: []
-			};
-		},
-		async ensureResources() {
-			console.warn(`ensureResources is a no-op, and will be removed in a future version of Stencil`);
-		},
 		exit: async (exitCode) => {
 			await runInterruptsCallbacks();
 			process.exitCode = exitCode;

package/dist/regular-expression-D5pGVpCu.mjs

@@ -0,0 +1,415 @@
+const MEMBER_FLAGS = {
+	String: 1,
+	Number: 2,
+	Boolean: 4,
+	Any: 8,
+	Unknown: 16,
+	State: 32,
+	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
+};
+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,
+	shadowModeClosed: 2048,
+	patchChildren: 4096,
+	patchClone: 8192,
+	patchInsert: 16384,
+	patchAll: 32768
+};
+/**
+* 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
+};
+//#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
+/**
+* Check if a value is defined (not null and not undefined).
+*
+* @param v - the value to check
+* @returns true if the value is defined
+*/
+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.
+* 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 text - The input string to process.
+* @param pattern - The pattern to search for in the input string. Can be a regular expression or a string.
+* @param replacement - The string to replace each match with.
+* @param replaceAll - Whether to replace all occurrences (true) or just the first occurrence (false). Defaults to true.
+* @returns The processed string with the replacements applied.
+*/
+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
+export { XLINK_NS as $, DIST_CUSTOM_ELEMENTS as A, DOCS_VSCODE as B, CMP_FLAGS as C, DEFAULT_STYLE_MODE as D, CUSTOM as E, DIST_TYPES as F, LISTENER_FLAGS as G, GENERATED_DTS as H, DOCS_CUSTOM as I, STATS as J, MEMBER_FLAGS as K, DOCS_CUSTOM_ELEMENTS_MANIFEST as L, DIST_HYDRATE_SCRIPT as M, DIST_LAZY as N, DIST as O, DIST_LAZY_LOADER as P, WWW as Q, DOCS_JSON as R, queryNonceMetaTagContent as S, COPY as T, HOST_FLAGS as U, EVENT_FLAGS as V, HTML_NS as W, VALID_CONFIG_OUTPUT_TARGETS as X, SVG_NS as Y, WATCH_FLAGS as Z, sortBy as _, fromEntries as a, toTitleCase as b, isDef as c, isNumber as d, isObject as f, pluck as g, noop as h, flatOne as i, DIST_GLOBAL_STYLES as j, DIST_COLLECTION as k, isFunction as l, mergeIntoWith as m, dashToPascalCase as n, isBoolean as o, isString as p, NODE_TYPES as q, escapeWithPattern as r, isComplexType as s, escapeRegExpSpecialCharacters as t, isIterable as u, toCamelCase as v, COLLECTION_MANIFEST_FILE_NAME as w, unique as x, toDashCase as y, DOCS_README as z };

package/dist/runtime/app-data/index.d.ts

@@ -1,2 +1,2 @@
-import { n as Env, r as NAMESPACE, t as BUILD } from "../../index-CHjZtib0.js";
+import { n as Env, r as NAMESPACE, t as BUILD } from "../../index-hS-KBdAP.js";
 export { BUILD, Env, NAMESPACE };

package/dist/runtime/app-data/index.js

@@ -30,7 +30,6 @@ const BUILD = {
 	hostListenerTargetWindow: true,
 	hostListenerTargetDocument: true,
 	hostListenerTargetBody: true,
-	hostListenerTargetParent: false,
 	hostListenerTarget: true,
 	member: true,
 	method: true,
@@ -41,6 +40,7 @@ const BUILD = {
 	reflect: true,
 	scoped: true,
 	shadowDom: true,
+	shadowModeClosed: false,
 	slot: true,
 	cssAnnotations: true,
 	state: true,
@@ -89,7 +89,6 @@ const BUILD = {
 	initializeNextTick: false,
 	asyncLoading: true,
 	asyncQueue: false,
-	transformTagName: false,
 	attachStyles: true,
 	experimentalSlotFixes: false
 };

package/dist/runtime/client/index.d.ts

@@ -1276,8 +1276,6 @@ interface JSXAttributes<T = Element$2> {
 interface CustomElementsDefineOptions {
   exclude?: string[];
   syncQueue?: boolean;
-  /** @deprecated in-favour of `setTagTransformer` and `transformTag` */
-  transformTagName?: (tagName: string) => string;
   jmp?: (c: Function) => any;
   raf?: (c: FrameRequestCallback) => number;
   ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
@@ -2172,6 +2170,18 @@ declare const disconnectedCallback: (elm: HostElement) => Promise<void>;
 //#endregion
 //#region src/runtime/element.d.ts
 declare const getElement: (ref: any) => HostElement;
+/**
+ * Get the shadow root for a Stencil component's host element.
+ * This works for both open and closed shadow DOM modes.
+ *
+ * For closed shadow DOM, `element.shadowRoot` returns `null` by design,
+ * but Stencil stores the reference internally so components can still
+ * access their own shadow root.
+ *
+ * @param element The host element (from @Element() decorator)
+ * @returns The shadow root, or null if no shadow root exists
+ */
+declare const getShadowRoot: (element: HTMLElement) => ShadowRoot | null;
 //#endregion
 //#region src/runtime/event-emitter.d.ts
 declare const createEvent: (ref: RuntimeRef, name: string, flags: number) => {
@@ -2182,7 +2192,7 @@ declare const createEvent: (ref: RuntimeRef, name: string, flags: number) => {
 declare const Fragment: FunctionalComponent;
 //#endregion
 //#region src/runtime/host-listener.d.ts
-declare const addHostEventListeners: (elm: HostElement, hostRef: HostRef, listeners?: ComponentRuntimeHostListener[], attachParentListeners?: boolean) => void;
+declare const addHostEventListeners: (elm: HostElement, hostRef: HostRef, listeners?: ComponentRuntimeHostListener[]) => void;
 //#endregion
 //#region src/runtime/mixin.d.ts
 type Ctor<T = {}> = new (...args: any[]) => T;
@@ -2355,4 +2365,4 @@ declare const insertVdomAnnotations: (doc: Document, staticComponents: string[])
  */
 declare const renderVdom: (hostRef: HostRef, renderFnResults: VNode | VNode[], isInitialLoad?: boolean) => void;
 //#endregion
-export { AttachInternals, AttrDeserialize, BUILD, Build, Component, Element$1 as Element, Env, Event, Fragment, H, H as HTMLElement, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Listen, Method, Mixin, NAMESPACE, Prop, PropSerialize, STENCIL_DEV_MODE, State, Watch, addHostEventListeners, bootstrapLazy, cmpModules, connectedCallback, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, getValue, h, insertVdomAnnotations, isMemberInElement, jsx, jsxs, loadModule, modeResolutionChain, needsScopedSSR, nextTick, parsePropertyValue, plt, postUpdateComponent, promiseResolve, proxyComponent, proxyCustomElement, readTask, registerHost, registerInstance, render, renderVdom, resolveVar, setAssetPath, setErrorHandler, setMode, setNonce, setPlatformHelpers, setPlatformOptions, setScopedSSR, setTagTransformer, setValue, styles, supportsConstructableStylesheets, supportsListenerOptions, supportsMutableAdoptedStyleSheets, supportsShadow, transformTag, win, writeTask };
+export { AttachInternals, AttrDeserialize, BUILD, Build, Component, Element$1 as Element, Env, Event, Fragment, H, H as HTMLElement, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Listen, Method, Mixin, NAMESPACE, Prop, PropSerialize, STENCIL_DEV_MODE, State, Watch, addHostEventListeners, bootstrapLazy, cmpModules, connectedCallback, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, getShadowRoot, getValue, h, insertVdomAnnotations, isMemberInElement, jsx, jsxs, loadModule, modeResolutionChain, needsScopedSSR, nextTick, parsePropertyValue, plt, postUpdateComponent, promiseResolve, proxyComponent, proxyCustomElement, readTask, registerHost, registerInstance, render, renderVdom, resolveVar, setAssetPath, setErrorHandler, setMode, setNonce, setPlatformHelpers, setPlatformOptions, setScopedSSR, setTagTransformer, setValue, styles, supportsConstructableStylesheets, supportsListenerOptions, supportsMutableAdoptedStyleSheets, supportsShadow, transformTag, win, writeTask };