@stencil/core 5.0.0-alpha.9 → 5.0.0-beta.0

package/dist/testing/index.d.mts

@@ -1,7 +1,4683 @@
-import { $r as LogLevel, B as ComponentCompilerMeta, Br as Diagnostic, Dt as HostRef, E as CompilerCtx, Et as HostElement, Nt as Module, Rt as NewSpecPageOptions, Zn as Compiler, Zr as LoadConfigInit, a as BuildCtx, aa as ValidatedConfig, cn as RuntimeRef, ei as Logger, fa as RafCallback, ha as UserBuildConditionals, ia as UnvalidatedConfig, kr as Config, mt as ComponentRuntimeMeta, ni as LoggerTimeSpan, pn as SpecPage, ua as ErrorHandler, vr as CompilerSystem } from "../index-vY35H18z.mjs";
-import { a as h, b as Env, d as getMode, g as getElement, h as createEvent, i as Host, m as Fragment, o as forceUpdate, p as Mixin, s as getRenderingRef, v as getAssetPath, y as setAssetPath } from "../index-BvkyxSY6.mjs";
+import "typescript";
+import { InputOptions, Plugin, SourceMap } from "rolldown";
 import { Mock } from "vitest";
-
+//#region src/utils/result.d.ts
+/**
+ * A Result wraps up a success state and a failure state, allowing you to
+ * return a single type from a function and discriminate between the two
+ * possible states in a principled way.
+ *
+ * Using it could look something like this:
+ *
+ * ```ts
+ * import { result } from './';
+ *
+ * const mightFail = (input: number): Result<number, string> => {
+ *   try {
+ *     let value: number = calculateSomethingWithInput(input);
+ *     return result.ok(value);
+ *   } catch (e) {
+ *     return result.err(e.message);
+ *   }
+ * }
+ *
+ * const sumResult = mightFail(2);
+ *
+ * const msg = result.map(sumResult, (sum: number) => `the sum was: ${sum}`);
+ * ```
+ *
+ * A few utility methods are defined in this module, like `map` and `unwrap`,
+ * which are (probably obviously) inspired by the correspond methods on
+ * `std::result::Result` in Rust.
+ */
+type Result<OnSuccess, OnFailure> = Ok<OnSuccess> | Err<OnFailure>;
+/**
+ * Type for the Ok state of a Result
+ */
+type Ok<T> = {
+  isOk: true;
+  isErr: false;
+  value: T;
+};
+/**
+ * Type for the Err state of a Result
+ */
+type Err<T> = {
+  isOk: false;
+  isErr: true;
+  value: T;
+};
+//#endregion
+//#region src/compiler/sys/in-memory-fs.d.ts
+/**
+ * An in-memory FS which proxies the underlying OS filesystem using a simple
+ * in-memory cache. FS writes can accumulate on the in-memory system, using an
+ * API similar to Node.js' `"fs"` module, and then be committed to disk as a
+ * unit.
+ *
+ * Files written to the in-memory system can be edited, deleted, and so on.
+ * This allows the compiler to proceed freely as if it is modifying the
+ * filesystem, modifying the world in whatever way suits it, while deferring
+ * actual FS writes until the end of the compilation process, making actual
+ * changes to the filesystem on disk contingent on an error-free build or any
+ * other condition.
+ *
+ * Usage example:
+ *
+ * ```ts
+ * // create an in-memory FS
+ * const sys = createSystem();
+ * const inMemoryFs = createInMemoryFs(sys);
+ *
+ * // do a few fs operations
+ * await inMemoryFs.writeFile("path/to/file.js", 'console.log("hey!");')
+ * await inMemoryFs.remove("path/to/another_file.ts");
+ *
+ * // commit the results to disk
+ * const commitStats = await inMemoryFs.commit();
+ * ```
+ *
+ * In the above example the write operation and the delete operation (w/
+ * `.remove`) are both queued in the in-memory proxy but not committed to
+ * disk until the `.commit` method is called.
+ */
+type InMemoryFileSystem = ReturnType<typeof createInMemoryFs>;
+/**
+ * A node in the in-memory file system. This may represent a file or
+ * a directory, and pending copy, write, and delete operations may be stored
+ * on it.
+ */
+interface FsItem {
+  fileText: string;
+  isFile: boolean;
+  isDirectory: boolean;
+  size: number;
+  mtimeMs: number;
+  exists: boolean;
+  queueCopyFileToDest: string;
+  queueWriteToDisk: boolean;
+  queueDeleteFromDisk?: boolean;
+  useCache: boolean;
+}
+/**
+ * Options supported by write methods on the in-memory filesystem.
+ */
+interface FsWriteOptions {
+  /**
+   * only use the in-memory cache and do not write the file to disk
+   */
+  inMemoryOnly?: boolean;
+  clearFileCache?: boolean;
+  /**
+   * flush the write to disk immediately, skipping the in-memory cache
+   */
+  immediateWrite?: boolean;
+  /**
+   * specify that the cache should be used
+   */
+  useCache?: boolean;
+  /**
+   * An optional tag for the current output target for which this file is being
+   * written.
+   */
+  outputTargetType?: string;
+}
+/**
+ * Results from a write operation on the in-memory filesystem.
+ */
+interface FsWriteResults {
+  changedContent: boolean;
+  queuedWrite: boolean;
+  ignored: boolean;
+}
+/**
+ * Options supported by read methods on the in-memory filesystem.
+ */
+interface FsReadOptions {
+  useCache?: boolean;
+  setHash?: boolean;
+}
+/**
+ * Options supported by the readdir option on the in-memory filesystem.
+ */
+interface FsReaddirOptions {
+  inMemoryOnly?: boolean;
+  recursive?: boolean;
+  /**
+   * Directory names to exclude. Just the basename,
+   * not the entire path. Basically for "node_modules".
+   */
+  excludeDirNames?: string[];
+  /**
+   * Extensions we know we can avoid. Each extension
+   * should include the `.` so that we can test for both
+   * `.d.ts.` and `.ts`. If `excludeExtensions` isn't provided it
+   * doesn't try to exclude anything. This only checks against
+   * the filename, not directory names when recursive.
+   */
+  excludeExtensions?: string[];
+}
+/**
+ * A result from a directory read operation
+ */
+interface FsReaddirItem {
+  absPath: string;
+  relPath: string;
+  isDirectory: boolean;
+  isFile: boolean;
+}
+/**
+ * Information about a file in the in-memory filesystem.
+ */
+interface FsStat {
+  exists: boolean;
+  isFile: boolean;
+  isDirectory: boolean;
+  size: number;
+}
+/**
+ * Create an in-memory FS which proxies the underlying OS filesystem using an
+ * in-memory cache. FS writes can accumulate on the in-memory system, using an
+ * API similar to Node.js' `"fs"` module, and then be committed to disk as a
+ * unit.
+ *
+ * Files written to the in-memory system can be edited, deleted, and so on.
+ * This allows the compiler to proceed freely as if it is modifying the
+ * filesystem, modifying the world in whatever way suits it, while deferring
+ * actual FS writes until the end of the compilation process, making actual
+ * changes to the filesystem on disk contingent on an error-free build or any
+ * other condition.
+ *
+ * @param sys a compiler system object
+ * @returns an in-memory filesystem interface
+ */
+declare const createInMemoryFs: (sys: CompilerSystem) => {
+  access: (filePath: string) => Promise<boolean>;
+  accessSync: (filePath: string) => boolean;
+  cancelDeleteDirectoriesFromDisk: (dirPaths: string[]) => void;
+  cancelDeleteFilesFromDisk: (filePaths: string[]) => void;
+  clearCache: () => void;
+  clearDirCache: (dirPath: string) => void;
+  clearFileCache: (filePath: string) => void;
+  commit: () => Promise<FsCommitResults>;
+  copyFile: (src: string, dest: string) => Promise<void>;
+  emptyDirs: (dirs: string[]) => Promise<void>;
+  getBuildOutputs: () => BuildOutput[];
+  getItem: (itemPath: string) => FsItem;
+  getMemoryStats: () => string;
+  readFile: (filePath: string, opts?: FsReadOptions) => Promise<string>;
+  readFileSync: (filePath: string, opts?: FsReadOptions) => string;
+  readdir: (dirPath: string, opts?: FsReaddirOptions) => Promise<FsReaddirItem[]>;
+  remove: (itemPath: string) => Promise<void>;
+  stat: (itemPath: string) => Promise<FsStat>;
+  statSync: (itemPath: string) => FsStat;
+  sys: CompilerSystem;
+  writeFile: (filePath: string, content: string, opts?: FsWriteOptions) => Promise<FsWriteResults>;
+  writeFiles: (files: {
+    [filePath: string]: string;
+  } | Map<string, string>, opts?: FsWriteOptions) => Promise<FsWriteResults[]>;
+};
+/**
+ * The information needed to carry out a file copy operation.
+ *
+ * `[ source, destination ]`
+ */
+type FileCopyTuple = [string, string];
+/**
+ * Results from committing pending filesystem operations
+ */
+interface FsCommitResults {
+  filesCopied: FileCopyTuple[];
+  filesWritten: string[];
+  filesDeleted: string[];
+  dirsDeleted: string[];
+  dirsAdded: string[];
+}
+//#endregion
+//#region src/declarations/stencil-public-docs.d.ts
+/**
+ * The Type Library holds information about the types which are used in a
+ * Stencil project. During compilation, Stencil gathers information about the
+ * types which form part of a component's public API, such as properties
+ * decorated with `@Prop`, `@Event`, `@Watch`, etc. This type information is
+ * then added to the Type Library, where it can be accessed later on for
+ * generating documentation.
+ *
+ * This information is included in the file written by the `docs-json` output
+ * target (see {@link JsonDocs.typeLibrary}).
+ */
+type JsonDocsTypeLibrary = Record<string, ComponentCompilerReferencedType>;
+/**
+ * A container for JSDoc metadata for a project
+ */
+interface JsonDocs {
+  /**
+   * The metadata for the JSDocs for each component in a Stencil project
+   */
+  components: JsonDocsComponent[];
+  /**
+   * Project-level usage content, collected from markdown files in a `usage`
+   * directory at the project's {@link Config.srcDir} root (as opposed to
+   * per-component usage content, which lives in {@link JsonDocsComponent.usage}).
+   * Keyed by file name (without extension), same shape as component usage.
+   */
+  usage?: JsonDocsUsage;
+  /**
+   * The timestamp at which the metadata was generated, in the format YYYY-MM-DDThh:mm:ss
+   */
+  timestamp: string;
+  compiler: {
+    /**
+     * The name of the compiler that generated the metadata
+     */
+    name: string;
+    /**
+     * The version of the Stencil compiler that generated the metadata
+     */
+    version: string;
+    /**
+     * The version of TypeScript that was used to generate the metadata
+     */
+    typescriptVersion: string;
+  };
+  typeLibrary: JsonDocsTypeLibrary;
+}
+/**
+ * Container for JSDoc metadata for a single Stencil component
+ */
+interface JsonDocsComponent {
+  /**
+   * The directory containing the Stencil component, minus the file name.
+   *
+   * @example /workspaces/stencil-project/src/components/my-component
+   */
+  dirPath?: string;
+  /**
+   * The name of the file containing the Stencil component, with no path
+   *
+   * @example my-component.tsx
+   */
+  fileName?: string;
+  /**
+   * The full path of the file containing the Stencil component
+   *
+   * @example /workspaces/stencil-project/src/components/my-component/my-component.tsx
+   */
+  filePath?: string;
+  /**
+   * The path to the component's `readme.md` file, including the filename
+   *
+   * @example /workspaces/stencil-project/src/components/my-component/readme.md
+   */
+  readmePath?: string;
+  /**
+   * The path to the component's `usage` directory
+   *
+   * @example /workspaces/stencil-project/src/components/my-component/usage/
+   */
+  usagesDir?: string;
+  /**
+   * The encapsulation strategy for a component
+   */
+  encapsulation: 'shadow' | 'scoped' | 'none';
+  /**
+   * The tag name for the component, for use in HTML
+   */
+  tag: string;
+  /**
+   * The contents of a component's `readme.md` that are user generated.
+   *
+   * Auto-generated contents are not stored in this reference.
+   */
+  readme: string;
+  /**
+   * The description of a Stencil component, found in the JSDoc that sits above the component's declaration
+   */
+  docs: string;
+  /**
+   * JSDoc tags found in the JSDoc comment written atop a component's declaration
+   */
+  docsTags: JsonDocsTag[];
+  /**
+   * The text from the class-level JSDoc for a Stencil component, if present.
+   */
+  overview?: string;
+  /**
+   * A mapping of usage example file names to their contents for the component.
+   */
+  usage: JsonDocsUsage;
+  /**
+   * Array of metadata for a component's `@Prop`s
+   */
+  props: JsonDocsProp[];
+  /**
+   * Array of metadata for a component's `@Method`s
+   */
+  methods: JsonDocsMethod[];
+  /**
+   * Array of metadata for a component's `@Event`s
+   */
+  events: JsonDocsEvent[];
+  /**
+   * Array of metadata for a component's `@Listen` handlers
+   */
+  listeners: JsonDocsListener[];
+  /**
+   * Array of metadata for a component's CSS styling information
+   */
+  styles: JsonDocsStyle[];
+  /**
+   * Array of component Slot information, generated from `@slot` tags
+   */
+  slots: JsonDocsSlot[];
+  /**
+   * Array of component Parts information, generate from `@part` tags
+   */
+  parts: JsonDocsPart[];
+  /**
+   * Array of custom states defined via @AttachInternals({ states: {...} })
+   */
+  customStates: JsonDocsCustomState[];
+  /**
+   * Array of metadata describing where the current component is used
+   */
+  dependents: string[];
+  /**
+   * Array of metadata listing the components which are used in current component
+   */
+  dependencies: string[];
+  /**
+   * Describes a tree of components coupling
+   */
+  dependencyGraph: JsonDocsDependencyGraph;
+  /**
+   * A deprecation reason/description found following a `@deprecated` tag
+   */
+  deprecation?: string;
+}
+interface JsonDocsDependencyGraph {
+  [tagName: string]: string[];
+}
+/**
+ * A descriptor for a single JSDoc tag found in a block comment
+ */
+interface JsonDocsTag {
+  /**
+   * The tag name (immediately following the '@')
+   */
+  name: string;
+  /**
+   * The description that immediately follows the tag name
+   */
+  text?: string;
+}
+interface JsonDocsValue {
+  value?: string;
+  type: string;
+}
+/**
+ * A mapping of file names to their contents.
+ *
+ * This type is meant to be used when reading one or more usage markdown files associated with a component. For the
+ * given directory structure:
+ * ```
+ * src/components/my-component
+ * ├── my-component.tsx
+ * └── usage
+ *     ├── bar.md
+ *     └── foo.md
+ * ```
+ * an instance of this type would include the name of the markdown file, mapped to its contents:
+ * ```ts
+ * {
+ *   'bar': STRING_CONTENTS_OF_BAR.MD
+ *   'foo': STRING_CONTENTS_OF_FOO.MD
+ * }
+ * ```
+ */
+interface JsonDocsUsage {
+  [key: string]: string;
+}
+/**
+ * An intermediate representation of a `@Prop` decorated member's JSDoc
+ */
+interface JsonDocsProp {
+  /**
+   * the name of the prop
+   */
+  name: string;
+  complexType?: ComponentCompilerPropertyComplexType;
+  /**
+   * the type of the prop, in terms of the TypeScript type system (as opposed to JavaScript's or HTML's)
+   */
+  type: string;
+  /**
+   * `true` if the prop was configured as "mutable" where it was declared, `false` otherwise
+   */
+  mutable: boolean;
+  /**
+   * The name of the attribute that is exposed to configure a compiled web component
+   */
+  attr?: string;
+  /**
+   * `true` if the prop was configured to "reflect" back to HTML where it (the prop) was declared, `false` otherwise
+   */
+  reflectToAttr: boolean;
+  /**
+   * the JSDoc description text associated with the prop
+   */
+  docs: string;
+  /**
+   * JSDoc tags associated with the prop
+   */
+  docsTags: JsonDocsTag[];
+  /**
+   * The default value of the prop
+   */
+  default?: string;
+  /**
+   * Deprecation text associated with the prop. This is the text that immediately follows a `@deprecated` tag
+   */
+  deprecation?: string;
+  values: JsonDocsValue[];
+  /**
+   * `true` if a component is declared with a '?', `false` otherwise
+   *
+   * @example
+   * ```tsx
+   * @Prop() componentProps?: any;
+   * ```
+   */
+  optional: boolean;
+  /**
+   * `true` if a component is declared with a '!', `false` otherwise
+   *
+   * @example
+   * ```tsx
+   * @Prop() componentProps!: any;
+   * ```
+   */
+  required: boolean;
+  /**
+   * `true` if the prop has a `get()`. `false` otherwise
+   */
+  getter: boolean;
+  /**
+   * `true` if the prop has a `set()`. `false` otherwise
+   */
+  setter: boolean;
+}
+interface JsonDocsMethod {
+  name: string;
+  docs: string;
+  docsTags: JsonDocsTag[];
+  deprecation?: string;
+  signature: string;
+  returns: JsonDocsMethodReturn;
+  parameters: JsonDocMethodParameter[];
+  complexType: ComponentCompilerMethodComplexType;
+}
+interface JsonDocsMethodReturn {
+  type: string;
+  docs: string;
+}
+interface JsonDocMethodParameter {
+  name: string;
+  type: string;
+  docs: string;
+}
+interface JsonDocsEvent {
+  event: string;
+  bubbles: boolean;
+  cancelable: boolean;
+  composed: boolean;
+  complexType: ComponentCompilerEventComplexType;
+  docs: string;
+  docsTags: JsonDocsTag[];
+  deprecation?: string;
+  detail: string;
+}
+/**
+ * Type describing a CSS Style, as described by a JSDoc-style comment
+ */
+interface JsonDocsStyle {
+  /**
+   * The name of the style
+   */
+  name: string;
+  /**
+   * The type/description associated with the style
+   */
+  docs: string;
+  /**
+   * The annotation used in the JSDoc of the style (e.g. `@prop`)
+   */
+  annotation: string;
+  /**
+   * The mode associated with the style
+   */
+  mode: string | undefined;
+}
+interface JsonDocsListener {
+  event: string;
+  target?: string;
+  capture: boolean;
+  passive: boolean;
+}
+/**
+ * A descriptor for a slot
+ *
+ * Objects of this type are translated from the JSDoc tag, `@slot`
+ */
+interface JsonDocsSlot {
+  /**
+   * The name of the slot. Defaults to an empty string for an unnamed slot.
+   */
+  name: string;
+  /**
+   * A textual description of the slot.
+   */
+  docs: string;
+}
+/**
+ * A descriptor of a CSS Shadow Part
+ *
+ * Objects of this type are translated from the JSDoc tag, `@part`, or the 'part'
+ * attribute on a component in TSX
+ */
+interface JsonDocsPart {
+  /**
+   * The name of the Shadow part
+   */
+  name: string;
+  /**
+   * A textual description of the Shadow part.
+   */
+  docs: string;
+}
+/**
+ * A descriptor for a Custom State defined via @AttachInternals({ states: {...} })
+ *
+ * Custom states are exposed via the ElementInternals.states CustomStateSet
+ * and can be targeted with the CSS `:state()` pseudo-class.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+ */
+interface JsonDocsCustomState {
+  /**
+   * The name of the custom state (without dashes)
+   */
+  name: string;
+  /**
+   * The initial/default value of the state
+   */
+  initialValue: boolean;
+  /**
+   * A textual description of the custom state
+   */
+  docs: string;
+}
+/**
+ * Represents a parsed block comment in a CSS, Sass, etc. file for a custom property.
+ */
+interface StyleDoc {
+  /**
+   * The name of the CSS property
+   */
+  name: string;
+  /**
+   * The user-defined description of the CSS property
+   */
+  docs: string;
+  /**
+   * The JSDoc-style annotation (e.g. `@prop`) that was used in the block comment to detect the comment.
+   * Used to inform Stencil where the start of a new property's description starts (and where the previous description
+   * ends).
+   */
+  annotation: 'prop';
+  /**
+   * The Stencil style-mode that is associated with this property.
+   */
+  mode: string | undefined;
+}
+//#endregion
+//#region src/declarations/stencil-public-runtime.d.ts
+type ListenTargetOptions = 'body' | 'document' | 'window';
+interface UserBuildConditionals {
+  isDev: boolean;
+  isBrowser: boolean;
+  isServer: boolean;
+  isTesting: boolean;
+}
+type ErrorHandler = (err: any, element?: HTMLElement) => void;
+/**
+ * A constructor type that can be used as the base for mixin factories.
+ *
+ * ```ts
+ * import { MixedInCtor } from '@stencil/core';
+ *
+ * const AFactoryFn = <B extends MixedInCtor>(Base: B) => {class A extends Base { propA = A }; return A;}
+ * ```
+ */
+type MixedInCtor<T = {}> = new (...args: any[]) => T;
+/**
+ * A map of `@Prop`/`@State` property names to their new and previous
+ * values, passed to `componentShouldUpdate` once per render cycle.
+ *
+ * Pass `this` as `T` to type `changes` against your component's own
+ * members, e.g. `componentShouldUpdate(changes: ComponentShouldUpdateChanges<this>)`.
+ */
+type ComponentShouldUpdateChanges<T = any> = { [K in Extract<keyof T, string>]?: {
+  newVal: T[K];
+  oldVal: T[K];
+}; };
+interface ComponentInterface {
+  connectedCallback?(): void;
+  disconnectedCallback?(): void;
+  componentWillRender?(): Promise<void> | void;
+  componentDidRender?(): void;
+  /**
+   * The component is about to load and it has not
+   * rendered yet.
+   *
+   * This is the best place to make any data updates
+   * before the first render.
+   *
+   * componentWillLoad will only be called once.
+   */
+  componentWillLoad?(): Promise<void> | void;
+  /**
+   * The component has loaded and has already rendered.
+   *
+   * Updating data in this method will cause the
+   * component to re-render.
+   *
+   * componentDidLoad will only be called once.
+   */
+  componentDidLoad?(): void;
+  /**
+   * One or more `@Prop` or `@State` properties changed and a rerender is
+   * about to be requested. `changes` contains every property that changed
+   * since the last render, keyed by property name.
+   *
+   * Called once per render cycle, batching all properties that changed
+   * synchronously since the last render.
+   *
+   * Return `false` to prevent the pending render.
+   *
+   * componentShouldUpdate is not called on the first render.
+   */
+  componentShouldUpdate?(changes: ComponentShouldUpdateChanges<this>): boolean | void;
+  /**
+   * The component is about to update and re-render.
+   *
+   * Called multiple times throughout the life of
+   * the component as it updates.
+   *
+   * componentWillUpdate is not called on the first render.
+   */
+  componentWillUpdate?(): Promise<void> | void;
+  /**
+   * The component has just re-rendered.
+   *
+   * Called multiple times throughout the life of
+   * the component as it updates.
+   *
+   * componentWillUpdate is not called on the
+   * first render.
+   */
+  componentDidUpdate?(): void;
+  render?(): any;
+  [memberName: string]: any;
+}
+/**
+ * A reusable behavior that hooks into a `ReactiveControllerHost`'s lifecycle. Modeled after Lit's
+ * `ReactiveController` pattern: implement the hooks you need, then register an instance with a host
+ * via `host.addController(this)`.
+ */
+interface ReactiveController {
+  hostConnected?(): void;
+  hostDisconnected?(): void;
+  hostWillLoad?(): Promise<void> | void;
+  hostDidLoad?(): void;
+  hostWillRender?(): Promise<void> | void;
+  hostDidRender?(): void;
+  hostWillUpdate?(): Promise<void> | void;
+  hostDidUpdate?(): void;
+}
+/**
+ * The shape added to a component by mixing in `ReactiveControllerHost` (see below).
+ */
+interface ReactiveControllerHostInterface extends ComponentInterface, HTMLElement {
+  readonly controllers: ReadonlySet<ReactiveController>;
+  addController(controller: ReactiveController): void;
+  removeController(controller: ReactiveController): void;
+  requestUpdate(): void;
+  /**
+   * Resolves once the next pending render commits. Matches the shape of Lit's
+   * `ReactiveControllerHost.updateComplete`, for interop with controllers written against Lit's API
+   * (e.g. `@lit/context`).
+   */
+  readonly updateComplete: Promise<boolean>;
+}
+interface RafCallback {
+  (timeStamp: number): void;
+}
+/**
+ * Utilities for working with functional Stencil components. An object
+ * conforming to this interface is passed by the Stencil runtime as the third
+ * argument to a functional component, allowing component authors to work with
+ * features like children.
+ *
+ * The children of a functional component will be passed as the second
+ * argument, so a functional component which uses these utils to transform its
+ * children might look like the following:
+ *
+ * ```ts
+ * export const AddClass: FunctionalComponent = (_, children, utils) => (
+ *  utils.map(children, child => ({
+ *    ...child,
+ *    vattrs: {
+ *      ...child.vattrs,
+ *      class: `${child.vattrs.class} add-class`
+ *    }
+ *  }))
+ * );
+ * ```
+ *
+ * For more see the Stencil documentation, here:
+ * https://stenciljs.com/docs/functional-components
+ */
+interface FunctionalUtilities {
+  /**
+   * Utility for reading the children of a functional component at runtime.
+   * Since the Stencil runtime uses a different interface for children it is
+   * not recommended to read the children directly, and is preferable to use
+   * this utility to, for instance, perform a side effect for each child.
+   */
+  forEach: (children: VNode[], cb: (vnode: ChildNode$1, index: number, array: ChildNode$1[]) => void) => void;
+  /**
+   * Utility for transforming the children of a functional component. Given an
+   * array of children and a callback this will return a list of the results of
+   * passing each child to the supplied callback.
+   */
+  map: (children: VNode[], cb: (vnode: ChildNode$1, index: number, array: ChildNode$1[]) => ChildNode$1) => VNode[];
+}
+interface FunctionalComponent<T = {}> {
+  (props: T, children: VNode[], utils: FunctionalUtilities): VNode | null;
+}
+/**
+ * A Child VDOM node
+ *
+ * This has most of the same properties as {@link VNode} but friendlier names
+ * (i.e. `vtag` instead of `$tag$`, `vchildren` instead of `$children$`) in
+ * order to provide a friendlier public interface for users of the
+ * {@link FunctionalUtilities}).
+ */
+interface ChildNode$1 {
+  vtag?: string | number | Function | symbol | null;
+  vkey?: string | number;
+  vtext?: string;
+  vchildren?: VNode[];
+  vattrs?: any;
+  vname?: string;
+}
+/**
+ * A virtual DOM node
+ */
+interface VNode {
+  $flags$: number;
+  $tag$: string | number | Function | symbol | null;
+  $elm$: any;
+  $text$: string;
+  $children$: VNode[];
+  $attrs$?: any;
+  $name$?: string;
+  $key$?: string | number;
+  /** Signal reference for vdom bypass: signal text nodes store the signal here. */
+  $signal$?: any;
+}
+//#endregion
+//#region src/declarations/stencil-public-compiler.d.ts
+/**
+ * https://stenciljs.com/docs/config/
+ */
+interface StencilConfig {
+  /**
+   * By default, Stencil will attempt to optimize small scripts by inlining them in HTML. Setting
+   * this flag to `false` will prevent this optimization and keep all scripts separate from HTML.
+   */
+  allowInlineScripts?: boolean;
+  /**
+   * By setting `autoprefixCss` to `true`, Stencil will use the appropriate config to automatically
+   * prefix css. For example, developers can write modern and standard css properties, such as
+   * "transform", and Stencil will automatically add in the prefixed version, such as "-webkit-transform".
+   * As of Stencil v2, autoprefixing CSS is no longer the default.
+   * Defaults to `false`
+   */
+  autoprefixCss?: boolean | any;
+  /**
+   * By default, Stencil will statically analyze the application and generate a component graph of
+   * how all the components are interconnected.
+   *
+   * From the component graph it is able to best decide how components should be grouped
+   * depending on their usage with one another within the app.
+   * By doing so it's able to bundle components together in order to reduce network requests.
+   * However, bundles can be manually generated using the bundles config.
+   *
+   * The bundles config is an array of objects that represent how components are grouped together
+   * in lazy-loaded bundles.
+   * This config is rarely needed as Stencil handles this automatically behind the scenes.
+   */
+  bundles?: ConfigBundle[];
+  /**
+   * Stencil will cache build results in order to speed up rebuilds.
+   * To disable this feature, set enableCache to false.
+   */
+  enableCache?: boolean;
+  /**
+   * The directory where sub-directories will be created for caching when `enableCache` is set
+   * `true` or if using Stencil's Screenshot Connector.
+   *
+   * @default '.stencil'
+   *
+   * @example
+   *
+   * A Stencil config like the following:
+   * ```ts
+   * export const config = {
+   *  ...,
+   *  enableCache: true,
+   *  cacheDir: '.cache',
+   *  testing: {
+   *    screenshotConnector: 'connector.js'
+   *  }
+   * }
+   * ```
+   *
+   * Will result in the following file structure:
+   * ```tree
+   * stencil-project-root
+   * └── .cache
+   *     ├── .build <-- Where build related file caching is written
+   *     |
+   *     └── screenshot-cache.json <-- Where screenshot caching is written
+   * ```
+   */
+  cacheDir?: string;
+  /**
+   * Stencil is traditionally used to compile many components into an app,
+   * and each component comes with its own compartmentalized styles.
+   * However, it's still common to have styles which should be "global" across all components and the website.
+   * A global CSS file is often useful to set CSS Variables.
+   *
+   * Additionally, the globalStyle config can be used to precompile styles with Sass, PostCSS, etc.
+   * Below is an example folder structure containing a webapp's global sass file, named app.css.
+   */
+  globalStyle?: string;
+  /**
+   * Will generate {@link https://nodejs.org/api/packages.html#packages_exports export map} entry points
+   * for each component in the build when `true`.
+   *
+   * @default false
+   */
+  generateExportMaps?: boolean;
+  /**
+   * The namespace config is a string representing a namespace for the app.
+   * For apps that are not meant to be a library of reusable components,
+   * the default of App is just fine. However, if the app is meant to be consumed
+   * as a third-party library, such as Ionic, a unique namespace is required.
+   */
+  namespace?: string;
+  /**
+   * Stencil is able to take an app's source and compile it to numerous targets,
+   * such as an app to be deployed on an http server, or as a third-party library
+   * to be distributed on npm. By default, Stencil apps have an output target type of www.
+   *
+   * The outputTargets config is an array of objects, with types of www and dist.
+   */
+  outputTargets?: OutputTarget[];
+  /**
+   * The plugins config can be used to add your own rolldown plugins, or Stencil's own
+   * legacy `resolveId`/`load`/`transform` style plugins (identified by a `pluginType`
+   * property). By default, Stencil does not come with Sass or PostCSS support.
+   * However, either can be added using the plugin array.
+   */
+  plugins?: (Plugin$1 | Plugin)[];
+  /**
+   * Generate js source map files for all bundles.
+   * Set to `true` to always generate source maps, `false` to never generate source maps.
+   * Set to `'dev'` to only generate source maps when the `--dev` flag is passed.
+   * Defaults to `'dev'`.
+   */
+  sourceMap?: boolean | 'dev';
+  /**
+   * The srcDir config specifies the directory which should contain the source typescript files
+   * for each component. The standard for Stencil apps is to use src, which is the default.
+   */
+  srcDir?: string;
+  /**
+   * Sets whether or not Stencil should transform path aliases set in a project's
+   * `tsconfig.json` from the assigned module aliases to resolved relative paths.
+   *
+   * This behavior defaults to `true`, but may be opted-out of by setting this flag to `false`.
+   */
+  transformAliasedImportPaths?: boolean;
+  /**
+   * Passes custom configuration down to the "@rolldown/plugin-node-resolve" that Stencil uses under the hood.
+   * For further information: https://stenciljs.com/docs/module-bundling
+   */
+  nodeResolve?: NodeResolveConfig;
+  /**
+   * Passes custom configuration down to rolldown itself, not all rolldown options can be overridden.
+   */
+  rolldownConfig?: RolldownConfig;
+  /**
+   * Sets if the JS browser files are minified or not. Stencil uses `terser` under the hood.
+   * Defaults to `false` in dev mode and `true` in production mode.
+   */
+  minifyJs?: boolean;
+  /**
+   * Sets if the CSS is minified or not.
+   * Defaults to `false` in dev mode and `true` in production mode.
+   */
+  minifyCss?: boolean;
+  /**
+   * Object to provide a custom logger. By default a `logger` is already provided for the
+   * platform the compiler is running on, such as NodeJS or a browser.
+   */
+  logger?: Logger;
+  /**
+   * Compatibility and workaround flags for framework/bundler edge cases
+   * and rarely-needed diagnostic suppressions.
+   */
+  compat?: ConfigCompat;
+  /**
+   * Replace `@State` and `@Prop` internals with `@preact/signals-core` signal primitives.
+   * Enables cross-framework reactive interop - component state becomes subscribable by
+   * Solid, Angular, Preact and any TC39-signal-compatible library without event/attribute
+   * roundtrips. No API changes required in component code.
+   * Defaults to `false`.
+   */
+  signalBacking?: boolean;
+  /**
+   * The hydrated flag identifies if a component and all of its child components
+   * have finished hydrating. This helps prevent any flash of unstyled content (FOUC)
+   * as various components are asynchronously downloaded and rendered. By default it
+   * will add the `hydrated` CSS class to the element. The `hydratedFlag` config can be used
+   * to change the name of the CSS class, change it to an attribute, or change which
+   * type of CSS properties and values are assigned before and after hydrating. This config
+   * can also be used to not include the hydrated flag at all by setting it to `null`.
+   */
+  hydratedFlag?: HydratedFlag | null;
+  /**
+   * Ionic prefers to hide all components prior to hydration with a style tag appended
+   * to the head of the document containing some `visibility: hidden;` css rules.
+   *
+   * Disabling this will remove the style tag that sets `visibility: hidden;` on all
+   * un-hydrated web components. This more closely follows the HTML spec, and allows
+   * you to set your own fallback content.
+   *
+   */
+  invisiblePrehydration?: boolean;
+  /**
+   * Sets the task queue used by stencil's runtime. The task queue schedules DOM read and writes
+   * across the frames to efficiently render and reduce layout thrashing. By default,
+   * `async` is used. It's recommended to also try each setting to decide which works
+   * best for your use-case. In all cases, if your app has many CPU intensive tasks causing the
+   * main thread to periodically lock-up, it's always recommended to try
+   * [Web Workers](https://stenciljs.com/docs/web-workers) for those tasks.
+   *
+   * - `async`: DOM read and writes are scheduled in the next frame to prevent layout thrashing.
+   *   During intensive CPU tasks it will not reschedule rendering to happen in the next frame.
+   *   `async` is ideal for most apps, and if the app has many intensive tasks causing the main
+   *   thread to lock-up, it's recommended to try [Web Workers](https://stenciljs.com/docs/web-workers)
+   *   rather than the congestion async queue.
+   *
+   * - `congestionAsync`: DOM reads and writes are scheduled in the next frame to prevent layout
+   *   thrashing. When the app is heavily tasked and the queue becomes congested it will then
+   *   split the work across multiple frames to prevent blocking the main thread. However, it can
+   *   also introduce unnecessary reflows in some cases, especially during startup. `congestionAsync`
+   *   is ideal for apps running animations while also simultaneously executing intensive tasks
+   *   which may lock-up the main thread.
+   *
+   * - `immediate`: Makes writeTask() and readTask() callbacks to be executed synchronously. Tasks
+   *   are not scheduled to run in the next frame, but do note there is at least one microtask.
+   *   The `immediate` setting is ideal for apps that do not provide long running and smooth
+   *   animations. Like the async setting, if the app has intensive tasks causing the main thread
+   *   to lock-up, it's recommended to try [Web Workers](https://stenciljs.com/docs/web-workers).
+   */
+  taskQueue?: 'async' | 'immediate' | 'congestionAsync';
+  /**
+   * Provide a object of key/values accessible within the app, using the `Env` object.
+   */
+  env?: {
+    [prop: string]: string | undefined;
+  };
+  docs?: StencilDocsConfig;
+  globalScript?: string;
+  srcIndexHtml?: string;
+  maxConcurrentWorkers?: number;
+  preamble?: string;
+  rolldownPlugins?: {
+    before?: Plugin[];
+    after?: Plugin[];
+  };
+  entryComponentsHint?: string[];
+  buildLogFilePath?: string;
+  devInspector?: boolean;
+  devServer?: StencilDevServerConfig;
+  sys?: CompilerSystem;
+  tsconfig?: string;
+  validateTypes?: boolean;
+  /**
+   * Sets whether Stencil will watch for changes in the source files and rebuild the project automatically.
+   * @default true
+   */
+  watch?: boolean;
+  /**
+   * External directories to watch for changes. By default, Stencil will watch the root and {@link StencilConfig.srcDir}
+   * directory for changes. If you want to watch additional directories, including e.g. `node_modules`, you can add them here.
+   * @default []
+   */
+  watchExternalDirs?: string[];
+  /**
+   * An array of RegExp patterns that are matched against all source files before adding
+   * to the watch list in watch mode. If the file path matches any of the patterns, when it
+   * is updated, it will not trigger a re-run of tests.
+   */
+  watchIgnoredRegex?: RegExp | RegExp[];
+  /**
+   * An array of component tag names to exclude from production builds.
+   * Useful to remove test, demo or experimental components from final output.
+   *
+   * **Note:** Exclusion only applies to production builds (the default).
+   * Development builds (with `--dev` flag) will include all components to support local testing.
+   *
+   * Supports glob patterns for matching multiple components:
+   * - `['demo-*']` - Excludes all components starting with "demo-"
+   * - `['*-test', '*-demo']` - Excludes components ending with "-test" or "-demo"
+   * - `['my-component']` - Excludes a specific component
+   *
+   * Components matching these patterns will be completely excluded from all output targets.
+   *
+   * @example
+   * ```ts
+   * export const config: Config = {
+   *   excludeComponents: ['demo-*', 'test-component', '*-internal'],
+   * };
+   * ```
+   *
+   * @default []
+   */
+  excludeComponents?: string[];
+  /**
+   * Set whether unused dependencies should be excluded from the built output.
+   */
+  excludeUnusedDependencies?: boolean;
+  /**
+   * Declares the set of valid style "modes" (e.g. `ios`, `md`) used by mode-keyed
+   * `styleUrls`/`styles` in `@Component()`. When set, the compiler validates that
+   * every mode key used in a component matches one of these entries, catching typos
+   * at build time. Entries marked `required` must be present on every component that
+   * defines any mode-keyed styles.
+   *
+   * @example
+   * ```ts
+   * export const config: Config = {
+   *   modes: ['ios', { mode: 'md', required: true }],
+   * };
+   * ```
+   *
+   * @default []
+   */
+  modes?: (string | ModeConfig)[];
+  /**
+   * Explicitly declare which npm packages are Stencil collections to be re-bundled into this project.
+   *
+   * Without this option, collection ingestion is triggered only by a side-effect import:
+   * ```ts
+   * import '@ionic/core';
+   * ```
+   * @example
+   * ```ts
+   * export const config: Config = {
+   *   collections: ['@ionic/core', '@my-org/design-system'],
+   * };
+   * ```
+   *
+   * @default []
+   */
+  collections?: string[];
+}
+/**
+ * DOM patches for light-dom / scoped components that use `<slot>`.
+ *
+ * These patches shield the component's slot machinery from framework DOM mutations
+ * (e.g. when Angular or React insert / remove nodes they route directly to the host
+ * element, bypassing the slot polyfill) and prevent hydration errors when a framework
+ * encounters Stencil's internal slot reference nodes during SSR reconciliation.
+ *
+ * Patches are only applied at runtime when a component is both non-shadow **and**
+ * declares at least one `<slot>`, so enabling them has no effect on pure shadow-DOM
+ * components.
+ *
+ * Set to `true` (default) to enable all patches, `false` to disable all, or an object
+ * for granular control.
+ */
+type LightDomPatches = {
+  /** Patches `childNodes`/`children` getters to return only slotted content. */
+  childNodes?: boolean;
+  /** Patches `cloneNode()` to correctly deep-clone slotted content. */
+  cloneNode?: boolean;
+  /** Patches `appendChild()`, `insertBefore()`, and `removeChild()` to route to the correct slot. */
+  domMutations?: boolean;
+  /** Patches `textContent` to act like shadow DOM (reads/writes slotted text only). */
+  textContent?: boolean;
+};
+/**
+ * Compatibility and workaround flags, primarily for shielding non-shadow DOM components
+ * from consuming frameworks that mutate internals they don't know about, plus other
+ * framework/bundler integration edge cases and rarely-needed diagnostic suppressions.
+ * These are opt-in behaviors that aren't needed by every project.
+ */
+interface ConfigCompat {
+  /**
+   * Projects that use a Stencil library built using the `dist` output target may have trouble lazily
+   * loading components when using a bundler such as Vite or Parcel. Setting this flag to `true` will change how Stencil
+   * lazily loads components in a way that works with additional bundlers. Setting this flag to `true` will increase
+   * the size of the compiled output. Defaults to `true`.
+   */
+  enableImportInjection?: boolean;
+  /**
+   * Dispatches component lifecycle events. Mainly used for testing. Defaults to `false`.
+   */
+  lifecycleDOMEvents?: boolean;
+  /**
+   * When a component is first attached to the DOM, this setting will wait a single tick before
+   * rendering. This works around an Angular issue, where Angular attaches the elements before
+   * settings their initial state, leading to double renders and unnecessary event dispatches.
+   * Defaults to `false`.
+   */
+  initializeNextTick?: boolean;
+  /**
+   * Adds `transformTag` calls to css strings and querySelector(All) calls.
+   * Use `'prod'` to enable only in production builds.
+   */
+  additionalTagTransformers?: boolean | 'prod';
+  /**
+   * DOM patches for light-dom / scoped components that use `<slot>`.
+   * See {@link LightDomPatches} for granular control. Defaults to `true`.
+   */
+  lightDomPatches?: boolean | LightDomPatches;
+  /**
+   * When `true`, Stencil will suppress diagnostics which warn about public members using reserved names
+   * (for example, decorating a method named `focus` with `@Method()`). Defaults to `false`.
+   */
+  suppressPublicNameWarnings?: boolean;
+  /**
+   * When `true`, Stencil will suppress diagnostics which warn about event names conflicting with native DOM event names. Defaults to `false`.
+   */
+  suppressEventNameWarnings?: boolean;
+}
+interface Config extends StencilConfig {
+  buildAppCore?: boolean;
+  configPath?: string;
+  writeLog?: boolean;
+  devServer?: DevServerConfig;
+  fsNamespace?: string;
+  logLevel?: LogLevel;
+  rootDir?: string;
+  packageJsonFilePath?: string;
+  suppressLogs?: boolean;
+  profile?: boolean;
+  tsCompilerOptions?: any;
+  tsWatchOptions?: any;
+  _isValidated?: boolean;
+  _isTesting?: boolean;
+  /**
+   * Internal flag set when --docs CLI flag is used.
+   * Forces docs output targets to build even in dev mode.
+   */
+  _docsFlag?: boolean;
+  /**
+   * Whether running in a CI environment (disables interactive features, adjusts worker count)
+   */
+  ci?: boolean;
+  /**
+   * Enable server-side rendering mode
+   */
+  ssr?: boolean;
+  /**
+   * Enable prerendering
+   */
+  prerender?: boolean;
+  /**
+   * Path to output docs JSON file (when --docsJson flag is used)
+   */
+  docsJsonPath?: string;
+  /**
+   * Path to output stats JSON file, or true to use default path
+   */
+  statsJsonPath?: string | boolean;
+  /**
+   * Whether to generate service worker
+   */
+  generateServiceWorker?: boolean;
+  /**
+   * Dev server address override
+   */
+  devServerAddress?: string;
+  /**
+   * Dev server port override
+   */
+  devServerPort?: number;
+  /**
+   * Whether to open browser on dev server start
+   */
+  devServerOpen?: boolean;
+}
+/**
+ * A 'loose' type useful for wrapping an incomplete / possible malformed
+ * object as we work on getting it comply with a particular Interface T.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Foo {
+ *   bar: string
+ * }
+ *
+ * function validateFoo(foo: Loose<Foo>): Foo {
+ *   let validatedFoo = {
+ *     ...foo,
+ *     bar: foo.bar || DEFAULT_BAR
+ *   }
+ *
+ *   return validatedFoo
+ * }
+ * ```
+ *
+ * Use this when you need to take user input or something from some other part
+ * of the world that we don't control and transform it into something
+ * conforming to a given interface. For best results, pair with a validation
+ * function as shown in the example.
+ */
+type Loose<T extends object> = Record<string, any> & Partial<T>;
+/**
+ * A Loose version of the Config interface. This is intended to let us load a partial config
+ * and have type information carry though as we construct an object which is a valid `Config`.
+ */
+type UnvalidatedConfig = Loose<Config>;
+/**
+ * Helper type to strip optional markers from keys in a type, while preserving other type information for the key.
+ * This type takes a union of keys, K, in type T to allow for the type T to be gradually updated.
+ *
+ * ```typescript
+ * type Foo { bar?: number, baz?: string }
+ * type ReqFieldFoo = RequireFields<Foo, 'bar'>; // { bar: number, baz?: string }
+ * ```
+ */
+type RequireFields<T, K extends keyof T> = T & { [P in K]-?: T[P]; };
+/**
+ * Fields in {@link Config} to make required for {@link ValidatedConfig}
+ */
+type StrictConfigFields = keyof Pick<Config, 'cacheDir' | 'devServer' | 'compat' | 'fsNamespace' | 'hydratedFlag' | 'logLevel' | 'logger' | 'minifyCss' | 'minifyJs' | 'namespace' | 'outputTargets' | 'packageJsonFilePath' | 'rolldownConfig' | 'rootDir' | 'srcDir' | 'srcIndexHtml' | 'sys' | 'transformAliasedImportPaths'>;
+/**
+ * A version of {@link Config} that makes certain fields required. This type represents a valid configuration entity.
+ * When a configuration is received by the user, it is a bag of unverified data. In order to make stricter guarantees
+ * about the data from a type-safety perspective, this type is intended to be used throughout the codebase once
+ * validations have occurred at runtime.
+ */
+type ValidatedConfig = RequireFields<Config, StrictConfigFields> & {
+  /**
+   * Whether the build is running in development mode.
+   * Set by the `--dev` CLI flag. Not user-configurable in `stencil.config.ts`.
+   */
+  devMode: boolean;
+  sourceMap: boolean;
+};
+interface ModeConfig {
+  /**
+   * The mode name, matched against `styleUrls`/`styles` object keys in `@Component()`.
+   */
+  mode: string;
+  /**
+   * When `true`, every component that defines mode-keyed `styleUrls` or `styles`
+   * must include this mode. Defaults to `false`.
+   */
+  required?: boolean;
+}
+interface HydratedFlag {
+  /**
+   * Defaults to `hydrated`.
+   */
+  name?: string;
+  /**
+   * Can be either `class` or `attribute`. Defaults to `class`.
+   */
+  selector?: 'class' | 'attribute';
+  /**
+   * The CSS property used to show and hide components. Defaults to use the CSS `visibility`
+   * property. Other commonly used CSS properties would be `display` with the `initialValue`
+   * setting as `none`, or `opacity` with the `initialValue` as `0`. Defaults to `visibility`
+   * and the default `initialValue` is `hidden`.
+   */
+  property?: string;
+  /**
+   * This is the CSS value to give all components before it has been hydrated.
+   * Defaults to `hidden`.
+   */
+  initialValue?: string;
+  /**
+   * This is the CSS value to assign once a component has finished hydrating.
+   * This is the CSS value that'll allow the component to show. Defaults to `inherit`.
+   */
+  hydratedValue?: string;
+}
+interface StencilDevServerConfig {
+  /**
+   * IP address used by the dev server. The default is `0.0.0.0`, which points to all IPv4 addresses
+   * on the local machine, such as `localhost`.
+   */
+  address?: string;
+  /**
+   * Base path to be used by the server. Defaults to the root pathname.
+   */
+  basePath?: string;
+  /**
+   * EXPERIMENTAL!
+   * During development, node modules can be independently requested and bundled, making for
+   * faster build times. This is only available using the Stencil Dev Server throughout
+   * development. Production builds will override this setting to `false`. Default is `false`.
+   */
+  experimentalDevModules?: boolean;
+  /**
+   * If the dev server should respond with gzip compressed content. Defaults to `true`.
+   */
+  gzip?: boolean;
+  /**
+   * When set, the dev server will run via https using the SSL certificate and key you provide
+   * (use `fs` if you want to read them from files).
+   */
+  https?: Credentials;
+  /**
+   * The URL the dev server should first open to. Defaults to `/`.
+   */
+  initialLoadUrl?: string;
+  /**
+   * When `true`, every request to the server will be logged within the terminal.
+   * Defaults to `false`.
+   */
+  logRequests?: boolean;
+  /**
+   * When set to `true`, the local dev URL is opened in your default browser when the dev server starts.
+   * Defaults to `false`.
+   */
+  openBrowser?: boolean;
+  /**
+   * Sets the server's port. Defaults to `3333`.
+   */
+  port?: number;
+  /**
+   * When set to `true`, the dev server will exit with an error if the specified port is already in use.
+   * When set to `false`, the dev server will automatically try the next available port.
+   * Defaults to `false`.
+   */
+  strictPort?: boolean;
+  /**
+   * When files are watched and updated, by default the dev server will use `hmr` (Hot Module Replacement)
+   * to update the page without a full page refresh. To have the page do a full refresh use `pageReload`.
+   * To disable any reloading, use `null`. Defaults to `hmr`.
+   */
+  reloadStrategy?: PageReloadStrategy;
+  /**
+   * Local path to a NodeJs file with a dev server request listener as the default export.
+   * The user's request listener is given the first chance to handle every request the dev server
+   * receives, and can choose to handle it or instead pass it on to the default dev server
+   * by calling `next()`.
+   *
+   * Below is an example of a NodeJs file the `requestListenerPath` config is using.
+   * The request and response arguments are the same as Node's `http` module and `RequestListener`
+   * callback. https://nodejs.org/api/http.html#http_http_createserver_options_requestlistener
+   *
+   * ```js
+   * module.exports = function (req, res, next) {
+   *    if (req.url === '/ping') {
+   *      // custom response overriding the dev server
+   *      res.setHeader('Content-Type', 'text/plain');
+   *      res.writeHead(200);
+   *      res.end('pong');
+   *    } else {
+   *      // pass request on to the default dev server
+   *      next();
+   *    }
+   * };
+   * ```
+   */
+  requestListenerPath?: string;
+  /**
+   * The root directory to serve the files from.
+   */
+  root?: string;
+  /**
+   * If the dev server should Server-Side Render (SSR) each page, meaning it'll dynamically generate
+   * server-side rendered html on each page load. The `--ssr` flag will most commonly be used with
+   * the`--dev --watch --serve` flags during development. Note that this is for development purposes
+   * only, and the built-in dev server should not be used for production. Defaults to `false`.
+   */
+  ssr?: boolean;
+  /**
+   * If the dev server fails to start up within the given timeout (in milliseconds), the startup will
+   * be canceled. Set to zero to disable the timeout. Defaults to `15000`.
+   */
+  startupTimeout?: number;
+  /**
+   * Whether to use the dev server's websocket client or not. Defaults to `true`.
+   */
+  websocket?: boolean;
+  /**
+   * If the dev server should fork a worker for the server process or not. A singled-threaded dev server
+   * is slower, however it is useful for debugging http requests and responses. Defaults to `true`.
+   */
+  worker?: boolean;
+}
+interface DevServerConfig extends StencilDevServerConfig {
+  browserUrl?: string;
+  devServerDir?: string;
+  /**
+   * A list of glob patterns like `subdir/*.js`  to exclude from hot-module
+   * reloading updates.
+   */
+  excludeHmr?: string[];
+  historyApiFallback?: HistoryApiFallback;
+  openBrowser?: boolean;
+  prerenderConfig?: string;
+  protocol?: 'http' | 'https';
+  srcIndexHtml?: string;
+  /**
+   * Route to be used for the "ping" sub-route of the Stencil dev server.
+   * This route will return a 200 status code once the Stencil build has finished.
+   * Setting this to `null` will disable the ping route.
+   *
+   * Defaults to `/ping`
+   */
+  pingRoute?: string | null;
+}
+interface HistoryApiFallback {
+  index?: string;
+  disableDotRule?: boolean;
+}
+type PageReloadStrategy = 'hmr' | 'pageReload' | null;
+/**
+ * Common system used by the compiler. All file reads, writes, access, etc. will all use
+ * this system. Additionally, throughout each build, the compiler will use an internal
+ * in-memory file system as to prevent unnecessary fs reads and writes. At the end of each
+ * build all actions the in-memory fs performed will be written to disk using this system.
+ * A NodeJS based system will use APIs such as `fs` and `crypto`, and a web-based system
+ * will use in-memory Maps and browser APIs. Either way, the compiler itself is unaware
+ * of the actual platform it's being ran on top of.
+ */
+interface CompilerSystem {
+  name: 'node' | 'in-memory';
+  version: string;
+  events?: BuildEvents;
+  details?: SystemDetails;
+  /**
+   * Add a callback which will be ran when destroy() is called.
+   */
+  addDestroy(cb: () => void): void;
+  /**
+   * Always returns a boolean, does not throw.
+   */
+  access(p: string): Promise<boolean>;
+  /**
+   * SYNC! Always returns a boolean, does not throw.
+   */
+  accessSync(p: string): boolean;
+  applyGlobalPatch?(fromDir: string): Promise<void>;
+  applyPrerenderGlobalPatch?(opts: {
+    devServerHostUrl: string;
+    window: any;
+  }): void;
+  cacheStorage?: CacheStorage;
+  checkVersion?: (logger: Logger, currentVersion: string) => Promise<() => void>;
+  copy?(copyTasks: Required<CopyTask>[], srcDir: string): Promise<CopyResults>;
+  /**
+   * Always returns a boolean if the files were copied or not. Does not throw.
+   */
+  copyFile(src: string, dst: string): Promise<boolean>;
+  /**
+   * Used to destroy any listeners, file watchers or child processes.
+   */
+  destroy(): Promise<void>;
+  /**
+   * Does not throw.
+   */
+  createDir(p: string, opts?: CompilerSystemCreateDirectoryOptions): Promise<CompilerSystemCreateDirectoryResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  createDirSync(p: string, opts?: CompilerSystemCreateDirectoryOptions): CompilerSystemCreateDirectoryResults;
+  homeDir(): string;
+  /**
+   * Used to determine if the current context of the terminal is TTY.
+   */
+  isTTY(): boolean;
+  /**
+   * Each platform has a different way to dynamically import modules.
+   */
+  dynamicImport?(p: string): Promise<any>;
+  /**
+   * Creates the worker controller for the current system.
+   *
+   * @param maxConcurrentWorkers the max number of concurrent workers to
+   * support
+   * @returns a worker controller appropriate for the current platform (node.js)
+   */
+  createWorkerController?(maxConcurrentWorkers: number): WorkerMainController;
+  encodeToBase64(str: string): string;
+  /**
+   * process.exit()
+   */
+  exit(exitCode: number): Promise<void>;
+  /**
+   * Optionally provide a fetch() function rather than using the built-in fetch().
+   * First arg is a url string or Request object (RequestInfo).
+   * Second arg is the RequestInit. Returns the Response object
+   */
+  fetch?(input: string | any, init?: any): Promise<any>;
+  /**
+   * Generates a sha1 digest encoded as HEX
+   */
+  generateContentHash?(content: string | any, length?: number): Promise<string>;
+  /**
+   * Generates a sha1 digest encoded as HEX from a file path
+   */
+  generateFileHash?(filePath: string | any, length?: number): Promise<string>;
+  /**
+   * Get the current directory.
+   */
+  getCurrentDirectory(): string;
+  /**
+   * The compiler's executing path.
+   */
+  getCompilerExecutingPath(): string;
+  getEnvironmentVar?(key: string): string;
+  /**
+   * Gets the absolute file path when for a dependency module.
+   */
+  getLocalModulePath(opts: {
+    rootDir: string;
+    moduleId: string;
+    path: string;
+  }): string;
+  /**
+   * Gets the full url when requesting a dependency module to fetch from a CDN.
+   */
+  getRemoteModuleUrl(opts: {
+    moduleId: string;
+    path?: string;
+    version?: string;
+  }): string;
+  /**
+   * Async glob task. Only available in NodeJS compiler system.
+   */
+  glob?(pattern: string, options: {
+    cwd?: string;
+    nodir?: boolean;
+    [key: string]: any;
+  }): Promise<string[]>;
+  /**
+   * The number of logical processors available to run threads on the user's computer (cpus).
+   */
+  hardwareConcurrency: number;
+  /**
+   * Tests if the path is a symbolic link or not. Always resolves a boolean. Does not throw.
+   */
+  isSymbolicLink(p: string): Promise<boolean>;
+  lazyRequire?: LazyRequire;
+  nextTick(cb: () => void): void;
+  /**
+   * Normalize file system path.
+   */
+  normalizePath(p: string): string;
+  onProcessInterrupt?(cb: () => void): void;
+  parseYarnLockFile?: (content: string) => {
+    type: 'success' | 'merge' | 'conflict';
+    object: any;
+  };
+  platformPath: PlatformPath;
+  /**
+   * All return paths are full normalized paths, not just the basenames. Always returns an array, does not throw.
+   */
+  readDir(p: string): Promise<string[]>;
+  /**
+   * SYNC! All return paths are full normalized paths, not just the basenames. Always returns an array, does not throw.
+   */
+  readDirSync(p: string): string[];
+  /**
+   * Returns undefined if file is not found. Does not throw.
+   */
+  readFile(p: string): Promise<string>;
+  readFile(p: string, encoding: 'utf8'): Promise<string>;
+  readFile(p: string, encoding: 'binary'): Promise<any>;
+  /**
+   * SYNC! Returns undefined if file is not found. Does not throw.
+   */
+  readFileSync(p: string, encoding?: string): string;
+  /**
+   * Does not throw.
+   */
+  realpath(p: string): Promise<CompilerSystemRealpathResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  realpathSync(p: string): CompilerSystemRealpathResults;
+  /**
+   * Remove a callback which will be ran when destroy() is called.
+   */
+  removeDestroy(cb: () => void): void;
+  /**
+   * Rename old path to new path. Does not throw.
+   */
+  rename(oldPath: string, newPath: string): Promise<CompilerSystemRenameResults>;
+  resolveModuleId?(opts: ResolveModuleIdOptions): Promise<ResolveModuleIdResults>;
+  resolvePath(p: string): string;
+  /**
+   * Does not throw.
+   */
+  removeDir(p: string, opts?: CompilerSystemRemoveDirectoryOptions): Promise<CompilerSystemRemoveDirectoryResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  removeDirSync(p: string, opts?: CompilerSystemRemoveDirectoryOptions): CompilerSystemRemoveDirectoryResults;
+  /**
+   * Does not throw.
+   */
+  removeFile(p: string): Promise<CompilerSystemRemoveFileResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  removeFileSync(p: string): CompilerSystemRemoveFileResults;
+  setupCompiler?: (c: {
+    ts: any;
+  }) => void;
+  /**
+   * Always returns an object. Does not throw. Check for "error" property if there's an error.
+   */
+  stat(p: string): Promise<CompilerFsStats>;
+  /**
+   * SYNC! Always returns an object. Does not throw. Check for "error" property if there's an error.
+   */
+  statSync(p: string): CompilerFsStats;
+  tmpDirSync(): string;
+  watchDirectory?(p: string, callback: CompilerFileWatcherCallback, recursive?: boolean): CompilerFileWatcher;
+  /**
+   * A `watchFile` implementation in order to hook into the rest of the {@link CompilerSystem} implementation that is
+   * used when running Stencil's compiler in "watch mode".
+   *
+   * It is analogous to TypeScript's `watchFile`  implementation.
+   *
+   * Note, this function may be called for full builds of Stencil projects by the TypeScript compiler. It should not
+   * assume that it will only be called in watch mode.
+   *
+   * This function should not perform any file watcher registration itself. Each `path` provided to it when called
+   * should already have been registered as a file to watch.
+   *
+   * @param path the path to the file that is being watched
+   * @param callback a callback to invoke when a file that is being watched has changed in some way
+   * @returns an object with a method for unhooking the file watcher from the system
+   */
+  watchFile?(path: string, callback: CompilerFileWatcherCallback): CompilerFileWatcher;
+  /**
+   * How many milliseconds to wait after a change before calling watch callbacks.
+   */
+  watchTimeout?: number;
+  /**
+   * Does not throw.
+   */
+  writeFile(p: string, content: string): Promise<CompilerSystemWriteFileResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  writeFileSync(p: string, content: string): CompilerSystemWriteFileResults;
+}
+interface ParsedPath {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+}
+interface PlatformPath {
+  normalize(p: string): string;
+  join(...paths: string[]): string;
+  resolve(...pathSegments: string[]): string;
+  isAbsolute(p: string): boolean;
+  relative(from: string, to: string): string;
+  dirname(p: string): string;
+  basename(p: string, ext?: string): string;
+  extname(p: string): string;
+  parse(p: string): ParsedPath;
+  sep: string;
+  delimiter: string;
+  posix: any;
+  win32: any;
+}
+interface ResolveModuleIdOptions {
+  moduleId: string;
+  containingFile?: string;
+  exts?: string[];
+  packageFilter?: (pkg: any, pkgFile: string) => any;
+}
+interface ResolveModuleIdResults {
+  moduleId: string;
+  resolveId: string;
+  pkgData: {
+    name: string;
+    version: string;
+    [key: string]: any;
+  };
+  pkgDirPath: string;
+}
+/**
+ * A controller which provides for communication and coordination between
+ * threaded workers.
+ */
+interface WorkerMainController<T extends Record<string, (...args: any[]) => Promise<any>> = Record<string, (...args: any[]) => Promise<any>>> {
+  /**
+   * Send a given set of arguments to a worker
+   */
+  send<K extends keyof T>(methodName: K, ...args: Parameters<T[K]>): ReturnType<T[K]>;
+  /**
+   * Handle a particular method
+   *
+   * @param name of the method to be passed to a worker
+   * @returns a Promise wrapping the results
+   */
+  handler<K extends keyof T>(name: K): T[K];
+  /**
+   * Destroy the worker represented by this instance, rejecting all outstanding
+   * tasks and killing the child process.
+   */
+  destroy(): void;
+  /**
+   * The current setting for the max number of workers
+   */
+  maxWorkers: number;
+}
+interface CopyResults {
+  diagnostics: Diagnostic[];
+  filePaths: string[];
+  dirPaths: string[];
+}
+interface SystemDetails {
+  cpuModel: string;
+  freemem(): number;
+  platform: 'darwin' | 'windows' | 'linux' | '';
+  release: string;
+  totalmem: number;
+}
+interface BuildOnEvents {
+  on(cb: (eventName: CompilerEventName, data: any) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileAdd, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileDelete, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileUpdate, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventDirAdd, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventDirDelete, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildStart, cb: (buildStart: CompilerBuildStart) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildFinish, cb: (buildResults: CompilerBuildResults) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildLog, cb: (buildLog: BuildLog) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildNoChange, cb: () => void): BuildOnEventRemove;
+}
+interface BuildEmitEvents {
+  emit(eventName: CompilerEventName, path: string): void;
+  emit(eventName: CompilerEventFileAdd, path: string): void;
+  emit(eventName: CompilerEventFileDelete, path: string): void;
+  emit(eventName: CompilerEventFileUpdate, path: string): void;
+  emit(eventName: CompilerEventDirAdd, path: string): void;
+  emit(eventName: CompilerEventDirDelete, path: string): void;
+  emit(eventName: CompilerEventBuildStart, buildStart: CompilerBuildStart): void;
+  emit(eventName: CompilerEventBuildFinish, buildResults: CompilerBuildResults): void;
+  emit(eventName: CompilerEventBuildNoChange, buildNoChange: BuildNoChangeResults): void;
+  emit(eventName: CompilerEventBuildLog, buildLog: BuildLog): void;
+  emit(eventName: CompilerEventFsChange, fsWatchResults: FsWatchResults): void;
+}
+interface FsWatchResults {
+  dirsAdded: string[];
+  dirsDeleted: string[];
+  filesUpdated: string[];
+  filesAdded: string[];
+  filesDeleted: string[];
+}
+interface BuildLog {
+  buildId: number;
+  messages: string[];
+  progress: number;
+}
+interface BuildNoChangeResults {
+  buildId: number;
+  noChange: boolean;
+}
+interface CompilerBuildResults {
+  buildId: number;
+  componentGraph?: BuildResultsComponentGraph;
+  components: ComponentCompilerMeta[];
+  diagnostics: Diagnostic[];
+  dirsAdded: string[];
+  dirsDeleted: string[];
+  duration: number;
+  filesAdded: string[];
+  filesChanged: string[];
+  filesDeleted: string[];
+  filesUpdated: string[];
+  hasError: boolean;
+  hasSuccessfulBuild: boolean;
+  hmr?: HotModuleReplacement;
+  ssrAppFilePath?: string;
+  isRebuild: boolean;
+  namespace: string;
+  fsNamespace: string;
+  outputs: BuildOutput[];
+  rootDir: string;
+  srcDir: string;
+  timestamp: string;
+}
+interface BuildResultsComponentGraph {
+  [scopeId: string]: string[];
+}
+interface BuildOutput {
+  type: string;
+  files: string[];
+}
+interface HotModuleReplacement {
+  componentsUpdated?: string[];
+  excludeHmr?: string[];
+  externalStylesUpdated?: string[];
+  imagesUpdated?: string[];
+  indexHtmlUpdated?: boolean;
+  inlineStylesUpdated?: HmrStyleUpdate[];
+  reloadStrategy: PageReloadStrategy;
+  scriptsAdded?: string[];
+  scriptsDeleted?: string[];
+  serviceWorkerUpdated?: boolean;
+  versionId?: string;
+}
+interface HmrStyleUpdate {
+  styleId: string;
+  styleTag: string;
+  styleText: string;
+}
+type BuildOnEventRemove = () => boolean;
+interface BuildEvents extends BuildOnEvents, BuildEmitEvents {
+  unsubscribeAll(): void;
+}
+interface CompilerBuildStart {
+  buildId: number;
+  timestamp: string;
+}
+/**
+ * A type describing a function to call when an event is emitted by a file watcher
+ * @param fileName the path of the file tied to event
+ * @param eventKind a variant describing the type of event that was emitter (added, edited, etc.)
+ */
+type CompilerFileWatcherCallback = (fileName: string, eventKind: CompilerFileWatcherEvent) => void;
+/**
+ * A type describing the different types of events that Stencil expects may happen when a file being watched is altered
+ * in some way
+ */
+type CompilerFileWatcherEvent = CompilerEventFileAdd | CompilerEventFileDelete | CompilerEventFileUpdate | CompilerEventDirAdd | CompilerEventDirDelete;
+type CompilerEventName = CompilerEventFsChange | CompilerEventFileUpdate | CompilerEventFileAdd | CompilerEventFileDelete | CompilerEventDirAdd | CompilerEventDirDelete | CompilerEventBuildStart | CompilerEventBuildFinish | CompilerEventBuildNoChange | CompilerEventBuildLog;
+type CompilerEventFsChange = 'fsChange';
+type CompilerEventFileUpdate = 'fileUpdate';
+type CompilerEventFileAdd = 'fileAdd';
+type CompilerEventFileDelete = 'fileDelete';
+type CompilerEventDirAdd = 'dirAdd';
+type CompilerEventDirDelete = 'dirDelete';
+type CompilerEventBuildStart = 'buildStart';
+type CompilerEventBuildFinish = 'buildFinish';
+type CompilerEventBuildLog = 'buildLog';
+type CompilerEventBuildNoChange = 'buildNoChange';
+interface CompilerFileWatcher {
+  close(): void | Promise<void>;
+}
+interface CompilerFsStats {
+  /**
+   * If it's a directory. `false` if there was an error.
+   */
+  isDirectory: boolean;
+  /**
+   * If it's a file. `false` if there was an error.
+   */
+  isFile: boolean;
+  /**
+   * If it's a symlink. `false` if there was an error.
+   */
+  isSymbolicLink: boolean;
+  /**
+   * The size of the file in bytes. `0` for directories or if there was an error.
+   */
+  size: number;
+  /**
+   * The timestamp indicating the last time this file was modified expressed in milliseconds since the POSIX Epoch.
+   */
+  mtimeMs?: number;
+  /**
+   * Error if there was one, otherwise `null`. `stat` and `statSync` do not throw errors but always returns this interface.
+   */
+  error: any;
+}
+interface CompilerSystemCreateDirectoryOptions {
+  /**
+   * Indicates whether parent directories should be created.
+   * @default false
+   */
+  recursive?: boolean;
+  /**
+   * A file mode. If a string is passed, it is parsed as an octal integer. If not specified
+   * @default 0o777.
+   */
+  mode?: number;
+}
+interface CompilerSystemCreateDirectoryResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  newDirs: string[];
+  error: any;
+}
+interface CompilerSystemRemoveDirectoryOptions {
+  /**
+   * Indicates whether child files and subdirectories should be removed.
+   * @default false
+   */
+  recursive?: boolean;
+}
+interface CompilerSystemRemoveDirectoryResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  removedDirs: string[];
+  removedFiles: string[];
+  error: any;
+}
+interface CompilerSystemRenameResults extends CompilerSystemRenamedPath {
+  renamed: CompilerSystemRenamedPath[];
+  oldDirs: string[];
+  oldFiles: string[];
+  newDirs: string[];
+  newFiles: string[];
+  error: any;
+}
+interface CompilerSystemRenamedPath {
+  oldPath: string;
+  newPath: string;
+  isFile: boolean;
+  isDirectory: boolean;
+}
+interface CompilerSystemRealpathResults {
+  path: string;
+  error: any;
+}
+interface CompilerSystemRemoveFileResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  error: any;
+}
+interface CompilerSystemWriteFileResults {
+  path: string;
+  error: any;
+}
+interface Credentials {
+  key: string;
+  cert: string;
+}
+interface ConfigBundle {
+  components: string[];
+}
+/**
+ * A file and/or directory copy operation that may be specified as part of
+ * certain output targets for Stencil (in particular `loader-bundle`,
+ * `standalone`, and `www`).
+ */
+interface CopyTask {
+  /**
+   * The source file path for a copy operation. This may be an absolute or
+   * relative path to a directory or a file, and may also include a glob
+   * pattern.
+   *
+   * If the path is a relative path it will be treated as relative to
+   * `Config.srcDir`.
+   */
+  src: string;
+  /**
+   * An optional destination file path for a copy operation. This may be an
+   * absolute or relative path.
+   *
+   * If relative, this will be treated as relative to the output directory for
+   * the output target for which this copy operation is configured.
+   */
+  dest?: string;
+  /**
+   * Additional glob patterns to exclude from the copy operation, merged with
+   * the built-in defaults: `__mocks__`, `__fixtures__`, `dist`, hidden dirs,
+   * `.ds_store`, `.gitignore`, `desktop.ini`, `thumbs.db`.
+   */
+  ignore?: string[];
+  /**
+   * Whether or not Stencil should issue warnings if it cannot find the
+   * specified source files or directories. Defaults to `false`.
+   *
+   * To receive warnings if a copy task source can't be found set this to
+   * `true`.
+   */
+  warn?: boolean;
+  /**
+   * Whether or not directory structure should be preserved when copying files
+   * from a source directory. Defaults to `true` if no `dest` path is supplied,
+   * else it defaults to `false`.
+   *
+   * If this is set to `false`, all the files from a source directory will be
+   * copied directly to the destination directory, but if it's set to `true` they
+   * will be copied to a new directory inside the destination directory with
+   * the same name as their original source directory.
+   *
+   * So if, for instance, `src` is set to `"images"` and `keepDirStructure` is
+   * set to `true` the copy task will then produce the following directory
+   * structure:
+   *
+   * ```
+   * images
+   * └── foo.png
+   * dist
+   * └── images
+   *     └── foo.png
+   * ```
+   *
+   * Conversely if `keepDirStructure` is set to `false` then files in `images/`
+   * will be copied to `dist` without first creating a new subdirectory,
+   * resulting in the following directory structure:
+   *
+   * ```
+   * images
+   * └── foo.png
+   * dist
+   * └── foo.png
+   * ```
+   *
+   * If a `dest` path is supplied then `keepDirStructure`
+   * will default to `false`, so that Stencil will write the
+   * copied files directly into the `dest` directory without creating a new
+   * subdirectory. This behavior can be overridden by setting
+   * `keepDirStructure` to `true`.
+   */
+  keepDirStructure?: boolean;
+}
+/**
+ * Configuration for generating documentation from Stencil components.
+ */
+interface StencilDocsConfig {
+  /**
+   * Options for processing and rendering Markdown documentation files.
+   */
+  markdown?: {
+    /**
+     * Styling for how the target component will be represented within documentation (e.g., in component diagrams).
+     */
+    targetComponent?: {
+      /**
+       * Background color used for nodes representing the component in diagrams (e.g., Mermaid graphs).
+       * Use standard color names or hex codes.
+       * @example '#f0f0f0' (light gray)
+       */
+      background?: string;
+      /**
+       * Text color used within nodes representing the component in diagrams (e.g., Mermaid graphs).
+       * Use standard color names or hex codes.
+       * @example '#333' (dark gray)
+       */
+      textColor?: string;
+    };
+  };
+}
+/** Options for rolldown's built-in module resolver, passed directly to rolldown's `resolve` input option. */
+type NodeResolveConfig = NonNullable<InputOptions['resolve']>;
+interface RolldownConfig {
+  treeshake?: boolean;
+  external?: (string | RegExp)[] | string | RegExp | ((source: string, importer: string | undefined, isResolved: boolean) => boolean | null | undefined);
+}
+/**
+ * This sets the log level hierarchy for our terminal logger, ranging from
+ * most to least verbose.
+ *
+ * Ordering the levels like this lets us easily check whether we should log a
+ * message at a given time. For instance, if the log level is set to `'warn'`,
+ * then anything passed to the logger with level `'warn'` or `'error'` should
+ * be logged, but we should _not_ log anything with level `'info'` or `'debug'`.
+ *
+ * If we have a current log level `currentLevel` and a message with level
+ * `msgLevel` is passed to the logger, we can determine whether or not we should
+ * log it by checking if the log level on the message is further up or at the
+ * same level in the hierarchy than `currentLevel`, like so:
+ *
+ * ```ts
+ * LOG_LEVELS.indexOf(msgLevel) >= LOG_LEVELS.indexOf(currentLevel)
+ * ```
+ *
+ * NOTE: for the reasons described above, do not change the order of the entries
+ * in this array without good reason!
+ */
+declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+/**
+ * Abstract interface representing a logger with the capability to accept log
+ * messages at various levels (debug, info, warn, and error), set colors, log
+ * time spans, print diagnostic messages, and more.
+ *
+ * A Node.js-specific implementation of this interface is used when Stencil is
+ * building and compiling a project.
+ */
+interface Logger {
+  enableColors: (useColors: boolean) => void;
+  setLevel: (level: LogLevel) => void;
+  getLevel: () => LogLevel;
+  debug: (...msg: any[]) => void;
+  info: (...msg: any[]) => void;
+  warn: (...msg: any[]) => void;
+  error: (...msg: any[]) => void;
+  createTimeSpan: (startMsg: string, debug?: boolean, appendTo?: string[]) => LoggerTimeSpan;
+  printDiagnostics: (diagnostics: Diagnostic[], cwd?: string) => void;
+  red: (msg: string) => string;
+  green: (msg: string) => string;
+  yellow: (msg: string) => string;
+  blue: (msg: string) => string;
+  magenta: (msg: string) => string;
+  cyan: (msg: string) => string;
+  gray: (msg: string) => string;
+  bold: (msg: string) => string;
+  dim: (msg: string) => string;
+  bgRed: (msg: string) => string;
+  emoji: (e: string) => string;
+  setLogFilePath?: (p: string) => void;
+  writeLogs?: (append: boolean) => void;
+  createLineUpdater?: () => Promise<LoggerLineUpdater>;
+}
+interface LoggerLineUpdater {
+  update(text: string): Promise<void>;
+  stop(): Promise<void>;
+}
+interface LoggerTimeSpan {
+  duration(): number;
+  finish(finishedMsg: string, color?: string, bold?: boolean, newLineSuffix?: boolean): number;
+}
+/**
+ * Output target for generating lazy-loaded component bundles with a loader infrastructure.
+ * This creates an optimized distribution for CDN usage and applications that benefit from
+ * lazy-loading components on demand.
+ *
+ * Formerly known as 'dist' in v4.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'loader-bundle',
+ *   dir: 'dist/loader-bundle'
+ * }
+ * ```
+ */
+interface OutputTargetLoaderBundle extends OutputTargetBaseNext {
+  type: 'loader-bundle';
+  /**
+   * Directory where lazy-loaded bundles will be written.
+   * @default '' (root of output directory)
+   */
+  buildDir?: string;
+  copy?: CopyTask[];
+  empty?: boolean;
+  /**
+   * Whether to generate CommonJS (CJS) bundles.
+   *
+   * When `true`, generates CJS output in `cjs/` subdirectory.
+   * When `false` (default in v5+), only ESM bundles are generated.
+   *
+   * @default false
+   */
+  cjs?: boolean;
+  /**
+   * Custom path for the loader directory; files you can import
+   * in an initiation script within your application to register all your components for
+   * lazy loading.
+   *
+   * @default 'loader' (relative to output directory)
+   */
+  loaderPath?: string;
+  /**
+   * Hash the filenames of generated chunks based on their content.
+   * Enables forever-caching of CDN-served bundles.
+   *
+   * @default true in production, false in dev mode
+   */
+  hashFileNames?: boolean;
+  /**
+   * Number of characters to use for the content hash in filenames.
+   *
+   * @default 8
+   */
+  hashedFileNameLength?: number;
+  /**
+   * When `true`, marks `@stencil/core` as an external dependency in the bundler (ESM/CJS)
+   * distribution output. Consumers must provide `@stencil/core` themselves.
+   *
+   * Has no effect on the browser/CDN build - the runtime is always bundled there.
+   *
+   * @default false
+   */
+  externalRuntime?: boolean;
+}
+/**
+ * Output target for generating Stencil component source for downstream re-bundling.
+ * This output contains transpiled source code, component metadata, and configuration
+ * that downstream Stencil projects can re-compile and bundle.
+ *
+ * Formerly 'dist-collection' sub-output in v4, now a first-class output target in v5.
+ *
+ * In production builds, this output is auto-generated unless explicitly configured.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'collection',
+ *   dir: 'dist/collection',
+ *   transformAliasedImportPaths: true
+ * }
+ * ```
+ */
+interface OutputTargetCollection extends OutputTargetBaseNext {
+  type: 'collection';
+  empty?: boolean;
+  /**
+   * When `true` this flag will transform aliased import paths defined in
+   * a project's `tsconfig.json` to relative import paths in the compiled output.
+   *
+   * Paths will be left in aliased format if `false` or `undefined`.
+   *
+   * @example
+   * // tsconfig.json
+   * {
+   *   paths: {
+   *     "@utils/*": ['/src/utils/*']
+   *   }
+   * }
+   *
+   * // Source file
+   * import * as dateUtils from '@utils/date-utils';
+   * // Output file
+   * import * as dateUtils from '../utils/date-utils';
+   */
+  transformAliasedImportPaths?: boolean | null;
+}
+/**
+ * Output target for generating TypeScript type definitions (.d.ts files).
+ *
+ * Formerly a sub-output of 'dist' and 'dist-custom-elements' in v4,
+ * now a first-class output target in v5 that can be shared across multiple outputs.
+ *
+ * In production builds, this output is auto-generated unless explicitly configured.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'types',
+ *   dir: 'dist/types'
+ * }
+ * ```
+ */
+interface OutputTargetTypes extends OutputTargetBaseNext {
+  type: 'types';
+  empty?: boolean;
+}
+interface OutputTargetDistLazy extends OutputTargetBase {
+  type: 'dist-lazy';
+  dir?: string;
+  esmDir?: string;
+  cjsDir?: string;
+  isBrowserBuild?: boolean;
+  esmIndexFile?: string;
+  cjsIndexFile?: string;
+  loaderDir?: string;
+  typesDir?: string;
+  empty?: boolean;
+  /** Inherited from parent output target (loader-bundle or www). Only meaningful for browser builds. */
+  hashFileNames?: boolean;
+  /** Inherited from parent output target (loader-bundle or www). */
+  hashedFileNameLength?: number;
+  /** Inherited from loader-bundle. When true, @stencil/core is external in this bundler output. */
+  externalRuntime?: boolean;
+}
+/**
+ * Output target for global styles.
+ * Generates a CSS file from an input stylesheet.
+ *
+ * Can be configured in two ways:
+ * 1. **Implicit** (backwards compat): Set `globalStyle` in the config and this output is auto-generated
+ * 2. **Explicit**: Define this output target with an `input` property
+ *
+ * Multiple `global-style` outputs are supported for building separate CSS bundles.
+ *
+ * @example
+ * ```typescript
+ * // Explicit configuration with custom input/output
+ * {
+ *   type: 'global-style',
+ *   input: './src/theme.css',
+ *   fileName: 'theme.css',
+ *   dir: 'dist/assets',
+ *   copyToLoaderBrowser: false
+ * }
+ * ```
+ */
+interface OutputTargetGlobalStyle extends OutputTargetBaseNext {
+  type: 'global-style';
+  /**
+   * Path to the input CSS file to compile.
+   * When specified, this takes precedence over the `globalStyle` config option.
+   *
+   * If neither `input` nor `globalStyle` config is set, no CSS will be built.
+   */
+  input?: string;
+  /**
+   * Output filename for the compiled CSS.
+   * @default '{namespace}.css' when using globalStyle config, or basename of input file
+   */
+  fileName?: string;
+  /**
+   * When `true`, also copies the global style CSS to the loader-bundle browser directory
+   * for backwards compatibility with existing CDN consumers who have hardcoded CSS paths.
+   *
+   * @default true
+   */
+  copyToLoaderBrowser?: boolean;
+  /**
+   * Controls whether this global stylesheet is injected into component shadow DOMs
+   * as a constructable stylesheet at runtime.
+   *
+   * - `'none'` (default): Don't inject - stylesheet must be loaded externally (e.g., via `<link>`)
+   * - `'client'`: Inject only in client builds, not SSR (reduces SSR output size)
+   * - `'all'`: Inject in both client and SSR builds
+   *
+   * @default 'none'
+   */
+  inject?: 'none' | 'client' | 'all';
+}
+/**
+ * Output target for component assets.
+ * Copies all component `assetsDirs` to a unified location.
+ *
+ * auto-generated when components have `assetsDirs` unless explicitly configured.
+ * The output is placed in `dist/assets/` by default and is available to all distribution strategies.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'assets',
+ *   dir: 'dist/assets'
+ * }
+ * ```
+ */
+interface OutputTargetAssets extends OutputTargetBaseNext {
+  type: 'assets';
+}
+/**
+ * Output target for server-side rendering (SSR) and hydration.
+ * Generates a script that can be used for SSR and static site generation (prerendering).
+ *
+ * Formerly known as 'dist-hydrate-script' in v4.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'ssr',
+ *   dir: 'dist/ssr',
+ *   minify: true
+ * }
+ * ```
+ */
+interface OutputTargetSsr extends OutputTargetBase {
+  type: 'ssr';
+  dir?: string;
+  /**
+   * Module IDs that should not be bundled into the script.
+   * By default, all node builtin's, such as `fs` or `path`
+   * will be considered "external" and not bundled.
+   */
+  external?: string[];
+  empty?: boolean;
+  minify?: boolean;
+  /**
+   * Whether to generate CommonJS (CJS) bundles.
+   *
+   * When `true`, generates CJS output as `index.cjs` alongside ESM `index.js`.
+   * When `false` (default in v5+), only ESM bundles are generated.
+   *
+   * @default false
+   */
+  cjs?: boolean;
+}
+interface OutputTargetSsrWasm extends OutputTargetBase {
+  type: 'ssr-wasm';
+  /** Output directory. @default 'dist/ssr-wasm' */
+  dir?: string;
+  empty?: boolean;
+  minify?: boolean;
+}
+interface OutputTargetCustom extends OutputTargetBase {
+  type: 'custom';
+  name: string;
+  /**
+   * Indicate when the output target should be executed.
+   *
+   * - `"onBuildOnly"`: Executed only when `stencil build` is called without `--watch`.
+   * - `"always"`: Executed on every build, including in `watch` mode.
+   *
+   * Defaults to "always".
+   */
+  taskShouldRun?: 'onBuildOnly' | 'always';
+  validate?: (config: Config, diagnostics: Diagnostic[]) => void;
+  generator: (config: Config, compilerCtx: CompilerCtx, buildCtx: BuildCtx, docs: JsonDocs) => Promise<void>;
+  copy?: CopyTask[];
+}
+/**
+ * Output target for generating [custom data](https://github.com/microsoft/vscode-custom-data) for VS Code as a JSON
+ * file.
+ */
+interface OutputTargetDocsVscode extends OutputTargetBase {
+  /**
+   * Designates this output target to be used for generating VS Code custom data.
+   * @see OutputTargetBase#type
+   */
+  type: 'docs-vscode';
+  /**
+   * The location on disk to write the JSON file.
+   */
+  file: string;
+  /**
+   * A base URL to find the source code of the component(s) described in the JSON file.
+   */
+  sourceCodeBaseUrl?: string;
+}
+interface OutputTargetDocsReadme extends OutputTargetBase {
+  type: 'docs-readme';
+  /**
+   * The root directory where README files should be written
+   *
+   * defaults to {@link Config.srcDir}
+   */
+  dir?: string;
+  dependencies?: boolean;
+  /**
+   * Controls how READMEs are written to the destination directory.
+   *
+   * - `true`: Always overwrite the destination README with the full content.
+   * - `false` (default): Only update the autogenerated content, preserving existing custom content above it.
+   * - `'if-missing'`: Write the full README only if no file exists at the destination.
+   *
+   * This option enables workflows requiring consistent, idempotent output across builds,
+   * and supports setups where custom documentation may need to coexist or vary between environments.
+   */
+  overwriteExisting?: boolean | 'if-missing';
+  footer?: string;
+  strict?: boolean;
+  /**
+   * Add extra columns to the generated Properties/Events tables, e.g. to
+   * surface custom JSDoc tags as a column of their own.
+   */
+  customColumns?: {
+    props?: DocsReadmeCustomColumn<JsonDocsProp>[];
+    events?: DocsReadmeCustomColumn<JsonDocsEvent>[];
+  };
+}
+/**
+ * A custom column to render in a `docs-readme` Properties/Events table.
+ * `content` is invoked once per row.
+ */
+interface DocsReadmeCustomColumn<T> {
+  header: string;
+  content: (member: T, cmp: JsonDocsComponent) => string;
+}
+interface OutputTargetDocsJson extends OutputTargetBase {
+  type: 'docs-json';
+  file: string;
+  /**
+   * Set an optional file path where Stencil should write a `d.ts` file to disk
+   * at build-time containing type declarations for {@link JsonDocs} and related
+   * interfaces. If this is omitted or set to `null` Stencil will not write such
+   * a file.
+   */
+  typesFile?: string | null;
+  strict?: boolean;
+  /**
+   * An optional file path pointing to a public type library which should be
+   * included and documented in the same way as other types which are included
+   * in this output target.
+   *
+   * This could be useful if, for instance, there are some important interfaces
+   * used in a few places in a Stencil project which don't form part of the
+   * public API for any of the project's components. Such interfaces will not
+   * be included in the `docs-json` output by default, but if they're declared
+   * and exported from a 'supplemental' file designated with this property then
+   * they'll be included in the output, facilitating their documentation.
+   */
+  supplementalPublicTypes?: string;
+}
+interface OutputTargetDocsCustomElementsManifest extends OutputTargetBase {
+  type: 'docs-custom-elements-manifest';
+  /**
+   * The file path where the custom-elements.json manifest will be written.
+   * Defaults to 'custom-elements.json' in the root directory.
+   */
+  file: string;
+  strict?: boolean;
+}
+interface OutputTargetDocsCustom extends OutputTargetBase {
+  type: 'docs-custom';
+  generator: (docs: JsonDocs, config: Config) => void | Promise<void>;
+  strict?: boolean;
+}
+/**
+ * Output target for generating an [Agent Skill](https://agentskills.io)
+ * (`SKILL.md` + per-component reference files) describing a component
+ * library, so AI coding agents can consume its API and usage examples
+ * directly.
+ */
+interface OutputTargetDocsAgentSkill extends OutputTargetBase {
+  type: 'docs-agent-skill';
+  /**
+   * The root directory where the skill (`SKILL.md` + `components/*.md`) is written.
+   *
+   * defaults to `dist/skill`
+   */
+  dir?: string;
+  /**
+   * The skill's name, used in the `SKILL.md` frontmatter.
+   *
+   * Defaults to a kebab-cased form of {@link Config.namespace}.
+   */
+  name?: string;
+  /**
+   * The skill's description, used in the `SKILL.md` frontmatter - this is the
+   * text agents use to decide when to load the skill.
+   *
+   * Defaults to an auto-generated sentence built from the project's
+   * {@link JsonDocs.usage} (if present) or its component tags.
+   */
+  description?: string;
+}
+interface OutputTargetStats extends OutputTargetBase {
+  type: 'stats';
+  file?: string;
+}
+interface OutputTargetBaseNext extends OutputTargetBase {
+  dir?: string;
+}
+/**
+ * The collection of valid export behaviors.
+ * Used to generate a type for typed configs as well as output target validation
+ * for the `standalone` output target.
+ *
+ * Adding a value to this const array will automatically add it as a valid option on the
+ * output target configuration for `customElementsExportBehavior`.
+ *
+ * - `default`: No additional export or definition behavior will happen.
+ * - `auto-define-custom-elements`: Enables the auto-definition of a component and its children (recursively) in the custom elements registry. This
+ * functionality allows consumers to bypass the explicit call to define a component, its children, its children's
+ * children, etc. Users of this flag should be aware that enabling this functionality may increase bundle size.
+ * - `bundle`: A `defineCustomElements` function will be exported from the distribution directory.
+ * - `single-export-module`: All components will be re-exported from the specified directory's root `index.js` file.
+ */
+declare const CustomElementsExportBehaviorOptions: readonly ["default", "auto-define-custom-elements", "bundle", "single-export-module"];
+/**
+ * This type is auto-generated based on the values in `CustomElementsExportBehaviorOptions` array.
+ * This is used on the output target config for intellisense in typed configs.
+ */
+type CustomElementsExportBehavior = (typeof CustomElementsExportBehaviorOptions)[number];
+/**
+ * Output target for generating standalone component modules.
+ * Each component is output as an individual ES module that can be directly imported.
+ *
+ * This output target is ideal for npm consumption and tree-shaking, as consumers
+ * can import only the components they need.
+ *
+ * Formerly known as 'dist-custom-elements' in v4.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   type: 'standalone',
+ *   dir: 'dist/standalone',
+ *   externalRuntime: true,
+ *   autoLoader: true
+ * }
+ * ```
+ */
+interface OutputTargetStandalone extends OutputTargetBaseNext {
+  type: 'standalone';
+  empty?: boolean;
+  /**
+   * Triggers the following behaviors when enabled:
+   * 1. All `@stencil/core/*` module references are treated as external during bundling.
+   * 2. File names are not hashed.
+   * 3. File minification will follow the behavior defined at the root of the Stencil config.
+   *
+   * @default false
+   */
+  externalRuntime?: boolean;
+  copy?: CopyTask[];
+  includeGlobalScripts?: boolean;
+  minify?: boolean;
+  /**
+   * Define the export/definition behavior for the output target's generated output.
+   * This controls if/how custom elements will be defined or where components will be exported from.
+   * If omitted, no auto-definition behavior or re-exporting will happen.
+   */
+  customElementsExportBehavior?: CustomElementsExportBehavior;
+  /**
+   * Generate an auto-loader script that uses MutationObserver to lazily load
+   * and define custom elements as they appear in the DOM.
+   *
+   * @default true
+   *
+   * When set to `true`, generates a `loader.js` file that auto-starts on import.
+   * Can also be configured with an object for more control:
+   * - `fileName`: Custom filename for the loader (default: 'loader.js')
+   * - `autoStart`: Whether to auto-start the loader on import (default: true)
+   *
+   * @example
+   * ```typescript
+   * // Simple usage
+   * autoLoader: true
+   *
+   * // With options
+   * autoLoader: {
+   *   fileName: 'my-loader.js',
+   *   autoStart: false
+   * }
+   * ```
+   */
+  autoLoader?: boolean | {
+    /**
+     * Custom filename for the generated loader script.
+     * @default 'loader.js'
+     */
+    fileName?: string;
+    /**
+     * Whether to automatically start the loader when the script is imported.
+     * If false, you must call `start()` manually.
+     * @default true
+     */
+    autoStart?: boolean;
+  };
+}
+/**
+ * The base type for output targets. All output targets should extend this base type.
+ */
+interface OutputTargetBase {
+  /**
+   * A unique string to differentiate one output target from another
+   */
+  type: string;
+  /**
+   * When `true`, this output target will be skipped during development builds (`--dev`).
+   * This improves dev build times by not generating production-only artifacts.
+   *
+   * Defaults vary by output target type:
+   * - `loader-bundle`: `false` (always builds)
+   * - `standalone`: `true` (skips in dev)
+   * - `ssr`: `true` (skips in dev, unless `devServer.ssr` is enabled)
+   * - `docs-*`: `true` (skips in dev)
+   * - `custom`: `true` (skips in dev)
+   * - `www`, `copy`, `stats`: `false` (always runs)
+   */
+  skipInDev?: boolean;
+}
+interface OutputTargetCopy extends OutputTargetBase {
+  type: 'copy';
+  dir: string;
+  copy?: CopyTask[];
+}
+interface OutputTargetWww extends OutputTargetBase {
+  /**
+   * Webapp output target.
+   */
+  type: 'www';
+  /**
+   * Choose how components are bundled for the www output.
+   *
+   * - `'loader'` (default): Uses the loader-bundle architecture with chunk
+   *   splitting and a loader infrastructure. Best for production apps with many
+   *   components where you want optimal loading performance.
+   *
+   * - `'standalone'`: Uses standalone component modules with an auto-loader that
+   *   uses MutationObserver to dynamically import components as they appear in
+   *   the DOM. Simpler architecture, easier debugging, one module per component.
+   *
+   * Default: `'loader'`
+   */
+  bundleMode?: 'loader' | 'standalone';
+  /**
+   * The directory to write the app's JavaScript and CSS build
+   * files to. The default is to place this directory as a child
+   * to the `dir` config. Default: `build`
+   */
+  buildDir?: string;
+  /**
+   * The directory to write the entire application to.
+   * Note, the `buildDir` is where the app's JavaScript and CSS build
+   * files are written. Default: `www`
+   */
+  dir?: string;
+  /**
+   * Empty the build directory of all files and directories on first build.
+   * Default: `true`
+   */
+  empty?: boolean;
+  /**
+   * The default index html file of the app, commonly found at the
+   * root of the `src` directory.
+   * Default: `index.html`
+   */
+  indexHtml?: string;
+  /**
+   * The copy config is an array of objects that defines any files or folders that should
+   * be copied over to the build directory.
+   *
+   * Each object in the array must include a src property which can be either an absolute path,
+   * a relative path or a glob pattern. The config can also provide an optional dest property
+   * which can be either an absolute path or a path relative to the build directory.
+   * Also note that any files within src/assets are automatically copied to www/assets for convenience.
+   *
+   * In the copy config below, it will copy the entire directory from src/docs-content over to www/docs-content.
+   */
+  copy?: CopyTask[];
+  /**
+   * The base url of the app, it's required during prerendering to be the absolute path
+   * of your app, such as: `https://my.app.com/app`.
+   *
+   * Default: `/`
+   */
+  baseUrl?: string;
+  /**
+   * Path to an external node module which has exports of the prerender config object.
+   * ```
+   * module.exports = {
+   *   afterSsr(document, url) {
+   *     document.title = `URL: ${url.href}`;
+   *   }
+   * }
+   * ```
+   */
+  prerenderConfig?: string;
+  /**
+   * Service worker config for production builds. In development mode, a script
+   * to deregister existing service workers is always injected. Defaults to
+   * `null` (disabled). Set to `true` to enable with default settings, or provide
+   * a config object for custom settings.
+   */
+  serviceWorker?: ServiceWorkerConfig | true | null;
+  appDir?: string;
+  /**
+   * Hash the filenames of generated chunks based on their content.
+   * Enables forever-caching of CDN-served bundles.
+   *
+   * @default true in production, false in dev mode
+   */
+  hashFileNames?: boolean;
+  /**
+   * Number of characters to use for the content hash in filenames.
+   *
+   * @default 8
+   */
+  hashedFileNameLength?: number;
+}
+type OutputTarget = OutputTargetCopy | OutputTargetCustom | OutputTargetLoaderBundle | OutputTargetStandalone | OutputTargetSsr | OutputTargetSsrWasm | OutputTargetCollection | OutputTargetTypes | OutputTargetGlobalStyle | OutputTargetAssets | OutputTargetDistLazy | OutputTargetDocsJson | OutputTargetDocsCustom | OutputTargetDocsReadme | OutputTargetDocsVscode | OutputTargetDocsCustomElementsManifest | OutputTargetDocsAgentSkill | OutputTargetWww | OutputTargetStats;
+/**
+ * Our custom configuration interface for generated caching Service Workers
+ * using the Workbox library (see https://developer.chrome.com/docs/workbox/).
+ *
+ * Although we are using Workbox we are unfortunately unable to depend on the
+ * published types for the library because they must be compiled using the
+ * `webworker` lib for TypeScript, which cannot be used at the same time as
+ * the `dom` lib. So as a workaround we maintain our own interface here. See
+ * here to refer to the published version:
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/c7b4dadae5b320ad1311a8f82242b8f2f41b7b8c/types/workbox-build/generate-sw.d.ts#L3
+ */
+interface ServiceWorkerConfig {
+  unregister?: boolean;
+  swDest?: string;
+  swSrc?: string;
+  globPatterns?: string[];
+  globDirectory?: string | string[];
+  globIgnores?: string | string[];
+  templatedUrls?: any;
+  maximumFileSizeToCacheInBytes?: number;
+  manifestTransforms?: any;
+  modifyUrlPrefix?: any;
+  dontCacheBustURLsMatching?: RegExp;
+  navigateFallback?: string;
+  navigateFallbackWhitelist?: RegExp[];
+  navigateFallbackBlacklist?: RegExp[];
+  cacheId?: string;
+  skipWaiting?: boolean;
+  clientsClaim?: boolean;
+  directoryIndex?: string;
+  runtimeCaching?: any[];
+  ignoreUrlParametersMatching?: any[];
+  handleFetch?: boolean;
+}
+interface LoadConfigInit {
+  /**
+   * User config object to merge into default config and
+   * config loaded from a file path.
+   */
+  config?: UnvalidatedConfig;
+  /**
+   * Absolute path to a Stencil config file. This path cannot be
+   * relative and it does not resolve config files within a directory.
+   */
+  configPath?: string;
+  logger?: Logger;
+  sys?: CompilerSystem;
+}
+interface Diagnostic {
+  absFilePath?: string | undefined;
+  code?: string;
+  columnNumber?: number | undefined;
+  debugText?: string;
+  header?: string;
+  language?: string;
+  level: 'error' | 'warn' | 'info' | 'log' | 'debug';
+  lineNumber?: number | undefined;
+  lines: PrintLine[];
+  messageText: string;
+  relFilePath?: string | undefined;
+  type: string;
+}
+interface CacheStorage {
+  get(key: string): Promise<any>;
+  set(key: string, value: any): Promise<void>;
+}
+/**
+ * Input for CSS optimization functions, including the input CSS
+ * string and a few boolean options which turn on or off various
+ * optimizations.
+ */
+interface OptimizeCssInput {
+  input: string;
+  filePath?: string;
+  autoprefixer?: boolean | null | AutoprefixerOptions;
+  minify?: boolean;
+  sourceMap?: boolean;
+  resolveUrl?: (url: string) => Promise<string> | string;
+}
+/**
+ * Options for autoprefixing CSS via Lightning CSS.
+ *
+ * The `targets` field accepts a browserslist query array. When omitted,
+ * Stencil uses a modern default browser list suitable for Stencil v5+.
+ *
+ * @example
+ * ```ts
+ * autoprefixer: {
+ *   targets: ['last 2 Chrome versions', 'last 2 Safari versions', 'iOS >= 14'],
+ * }
+ * ```
+ */
+interface AutoprefixerOptions {
+  /**
+   * A browserslist query array describing which browsers to generate vendor
+   * prefixes for. Defaults to a modern set of browsers appropriate for
+   * Stencil v5+.
+   */
+  targets?: string[];
+}
+/**
+ * Output from CSS optimization functions, wrapping up optimized
+ * CSS and any diagnostics produced during optimization.
+ */
+interface OptimizeCssOutput {
+  output: string;
+  diagnostics: Diagnostic[];
+}
+interface LazyRequire {
+  ensure(fromDir: string, moduleIds: string[]): Promise<Diagnostic[]>;
+  require(fromDir: string, moduleId: string): any;
+  getModulePath(fromDir: string, moduleId: string): string;
+}
+//#endregion
+//#region src/declarations/stencil-private.d.ts
+interface SourceMap$1 {
+  file: string;
+  mappings: string;
+  names: string[];
+  sourceRoot?: string;
+  sources: string[];
+  sourcesContent?: (string | null)[];
+  version: number;
+}
+interface PrintLine {
+  lineIndex: number;
+  lineNumber: number;
+  text: string;
+  errorCharStart: number;
+  errorLength?: number;
+}
+interface BuildFeatures {
+  style: boolean;
+  mode: boolean;
+  formAssociated: boolean;
+  shadowDom: boolean;
+  shadowDelegatesFocus: boolean;
+  shadowModeClosed: boolean;
+  shadowSlotAssignmentManual: boolean;
+  shadowClonable: boolean;
+  shadowSerializable: boolean;
+  scoped: boolean;
+  /**
+   * Every component has a render function
+   */
+  allRenderFn: boolean;
+  /**
+   * At least one component has a render function
+   */
+  hasRenderFn: boolean;
+  vdomRender: boolean;
+  vdomAttribute: boolean;
+  vdomClass: boolean;
+  vdomFunctional: boolean;
+  vdomKey: boolean;
+  vdomListener: boolean;
+  vdomPropOrAttr: boolean;
+  /** True when at least one component uses the explicit `attr:`/`prop:` JSX prefix. */
+  vdomPropOrAttrPrefix: boolean;
+  vdomRef: boolean;
+  vdomStyle: boolean;
+  vdomText: boolean;
+  vdomXlink: boolean;
+  vdomSignals: boolean;
+  slotRelocation: boolean;
+  patchAll: boolean;
+  patchChildren: boolean;
+  patchClone: boolean;
+  patchInsert: boolean;
+  slot: boolean;
+  svg: boolean;
+  element: boolean;
+  event: boolean;
+  hostListener: boolean;
+  hostListenerTargetWindow: boolean;
+  hostListenerTargetDocument: boolean;
+  hostListenerTargetBody: boolean;
+  hostListenerTarget: boolean;
+  method: boolean;
+  prop: boolean;
+  propChangeCallback: boolean;
+  propMutable: boolean;
+  state: boolean;
+  member: boolean;
+  updatable: boolean;
+  propBoolean: boolean;
+  propNumber: boolean;
+  propString: boolean;
+  serializer: boolean;
+  deserializer: boolean;
+  lifecycle: boolean;
+  asyncLoading: boolean;
+  observeAttribute: boolean;
+  reflect: boolean;
+  taskQueue: boolean;
+}
+interface BuildConditionals extends Partial<BuildFeatures> {
+  hotModuleReplacement?: boolean;
+  isDebug?: boolean;
+  isTesting?: boolean;
+  isDev?: boolean;
+  devTools?: boolean;
+  invisiblePrehydration?: boolean;
+  hydrateServerSide?: boolean;
+  hydrateClientSide?: boolean;
+  lifecycleDOMEvents?: boolean;
+  cssAnnotations?: boolean;
+  lazyLoad?: boolean;
+  profile?: boolean;
+  constructableCSS?: boolean;
+  /** True when `compat.lightDomPatches === true` - enables `applyLightDomPatches` shortcut. */
+  lightDomPatches?: boolean;
+  /** Patch `childNodes`/`children` getters on light-dom slotted components. */
+  slotChildNodes?: boolean;
+  /** Patch `cloneNode()` on light-dom slotted components. */
+  slotCloneNode?: boolean;
+  /** Patch `appendChild`/`insertBefore`/`removeChild` on light-dom slotted components. */
+  slotDomMutations?: boolean;
+  /** Patch `textContent` on light-dom slotted components. */
+  slotTextContent?: boolean;
+  hydratedAttribute?: boolean;
+  hydratedClass?: boolean;
+  hydratedSelectorName?: string;
+  /** True when a global-style input contains `@import "stencil-hydrate"` - suppresses dynamic style injection in the loader. */
+  staticHydrationStyles?: boolean;
+  initializeNextTick?: boolean;
+  asyncQueue?: boolean;
+  additionalTagTransformers?: boolean | 'prod';
+  signalBacking?: boolean;
+  /** True when JSX signal bypass is active - text nodes and attributes backed by Signal objects update the DOM directly. Auto-enabled when `signalBacking: true`. */
+  vdomSignals?: boolean;
+}
+type ModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd' | 'commonjs' | 'esm' | 'module' | 'systemjs';
+interface RolldownResultModule {
+  id: string;
+}
+interface RolldownResults {
+  modules: RolldownResultModule[];
+}
+interface BuildCtx {
+  buildId: number;
+  buildResults: CompilerBuildResults;
+  buildStats?: Result<CompilerBuildStats, {
+    diagnostics: Diagnostic[];
+  }>;
+  buildMessages: string[];
+  bundleBuildCount: number;
+  collections: CollectionCompilerMeta[];
+  compilerCtx: CompilerCtx;
+  esmBrowserComponentBundle: ReadonlyArray<BundleModule>;
+  esmComponentBundle: ReadonlyArray<BundleModule>;
+  commonJsComponentBundle: ReadonlyArray<BundleModule>;
+  components: ComponentCompilerMeta[];
+  componentGraph: Map<string, string[]>;
+  config: ValidatedConfig;
+  createTimeSpan(msg: string, debug?: boolean): LoggerTimeSpan;
+  data: any;
+  debug: (msg: string) => void;
+  diagnostics: Diagnostic[];
+  dirsAdded: string[];
+  dirsDeleted: string[];
+  entryModules: EntryModule[];
+  filesAdded: string[];
+  filesChanged: string[];
+  filesDeleted: string[];
+  filesUpdated: string[];
+  filesWritten: string[];
+  globalStyle: string | undefined;
+  hasConfigChanges: boolean;
+  hasError: boolean;
+  hasFinished: boolean;
+  hasHtmlChanges: boolean;
+  hasPrintedResults: boolean;
+  hasServiceWorkerChanges: boolean;
+  hasScriptChanges: boolean;
+  hasStyleChanges: boolean;
+  hasWarning: boolean;
+  ssrAppFilePath: string;
+  indexBuildCount: number;
+  indexDoc: Document;
+  /** All non-entry HTML files found in srcDir, keyed by path relative to srcDir */
+  htmlDocs: Map<string, Document>;
+  isRebuild: boolean;
+  /**
+   * A collection of Stencil's intermediate representation of components, tied to the current build
+   */
+  moduleFiles: Module[];
+  packageJson: PackageJsonData | null;
+  pendingCopyTasks: Promise<CopyResults>[];
+  progress(task: BuildTask): void;
+  requiresFullBuild: boolean;
+  rolldownResults?: RolldownResults;
+  scriptsAdded: string[];
+  scriptsDeleted: string[];
+  startTime: number;
+  styleBuildCount: number;
+  /**
+   * A promise that resolves to the global styles for the current build.
+   */
+  stylesPromise: Promise<string>;
+  stylesUpdated: BuildStyleUpdate[];
+  timeSpan: LoggerTimeSpan;
+  timestamp: string;
+  transpileBuildCount: number;
+  validateTypesBuild?(): Promise<void>;
+  validateTypesHandler?: (results: any) => Promise<void>;
+  validateTypesPromise?: Promise<any>;
+}
+interface BuildStyleUpdate {
+  styleTag: string;
+  styleText: string;
+  styleMode: string;
+}
+type BuildTask = any;
+interface CompilerBuildStats {
+  timestamp: string;
+  compiler: {
+    name: string;
+    version: string;
+  };
+  app: {
+    namespace: string;
+    fsNamespace: string;
+    components: number;
+    entries: number;
+    bundles: number;
+    outputs: any;
+  };
+  options: {
+    minifyJs: boolean;
+    minifyCss: boolean;
+  };
+  formats: {
+    esmBrowser: ReadonlyArray<CompilerBuildStatBundle>;
+    esm: ReadonlyArray<CompilerBuildStatBundle>;
+    commonjs: ReadonlyArray<CompilerBuildStatBundle>;
+  };
+  components: BuildComponent[];
+  entries: EntryModule[];
+  rolldownResults: RolldownResults;
+  sourceGraph?: BuildSourceGraph;
+  componentGraph: BuildResultsComponentGraph;
+  collections: CompilerBuildStatCollection[];
+}
+interface CompilerBuildStatCollection {
+  name: string;
+  source: string;
+  tags: string[][];
+}
+interface CompilerBuildStatBundle {
+  key: string;
+  components: string[];
+  bundleId: string;
+  fileName: string;
+  imports: string[];
+  originalByteSize: number;
+}
+interface BuildSourceGraph {
+  [filePath: string]: string[];
+}
+interface BuildComponent {
+  tag: string;
+  dependencyOf?: string[];
+  dependencies?: string[];
+}
+interface RolldownChunkResult {
+  type: 'chunk';
+  entryKey: string;
+  fileName: string;
+  code: string;
+  isEntry: boolean;
+  isComponent: boolean;
+  isCore: boolean;
+  isIndex: boolean;
+  isBrowserLoader: boolean;
+  imports: string[];
+  moduleFormat: ModuleFormat;
+  map?: SourceMap;
+}
+interface BundleModule {
+  entryKey: string;
+  rolldownResult: RolldownChunkResult;
+  cmps: ComponentCompilerMeta[];
+  output: BundleModuleOutput;
+}
+interface BundleModuleOutput {
+  bundleId: string;
+  fileName: string;
+  code: string;
+}
+interface Cache {
+  get(key: string): Promise<string | null>;
+  put(key: string, value: string): Promise<boolean>;
+  has(key: string): Promise<boolean>;
+  createKey(domain: string, ...args: any[]): Promise<string>;
+  commit(): Promise<void>;
+  clear(): void;
+  clearDiskCache(): Promise<void>;
+  getMemoryStats(): string;
+  initCacheDir(): Promise<void>;
+}
+interface CollectionCompilerMeta {
+  collectionName: string;
+  moduleId?: string;
+  moduleDir: string;
+  moduleFiles: Module[];
+  global?: Module;
+  compiler?: CollectionCompilerVersion;
+  isInitialized?: boolean;
+  hasExports?: boolean;
+  dependencies?: string[];
+  bundles?: {
+    components: string[];
+  }[];
+  buildFlags?: Partial<BuildConditionals>;
+}
+interface CollectionCompilerVersion {
+  name: string;
+  version: string;
+  typescriptVersion?: string;
+}
+/**
+ * A memoized result of the SASS + Lightning CSS transformation for a single stylesheet, keyed by
+ * the annotated Rolldown import id (e.g. `/path/to/comp.scss?tag=ion-button&encapsulation=shadow`).
+ *
+ * Storing this allows all output targets (customElements, lazy, hydrate) that process the same
+ * stylesheets to share a single computation instead of repeating it N times.
+ */
+interface CssTransformCacheEntry {
+  /** Resolved file ID after plugin (SASS) transforms */
+  pluginTransformId: string;
+  /** CSS source produced by the SASS / plugin pipeline */
+  pluginTransformCode: string;
+  /** File dependencies discovered during the SASS transform (e.g. `@import`-ed partials) */
+  pluginTransformDependencies: string[];
+  /** Diagnostics emitted during the plugin transform pass */
+  pluginTransformDiagnostics: Diagnostic[];
+  /** Full output of the subsequent `transformCssToEsm` call */
+  cssTransformOutput: TransformCssToEsmOutput;
+}
+interface CompilerCtx {
+  version: number;
+  activeBuildId: number;
+  activeDirsAdded: string[];
+  activeDirsDeleted: string[];
+  activeFilesAdded: string[];
+  activeFilesDeleted: string[];
+  activeFilesUpdated: string[];
+  addWatchDir: (path: string, recursive: boolean) => void;
+  addWatchFile: (path: string) => void;
+  cache: Cache;
+  cssModuleImports: Map<string, string[]>;
+  /** Cache of built global styles, keyed by input file path */
+  globalStyleCache: Map<string, string>;
+  collections: CollectionCompilerMeta[];
+  compilerOptions: any;
+  events: BuildEvents;
+  fs: InMemoryFileSystem;
+  hasSuccessfulBuild: boolean;
+  isActivelyBuilding: boolean;
+  lastBuildResults: CompilerBuildResults;
+  /**
+   * A mapping of a file path to a Stencil {@link Module}
+   */
+  moduleMap: ModuleMap;
+  nodeMap: NodeMap;
+  resolvedCollections: Set<string>;
+  rolldownCacheSsr: any;
+  rolldownCacheLazy: any;
+  rolldownCacheNative: any;
+  styleModeNames: Set<string>;
+  changedModules: Set<string>;
+  changedFiles: Set<string>;
+  worker?: CompilerWorkerContext;
+  rolldownCache: Map<string, any>;
+  /**
+   * Cross-build cache for {@link ts.transpileModule} results.
+   * Keyed by `"${bundleId}:${normalizedFilePath}"`. Invalidated for any
+   * file that appears in {@link changedModules} after TypeScript re-emits.
+   * @see transpileCache in compiler-ctx.ts
+   */
+  transpileCache: Map<string, {
+    outputText: string;
+    sourceMapText: string | null;
+  }>;
+  /**
+   * Cross-build cache of the last style text pushed to the HMR client.
+   * Keyed by getScopeId result (e.g. "ion-accordion$ios"). Used by
+   * extTransformsPlugin to avoid re-pushing unchanged styles on every rebuild.
+   */
+  prevStylesMap: Map<string, string>;
+  /**
+   * Cross-output-target cache for the SASS + Lightning CSS computation.
+   * Keyed by the annotated Rolldown import id. Null entries indicate that the
+   * source file could not be read (propagated as a `null` return from the
+   * transform hook).
+   *
+   * Entries are invalidated in `invalidateRolldownCaches` whenever a
+   * source file or one of its SASS dependencies is modified.
+   */
+  cssTransformCache: Map<string, CssTransformCacheEntry | null>;
+  reset(): void;
+}
+type NodeMap = WeakMap<any, ComponentCompilerMeta>;
+/**
+ * Record, for a specific component, whether or not it has various features
+ * which need to be handled correctly in the compilation pipeline.
+ *
+ * Note: this must be serializable to JSON.
+ */
+interface ComponentCompilerFeatures {
+  hasAttribute: boolean;
+  hasAttributeChangedCallbackFn: boolean;
+  hasComponentWillLoadFn: boolean;
+  hasComponentDidLoadFn: boolean;
+  hasComponentShouldUpdateFn: boolean;
+  hasComponentWillUpdateFn: boolean;
+  hasComponentDidUpdateFn: boolean;
+  hasComponentWillRenderFn: boolean;
+  hasComponentDidRenderFn: boolean;
+  hasConnectedCallbackFn: boolean;
+  hasDeserializer: boolean;
+  hasDisconnectedCallbackFn: boolean;
+  hasElement: boolean;
+  hasEvent: boolean;
+  hasLifecycle: boolean;
+  hasListener: boolean;
+  hasListenerTarget: boolean;
+  hasListenerTargetWindow: boolean;
+  hasListenerTargetDocument: boolean;
+  hasListenerTargetBody: boolean;
+  hasMember: boolean;
+  hasMethod: boolean;
+  hasMode: boolean;
+  hasModernPropertyDecls: boolean;
+  hasPatchAll: boolean;
+  hasPatchChildren: boolean;
+  hasPatchClone: boolean;
+  hasPatchInsert: boolean;
+  hasProp: boolean;
+  hasPropBoolean: boolean;
+  hasPropNumber: boolean;
+  hasPropString: boolean;
+  hasPropMutable: boolean;
+  hasReflect: boolean;
+  hasRenderFn: boolean;
+  hasSerializer: boolean;
+  hasSlot: boolean;
+  hasState: boolean;
+  hasStyle: boolean;
+  hasVdomAttribute: boolean;
+  hasVdomClass: boolean;
+  hasVdomFunctional: boolean;
+  hasVdomKey: boolean;
+  hasVdomListener: boolean;
+  hasVdomPropOrAttr: boolean;
+  hasVdomPropOrAttrPrefix: boolean;
+  hasVdomRef: boolean;
+  hasVdomRender: boolean;
+  hasVdomStyle: boolean;
+  hasVdomText: boolean;
+  hasVdomXlink: boolean;
+  hasSignalsImport: boolean;
+  hasWatchCallback: boolean;
+  htmlAttrNames: string[];
+  htmlTagNames: string[];
+  htmlParts: string[];
+  htmlSlots: string[];
+  isUpdateable: boolean;
+  /**
+   * A plain component is one that doesn't have:
+   * - any members decorated with `@Prop()`, `@State()`, `@Element()`, `@Method()`
+   * - any methods decorated with `@Listen()`
+   * - any styles
+   * - any lifecycle methods, including `render()`
+   */
+  isPlain: boolean;
+  /**
+   * A collection of tag names of web components that a component references in its JSX/h() function
+   */
+  potentialCmpRefs: string[];
+}
+/**
+ * Metadata about a given component
+ *
+ * Note: must be serializable to JSON!
+ */
+interface ComponentCompilerMeta extends ComponentCompilerFeatures {
+  assetsDirs: CompilerAssetDir[];
+  /**
+   * The name to which an `ElementInternals` object (the return value of
+   * `HTMLElement.attachInternals`) should be attached at runtime. If this is
+   * `null` then `attachInternals` should not be called.
+   */
+  attachInternalsMemberName: string | null;
+  /**
+   * Custom states to initialize on the ElementInternals.states CustomStateSet.
+   * These are defined via @AttachInternals({ states: {...} }).
+   */
+  attachInternalsCustomStates: ComponentCompilerCustomState[];
+  componentClassName: string;
+  /**
+   * A list of web component tag names that are either:
+   * - directly referenced in a Stencil component's JSX/h() function
+   * - are referenced by a web component that is directly referenced in a Stencil component's JSX/h() function
+   */
+  dependencies: string[];
+  /**
+   * A list of web component tag names that either:
+   * - directly reference the current component directly in their JSX/h() function
+   * - indirectly/transitively reference the current component directly in their JSX/h() function
+   */
+  dependents: string[];
+  deserializers: ComponentCompilerChangeHandler[];
+  /**
+   * A list of web component tag names that are directly referenced in a Stencil component's JSX/h() function
+   */
+  directDependencies: string[];
+  /**
+   * A list of web component tag names that the current component directly in their JSX/h() function
+   */
+  directDependents: string[];
+  docs: CompilerJsDoc;
+  doesExtend: boolean;
+  elementRef: string;
+  encapsulation: Encapsulation;
+  events: ComponentCompilerEvent[];
+  excludeFromCollection: boolean;
+  /**
+   * Whether or not the component is form-associated
+   */
+  formAssociated: boolean;
+  internal: boolean;
+  isCollectionDependency: boolean;
+  jsFilePath: string;
+  listeners: ComponentCompilerListener[];
+  methods: ComponentCompilerMethod[];
+  properties: ComponentCompilerProperty[];
+  serializers: ComponentCompilerChangeHandler[];
+  shadowDelegatesFocus: boolean;
+  /**
+   * Whether the shadow root is preserved when the host element is deep-cloned via
+   * `Node.cloneNode(true)`. Only applicable when encapsulation is 'shadow'.
+   */
+  shadowClonable: boolean;
+  /**
+   * Whether the shadow root is marked serializable for `Element.getHTML({ serializableShadowRoots: true })`.
+   * Only applicable when encapsulation is 'shadow'.
+   */
+  shadowSerializable: boolean;
+  /**
+   * Shadow DOM mode. 'open' (default) or 'closed'.
+   * Only applicable when encapsulation is 'shadow'.
+   */
+  shadowMode: 'open' | 'closed' | null;
+  /**
+   * Slot assignment mode for shadow DOM. 'manual', enables imperative slotting
+   * using HTMLSlotElement.assign(). Only applicable when encapsulation is 'shadow'.
+   */
+  slotAssignment: 'manual' | null;
+  /**
+   * Per-component slot patches for non-shadow DOM components.
+   * These patches enable proper slot behavior without native Shadow DOM.
+   * Only applicable when encapsulation is 'none' or 'scoped'.
+   */
+  patches: ComponentPatches | null;
+  sourceFilePath: string;
+  sourceMapPath: string;
+  states: ComponentCompilerState[];
+  styleDocs: CompilerStyleDoc[];
+  styles: StyleCompiler[];
+  globalStyles: ComponentGlobalStyle[];
+  tagName: string;
+  virtualProperties: ComponentCompilerVirtualProperty[];
+  watchers: ComponentCompilerChangeHandler[];
+}
+/**
+ * The supported style encapsulation modes on a Stencil component:
+ * 1. 'shadow' - native Shadow DOM
+ * 2. 'scoped' - encapsulated styles and polyfilled slots
+ * 3. 'none' - a basic HTML element
+ */
+type Encapsulation = 'shadow' | 'scoped' | 'none';
+/**
+ * Per-component slot patches for non-shadow DOM components.
+ * These enable proper slot behavior when not using native Shadow DOM.
+ */
+interface ComponentPatches {
+  /** Apply all slot patches (equivalent to lightDomPatches) */
+  all?: boolean;
+  /** Patch child node accessors (children, firstChild, lastChild, etc.) */
+  children?: boolean;
+  /** Patch cloneNode() to handle slotted content */
+  clone?: boolean;
+  /** Patch appendChild(), insertBefore(), etc. for slot relocation */
+  insert?: boolean;
+}
+/**
+ * Intermediate Representation (IR) of a static property on a Stencil component
+ */
+interface ComponentCompilerStaticProperty {
+  mutable: boolean;
+  optional: boolean;
+  required: boolean;
+  type: ComponentCompilerPropertyType;
+  complexType: ComponentCompilerPropertyComplexType;
+  attribute?: string;
+  reflect?: boolean;
+  docs: CompilerJsDoc;
+  defaultValue?: string;
+  getter: boolean;
+  setter: boolean;
+  ogPropName?: string;
+}
+/**
+ * Intermediate Representation (IR) of a property on a Stencil component
+ */
+interface ComponentCompilerProperty extends ComponentCompilerStaticProperty {
+  name: string;
+  internal: boolean;
+}
+interface ComponentCompilerVirtualProperty {
+  name: string;
+  type: string;
+  docs: string;
+}
+type ComponentCompilerPropertyType = 'any' | 'string' | 'boolean' | 'number' | 'unknown';
+/**
+ * Information about a type used in a Stencil component or exported
+ * from a Stencil project.
+ */
+interface ComponentCompilerPropertyComplexType {
+  /**
+   * The string of the original type annotation in the Stencil source code
+   */
+  original: string;
+  /**
+   * A 'resolved' type, where e.g. imported types have been resolved and inlined
+   *
+   * For instance, an annotation like `(foo: Foo) => string;` will be
+   * converted to `(foo: { foo: string }) => string;`.
+   */
+  resolved: string;
+  /**
+   * A record of the types which were referenced in the assorted type
+   * annotation in the original source file.
+   */
+  references: ComponentCompilerTypeReferences;
+  /**
+   * @internal TypeScript AST node used for semantic type analysis during compilation.
+   * Not serialized, only used internally for improved type renaming logic.
+   */
+  _astNode?: any;
+}
+/**
+ * A record of `ComponentCompilerTypeReference` entities.
+ *
+ * Each key in this record is intended to be the names of the types used by a component. However, this is not enforced
+ * by the type system (I.E. any string can be used as a key).
+ *
+ * Note any key can be a user defined type or a TypeScript standard type.
+ */
+type ComponentCompilerTypeReferences = Record<string, ComponentCompilerTypeReference>;
+/**
+ * Describes a reference to a type used by a component.
+ */
+interface ComponentCompilerTypeReference {
+  /**
+   * A type may be defined:
+   * - locally (in the same file as the component that uses it)
+   * - globally
+   * - by importing it into a file (and is defined elsewhere)
+   */
+  location: 'local' | 'global' | 'import';
+  /**
+   * The path to the type reference, if applicable (global types should not need a path associated with them)
+   */
+  path?: string;
+  /**
+   * An ID for this type which is unique within a Stencil project.
+   */
+  id: string;
+  /**
+   * Whether this type was imported as a default import (e.g., `import MyEnum from './my-enum'`)
+   * vs a named import (e.g., `import { MyType } from './my-type'`)
+   */
+  isDefault?: boolean;
+  /**
+   * The name used in the import statement (before any user-defined alias).
+   * For `import { XAxisOption as moo }`, this would be "XAxisOption".
+   * This is the name exported by the source module.
+   */
+  referenceLocation?: string;
+}
+/**
+ * Information about a type which is referenced by another type on a Stencil
+ * component, for instance a {@link ComponentCompilerPropertyComplexType} or a
+ * {@link ComponentCompilerEventComplexType}.
+ */
+interface ComponentCompilerReferencedType {
+  /**
+   * The path to the module where the type is declared.
+   */
+  path: string;
+  /**
+   * The string of the original type annotation in the Stencil source code
+   */
+  declaration: string;
+  /**
+   * An extracted docstring
+   */
+  docstring: string;
+}
+interface ComponentCompilerStaticEvent {
+  name: string;
+  method: string;
+  bubbles: boolean;
+  cancelable: boolean;
+  composed: boolean;
+  docs: CompilerJsDoc;
+  complexType: ComponentCompilerEventComplexType;
+}
+interface ComponentCompilerEvent extends ComponentCompilerStaticEvent {
+  internal: boolean;
+}
+interface ComponentCompilerEventComplexType {
+  original: string;
+  resolved: string;
+  references: ComponentCompilerTypeReferences;
+}
+interface ComponentCompilerListener {
+  name: string;
+  method: string;
+  capture: boolean;
+  passive: boolean;
+  target: ListenTargetOptions | undefined;
+}
+interface ComponentCompilerStaticMethod {
+  docs: CompilerJsDoc;
+  complexType: ComponentCompilerMethodComplexType;
+}
+interface ComponentCompilerMethodComplexType {
+  signature: string;
+  parameters: JsonDocMethodParameter[];
+  references: ComponentCompilerTypeReferences;
+  return: string;
+  /**
+   * @internal TypeScript AST method node used for semantic type analysis during compilation.
+   * Not serialized, only used internally for improved type renaming logic.
+   */
+  _astNode?: any;
+}
+interface ComponentCompilerChangeHandler {
+  propName: string;
+  methodName: string;
+  handlerOptions?: {
+    immediate?: boolean;
+  };
+}
+interface ComponentCompilerMethod extends ComponentCompilerStaticMethod {
+  name: string;
+  internal: boolean;
+}
+interface ComponentCompilerState {
+  name: string;
+}
+/**
+ * Metadata about a custom state defined via @AttachInternals({ states: {...} })
+ *
+ * Custom states are exposed via the ElementInternals.states CustomStateSet
+ * and can be targeted with the CSS :state() pseudo-class.
+ */
+interface ComponentCompilerCustomState {
+  /**
+   * The name of the custom state (without dashes)
+   */
+  name: string;
+  /**
+   * The initial value of the state
+   */
+  initialValue: boolean;
+  /**
+   * Optional JSDoc description for the state
+   */
+  docs: string;
+}
+/**
+ * Representation of JSDoc that is pulled off a node in the AST
+ */
+interface CompilerJsDoc {
+  /**
+   * The text associated with the JSDoc
+   */
+  text: string;
+  /**
+   * Tags included in the JSDoc
+   */
+  tags: CompilerJsDocTagInfo[];
+}
+/**
+ * Representation of a tag that exists in a JSDoc
+ */
+interface CompilerJsDocTagInfo {
+  /**
+   * The name of the tag - e.g. `@deprecated`
+   */
+  name: string;
+  /**
+   * Additional text that is associated with the tag - e.g. `@deprecated use v2 of this API`
+   */
+  text?: string;
+}
+/**
+ * The (internal) representation of a CSS block comment in a CSS, Sass, etc. file. This data structure is used during
+ * the initial compilation phases of Stencil, as a piece of {@link ComponentCompilerMeta}.
+ */
+interface CompilerStyleDoc {
+  /**
+   * The name of the CSS property
+   */
+  name: string;
+  /**
+   * The user-defined description of the CSS property
+   */
+  docs: string;
+  /**
+   * The JSDoc-style annotation (e.g. `@prop`) that was used in the block comment to detect the comment.
+   * Used to inform Stencil where the start of a new property's description starts (and where the previous description
+   * ends).
+   */
+  annotation: 'prop';
+  /**
+   * The Stencil style-mode that is associated with this property.
+   */
+  mode: string;
+}
+interface CompilerAssetDir {
+  absolutePath?: string;
+  cmpRelativePath?: string;
+  originalComponentPath?: string;
+}
+/**
+ * A mapping from class member names to a list of methods which are watching
+ * them.
+ */
+interface ComponentConstructorChangeHandlers {
+  [propName: string]: {
+    [methodName: string]: number;
+  }[];
+}
+interface EntryModule {
+  entryKey: string;
+  cmps: ComponentCompilerMeta[];
+}
+/**
+ * An interface extending `HTMLElement` which describes the fields added onto
+ * host HTML elements by the Stencil runtime.
+ */
+interface HostElement extends HTMLElement {
+  connectedCallback?: () => void;
+  attributeChangedCallback?: (attribName: string, oldVal: string, newVal: string, namespace: string) => void;
+  disconnectedCallback?: () => void;
+  host?: Element;
+  forceUpdate?: () => void;
+  __s_ghr?: () => HostRef;
+  /**
+   * Unique stencil id for this element
+   */
+  ['s-id']?: string;
+  /**
+   * Content Reference:
+   * Reference to the HTML Comment that's placed inside of the
+   * host element's original content. This comment is used to
+   * always represent where host element's light dom is.
+   */
+  ['s-cr']?: RenderNode;
+  /**
+   * Lifecycle ready
+   */
+  ['s-lr']?: boolean;
+  /**
+   * A reference to the `ElementInternals` object for the current host
+   *
+   * This is used for maintaining a reference to the object between HMR
+   * refreshes in the lazy build.
+   *
+   * "stencil-element-internals"
+   */
+  ['s-ei']?: ElementInternals;
+  /**
+   * On Render Callbacks:
+   * Array of callbacks to fire off after it has rendered.
+   */
+  ['s-rc']?: (() => void)[];
+  /**
+   * Scope Id
+   * The scope id of this component when using scoped css encapsulation
+   * or using shadow dom but the browser doesn't support it
+   */
+  ['s-sc']?: string;
+  /**
+   * Scope Ids
+   * All the possible scope ids of this component when using scoped css encapsulation
+   * or using shadow dom but the browser doesn't support it
+   */
+  ['s-scs']?: string[];
+  /**
+   * Hot Module Replacement, dev mode only
+   *
+   * This function should be defined by the HMR-supporting runtime and should
+   * do the work of actually updating the component in-place.
+   */
+  ['s-hmr']?: (versionId: string) => void;
+  /**
+   * A list of nested nested hydration promises that
+   * must be resolved for the top, ancestor component to be fully hydrated
+   */
+  ['s-p']?: Promise<void>[];
+  /**
+   * Pending Connects:
+   * A list of {@link HostRef.$onFirstConnectPromise$} promises for descendants that
+   * were already registered with this component (their nearest Stencil ancestor) by
+   * the time this component's own initial `componentWillLoad` was scheduled. Awaited
+   * so this component's `componentWillLoad` can't fire before those descendants'
+   * real `connectedCallback`s have.
+   */
+  ['s-pc']?: Promise<void>[];
+  componentOnReady?: () => Promise<this>;
+}
+/**
+ * A mapping from a TypeScript or JavaScript source file path on disk, to a Stencil {@link Module}.
+ *
+ * It is advised that the key (path) be normalized before storing/retrieving the `Module` to avoid unnecessary lookup
+ * failures.
+ */
+type ModuleMap = Map<string, Module>;
+/**
+ * Stencil's Intermediate Representation (IR) of a module, bundling together
+ * various pieces of information like the classes declared within it, the path
+ * to the original source file, HTML tag names defined in the file, and so on.
+ *
+ * Note that this gets serialized/parsed as JSON and therefore cannot contain a
+ * `Map` or a `Set`.
+ */
+interface Module {
+  cmps: ComponentCompilerMeta[];
+  isMixin: boolean;
+  isExtended: boolean;
+  /**
+   * Indicates this module contains mixin/abstract classes that can be extended by other projects.
+   * These are classes with Stencil static members (properties, states, etc.) but no @Component decorator.
+   */
+  hasExportableMixins: boolean;
+  /**
+   * A collection of modules that a component will need. The modules in this list must have import statements generated
+   * in order for the component to function.
+   */
+  coreRuntimeApis: string[];
+  /**
+   * A collection of modules that a component will need for a specific output target. The modules in this list must
+   * have import statements generated in order for the component to function, but only for a specific output target.
+   */
+  outputTargetCoreRuntimeApis: Partial<Record<OutputTarget['type'], string[]>>;
+  collectionName: string;
+  dtsFilePath: string;
+  excludeFromCollection: boolean;
+  externalImports: string[];
+  htmlAttrNames: string[];
+  htmlTagNames: string[];
+  htmlParts: string[];
+  htmlSlots: string[];
+  isCollectionDependency: boolean;
+  isLegacy: boolean;
+  jsFilePath: string;
+  localImports: string[];
+  /**
+   * Source file paths of functional components that are used in JSX/h() calls.
+   * This is used to ensure htmlTagNames are properly propagated from functional
+   * component dependencies even when they're accessed indirectly (e.g., via barrel files).
+   */
+  functionalComponentDeps: string[];
+  originalImports: string[];
+  originalCollectionComponentPath: string;
+  potentialCmpRefs: string[];
+  sourceFilePath: string;
+  staticSourceFile: any;
+  staticSourceFileText: string;
+  sourceMapPath: string;
+  sourceMapFileText: string;
+  hasVdomAttribute: boolean;
+  hasVdomClass: boolean;
+  hasVdomFunctional: boolean;
+  hasVdomKey: boolean;
+  hasVdomListener: boolean;
+  hasVdomPropOrAttr: boolean;
+  hasVdomPropOrAttrPrefix: boolean;
+  hasVdomRef: boolean;
+  hasVdomRender: boolean;
+  hasVdomStyle: boolean;
+  hasVdomText: boolean;
+  hasVdomXlink: boolean;
+  hasSignalsImport: boolean;
+}
+interface Plugin$1 {
+  name?: string;
+  pluginType?: string;
+  load?: (id: string, context: PluginCtx) => Promise<string> | string;
+  resolveId?: (importee: string, importer: string, context: PluginCtx) => Promise<string> | string;
+  transform?: (sourceText: string, id: string, context: PluginCtx) => Promise<PluginTransformResults> | PluginTransformResults;
+}
+type PluginTransformResults = PluginTransformationDescriptor | string | null;
+interface PluginTransformationDescriptor {
+  code?: string;
+  map?: string;
+  id?: string;
+  diagnostics?: Diagnostic[];
+  dependencies?: string[];
+}
+interface PluginCtx {
+  config: Config;
+  sys: CompilerSystem;
+  fs: InMemoryFileSystem;
+  cache: Cache;
+  diagnostics: Diagnostic[];
+}
+interface PrerenderUrlResults {
+  anchorUrls: string[];
+  diagnostics: Diagnostic[];
+  filePath: string;
+}
+interface PrerenderUrlRequest {
+  appDir: string;
+  buildId: string;
+  baseUrl: string;
+  componentGraphPath: string;
+  devServerHostUrl: string;
+  ssrAppFilePath: string;
+  isDebug: boolean;
+  prerenderConfigPath: string;
+  staticSite: boolean;
+  templateId: string;
+  url: string;
+  writeToFilePath: string;
+}
+/**
+ * Generic node that represents all of the
+ * different types of nodes we'd see when rendering
+ */
+interface RenderNode extends HostElement {
+  /**
+   * Shadow root's host
+   */
+  host?: Element;
+  /**
+   * On Ref Function:
+   * Callback function to be called when the slotted node ref is ready.
+   */
+  ['s-rf']?: (elm: Element) => unknown;
+  /**
+   * Is initially hidden
+   * Whether this node was originally rendered with the `hidden` attribute.
+   *
+   * Used to reset the `hidden` state of a node during slot relocation.
+   */
+  ['s-ih']?: boolean;
+  /**
+   * Is Content Reference Node:
+   * This node is a content reference node.
+   */
+  ['s-cn']?: boolean;
+  /**
+   * Is a `slot` node when `shadow: false` (or `scoped: true`).
+   *
+   * This is a node (either empty text-node or `<slot-fb>` element)
+   * that represents where a `<slot>` is located in the original JSX.
+   */
+  ['s-sr']?: boolean;
+  /**
+   * Slot name of either the slot itself or the slotted node
+   */
+  ['s-sn']?: string;
+  /**
+   * `slot` attribute of a `<slot>` reference rendered as a text node (no fallback content),
+   * since text nodes can't carry real DOM attributes.
+   */
+  ['s-sa']?: string;
+  /**
+   * Host element tag name:
+   * The tag name of the host element that this
+   * node was created in.
+   */
+  ['s-hn']?: string;
+  /**
+   * Slot host tag name:
+   * This is the tag name of the element where this node
+   * has been moved to during slot relocation.
+   *
+   * This allows us to check if the node has been moved and prevent
+   * us from thinking a node _should_ be moved when it may already be in
+   * its final destination.
+   *
+   * This value is set to `undefined` whenever the node is put back into its original location.
+   */
+  ['s-sh']?: string;
+  /**
+   * Original Location Reference:
+   * A reference pointing to the comment
+   * which represents the original location
+   * before it was moved to its slot.
+   */
+  ['s-ol']?: RenderNode;
+  /**
+   * Node reference:
+   * This is a reference from an original location node
+   * back to the node that's been moved around.
+   */
+  ['s-nr']?: PatchedSlotNode | RenderNode;
+  /**
+   * Original Order:
+   * During SSR; a number representing the order of a slotted node
+   */
+  ['s-oo']?: number;
+  /**
+   * Scope Id
+   */
+  ['s-si']?: string;
+  /**
+   * Host Id (hydrate only)
+   */
+  ['s-host-id']?: number;
+  /**
+   * Node Id (hydrate only)
+   */
+  ['s-node-id']?: number;
+  /**
+   * Used to know the components encapsulation.
+   * empty "" for shadow, "c" from scoped
+   */
+  ['s-en']?: '' | /*shadow*/ 'c';
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the internal `childNodes` of the component
+   */
+  readonly __childNodes?: NodeListOf<ChildNode>;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the internal `children` of the component
+   */
+  readonly __children?: HTMLCollectionOf<Element>;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the internal `firstChild` of the component
+   */
+  readonly __firstChild?: ChildNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the internal `lastChild` of the component
+   */
+  readonly __lastChild?: ChildNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the internal `textContent` of the component
+   */
+  __textContent?: string;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * gives access to the original `append` method
+   */
+  __append?: (...nodes: (Node | string)[]) => void;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * gives access to the original `prepend` method
+   */
+  __prepend?: (...nodes: (Node | string)[]) => void;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * gives access to the original `appendChild` method
+   */
+  __appendChild?: <T extends Node>(newChild: T) => T;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * gives access to the original `insertBefore` method
+   */
+  __insertBefore?: <T extends Node>(node: T, child: Node | null) => T;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * gives access to the original `removeChild` method
+   */
+  __removeChild?: <T extends Node>(child: T) => T;
+}
+interface PatchedSlotNode extends Node {
+  /**
+   * Slot name
+   */
+  ['s-sn']?: string;
+  /**
+   * Original Location Reference:
+   * A reference pointing to the comment
+   * which represents the original location
+   * before it was moved to its slot.
+   */
+  ['s-ol']?: RenderNode;
+  /**
+   * Slot host tag name:
+   * This is the tag name of the element where this node
+   * has been moved to during slot relocation.
+   *
+   * This allows us to check if the node has been moved and prevent
+   * us from thinking a node _should_ be moved when it may already be in
+   * its final destination.
+   *
+   * This value is set to `undefined` whenever the node is put back into its original location.
+   */
+  ['s-sh']?: string;
+  /**
+   * Is a `slot` node when `shadow: false` (or `scoped: true`).
+   *
+   * This is a node (either empty text-node or `<slot-fb>` element)
+   * that represents where a `<slot>` is located in the original JSX.
+   */
+  ['s-sr']?: boolean;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the actual `parentNode` of the component
+   */
+  __parentNode?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the actual `nextSibling` of the component
+   */
+  __nextSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the actual `previousSibling` of the component
+   */
+  __previousSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the actual `nextElementSibling` of the component
+   */
+  __nextElementSibling?: RenderNode;
+  /**
+   * On a `scoped: true` component
+   * with `lightDomPatches` flag enabled,
+   * returns the actual `nextElementSibling` of the component
+   */
+  __previousElementSibling?: RenderNode;
+}
+/**
+ * Runtime metadata for a Stencil component
+ */
+interface ComponentRuntimeMeta {
+  /**
+   * This number is used to hold a series of bitflags for various features we
+   * support on components. The flags which this value is intended to store are
+   * documented in the `CMP_FLAGS` enum.
+   */
+  $flags$: number;
+  /**
+   * Just what it says on the tin - the tag name for the component, as set in
+   * the `@Component` decorator.
+   */
+  $tagName$: string;
+  /**
+   * A map of the component's members, which could include fields decorated
+   * with `@Prop`, `@State`, etc as well as methods.
+   */
+  $members$?: ComponentRuntimeMembers;
+  /**
+   * Information about listeners on the component.
+   */
+  $listeners$?: ComponentRuntimeHostListener[];
+  /**
+   * Tuples containing information about `@Prop` fields on the component which
+   * are set to be reflected (i.e. kept in sync) as HTML attributes when
+   * updated.
+   */
+  $attrsToReflect$?: ComponentRuntimeReflectingAttr[];
+  /**
+   * Information about which class members have watchers attached on the component.
+   */
+  $watchers$?: ComponentConstructorChangeHandlers;
+  /**
+   * A bundle ID used for lazy loading.
+   */
+  $lazyBundleId$?: string;
+  /**
+   * Information about which class members have prop > attribute serializers attached on the component.
+   */
+  $serializers$?: ComponentConstructorChangeHandlers;
+  /**
+   * Information about which class members have attribute > prop deserializers attached on the component.
+   */
+  $deserializers$?: ComponentConstructorChangeHandlers;
+}
+/**
+ * A mapping of the names of members on the component to some runtime-specific
+ * information about them.
+ */
+interface ComponentRuntimeMembers {
+  [memberName: string]: ComponentRuntimeMember;
+}
+/**
+ * A tuple with information about a class member that's relevant at runtime.
+ * The fields are:
+ *
+ * 1. A number used to hold bitflags for component members. The bit flags which
+ * this is intended to store are documented in the `MEMBER_FLAGS` enum.
+ * 2. The attribute name to observe.
+ */
+type ComponentRuntimeMember = [number, string?];
+/**
+ * A tuple holding information about a host listener which is relevant at
+ * runtime. The field are:
+ *
+ * 1. A number used to hold bitflags for listeners. The bit flags which this is
+ * intended to store are documented in the `LISTENER_FLAGS` enum.
+ * 2. The event name.
+ * 3. The method name.
+ */
+type ComponentRuntimeHostListener = [number, string, string];
+/**
+ * A tuple containing information about props which are "reflected" at runtime,
+ * meaning that HTML attributes on the component instance are kept in sync with
+ * the prop value.
+ *
+ * The fields are:
+ *
+ * 1. the prop name
+ * 2. the prop attribute.
+ */
+type ComponentRuntimeReflectingAttr = [string, string | undefined];
+/**
+ * A runtime component reference, consistent of either a host element _or_ an
+ * empty object. This is used in particular in a few different places as the
+ * keys in a `WeakMap` which maps {@link HostElement} instances to their
+ * associated {@link HostRef} instance.
+ */
+type RuntimeRef = HostElement | {
+  __s_ghr?: () => HostRef;
+};
+/**
+ * Interface used to track an Element, it's virtual Node (`VNode`), and other data
+ */
+interface HostRef {
+  $ancestorComponent$?: HostElement;
+  $flags$: number;
+  $cmpMeta$: ComponentRuntimeMeta;
+  $hostElement$: HostElement;
+  $instanceValues$?: Map<string, any>;
+  /**
+   * Prop/state changes accumulated since the last render, flushed to
+   * `componentShouldUpdate` once per render cycle.
+   */
+  $queuedPropChanges$?: ComponentShouldUpdateChanges;
+  $signalValues$?: Map<string, import('@preact/signals-core').Signal<any>>;
+  /** Dispose function that tears down all signal effects for this component. */
+  $signalCleanup$?: () => void;
+  $serializerValues$?: Map<string, string>;
+  $lazyInstance$?: ComponentInterface;
+  /**
+   * A list of callback functions called immediately after a lazy component module has been fetched.
+   */
+  $fetchedCbList$?: ((elm: HostElement) => void)[];
+  /**
+   * A promise that gets resolved if `BUILD.asyncLoading` is enabled and after the `componentDidLoad`
+   * and before the `componentDidUpdate` lifecycle events are triggered.
+   */
+  $onReadyPromise$?: Promise<HostElement>;
+  /**
+   * A callback which resolves {@link HostRef.$onReadyPromise$}
+   * @param elm host element
+   */
+  $onReadyResolve$?: (elm: HostElement) => void;
+  /**
+   * A promise which resolves with the host component once it has finished rendering
+   * for the first time. This is primarily used to wait for the first `update` to be
+   * called on a component.
+   */
+  $onInstancePromise$?: Promise<HostElement>;
+  /**
+   * A callback which resolves {@link HostRef.$onInstancePromise$}
+   * @param elm host element
+   */
+  $onInstanceResolve$?: (elm: HostElement) => void;
+  /**
+   * A promise which resolves when the component has finished rendering for the first time.
+   * It is called after {@link HostRef.$onInstancePromise$} resolves.
+   */
+  $onRenderResolve$?: () => void;
+  /**
+   * A promise that resolves once this component's real `connectedCallback` has fired
+   * for the first time. Created lazily - either by a descendant that needs to wait for
+   * this component's connection before firing its own real `connectedCallback`
+   * ({@link HOST_FLAGS.hasFiredConnected}), or by this component registering itself
+   * with its nearest Stencil ancestor's `s-pc` list. This is what lets a component's
+   * real `connectedCallback` (and, transitively, a pending ancestor's initial
+   * `componentWillLoad`) stay ordered correctly regardless of which of an
+   * ancestor/descendant pair's lazy module happens to resolve first.
+   */
+  $onFirstConnectPromise$?: Promise<void>;
+  /**
+   * A callback which resolves {@link HostRef.$onFirstConnectPromise$}
+   */
+  $onFirstConnectResolve$?: () => void;
+  $vnode$?: VNode;
+  $queuedListeners$?: [string, any][];
+  $rmListeners$?: (() => void)[];
+  $modeName$?: string;
+  $renderCount$?: number;
+  /**
+   * Defer connectedCallback until after first render for components with slot relocation.
+   */
+  $deferredConnectedCallback$?: boolean;
+  /**
+   * The number of times this host's lazy component load has failed and been retried.
+   * Used to give up retrying after {@link MAX_LAZY_LOAD_RETRIES} failed attempts.
+   */
+  $loadRetryCount$?: number;
+}
+interface PlatformRuntime {
+  /**
+   * This number is used to hold a series of bitflags for various features we
+   * support within the runtime. The flags which this value is intended to store are
+   * documented in the {@link PLATFORM_FLAGS} enum.
+   */
+  $flags$: number;
+  /**
+   * Holds a map of nodes to be hydrated.
+   */
+  $orgLocNodes$?: Map<string, RenderNode>;
+  /**
+   * Holds the resource url for given platform environment.
+   */
+  $resourcesUrl$: string;
+  /**
+   * The nonce value to be applied to all script/style tags at runtime.
+   * If `null`, the nonce attribute will not be applied.
+   */
+  $nonce$?: string | null;
+  /**
+   * A utility function that executes a given function and returns the result.
+   * @param c The callback function to execute
+   */
+  jmp: (c: Function) => any;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame `requestAnimationFrame`}
+   */
+  raf: (c: FrameRequestCallback) => number;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener `addEventListener`}
+   */
+  ael: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  /**
+   * A wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener `removeEventListener`}
+   */
+  rel: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  /**
+   * A wrapper for creating a {@link https://developer.mozilla.org/docs/Web/API/CustomEvent `CustomEvent`}
+   */
+  ce: (eventName: string, opts?: any) => CustomEvent;
+}
+interface StyleCompiler {
+  modeName: string;
+  styleId: string;
+  styleStr: string;
+  styleIdentifier: string;
+  externalStyles: ExternalStyleCompiler[];
+}
+interface ExternalStyleCompiler {
+  absolutePath: string;
+  relativePath: string;
+  originalComponentPath: string;
+}
+interface ComponentGlobalStyle {
+  /** Absolute path to the CSS file, or null for inline styles */
+  absolutePath: string | null;
+  /** Raw inline CSS string, or null for file-based styles */
+  styleStr: string | null;
+}
+/**
+ * Input CSS to be transformed into ESM
+ */
+interface TransformCssToEsmInput {
+  input: string;
+  module?: 'cjs' | 'esm' | string;
+  file?: string;
+  tag?: string;
+  tags?: string[];
+  addTagTransformers: boolean;
+  encapsulation?: string;
+  /**
+   * The mode under which the CSS will be applied.
+   *
+   * Corresponds to a key used when `@Component`'s `styleUrls` field is an object:
+   * ```ts
+   * @Component({
+   *   tag: 'todo-list',
+   *   styleUrls: {
+   *      ios: 'todo-list.ios.scss',
+   *      md: 'todo-list.md.scss',
+   *   }
+   * })
+   * ```
+   * In the example above, two `TransformCssToEsmInput`s should be created, one for 'ios' and one for 'md' (this field
+   * is not shared by multiple fields, nor is it a composite of multiple modes).
+   */
+  mode?: string;
+  sourceMap?: boolean;
+  minify?: boolean;
+  docs?: boolean;
+  autoprefixer?: any;
+  styleImportData?: string;
+}
+interface TransformCssToEsmOutput {
+  styleText: string;
+  output: string;
+  map: any;
+  diagnostics: Diagnostic[];
+  defaultVarName: string;
+  styleDocs: StyleDoc[];
+  imports: {
+    varName: string;
+    importPath: string;
+  }[];
+}
+interface PackageJsonData {
+  name?: string;
+  version?: string;
+  type?: 'module' | 'commonjs';
+  main?: string;
+  exports?: {
+    [key: string]: string | {
+      [key: string]: string;
+    };
+  };
+  description?: string;
+  bin?: {
+    [key: string]: string;
+  };
+  browser?: string;
+  module?: string;
+  'jsnext:main'?: string;
+  unpkg?: string;
+  collection?: string;
+  types?: string;
+  files?: string[];
+  ['dist-tags']?: {
+    latest: string;
+  };
+  dependencies?: {
+    [moduleId: string]: string;
+  };
+  devDependencies?: {
+    [moduleId: string]: string;
+  };
+  repository?: {
+    type?: string;
+    url?: string;
+  };
+  private?: boolean;
+  scripts?: {
+    [runName: string]: string;
+  };
+  license?: string;
+  keywords?: string[];
+}
+interface AnyHTMLElement extends HTMLElement {
+  [key: string]: any;
+}
+interface SpecPage {
+  /**
+   * Mocked testing `document.body`.
+   */
+  body: HTMLBodyElement;
+  /**
+   * Mocked testing `document`.
+   */
+  doc: HTMLDocument;
+  /**
+   * The first component found within the mocked `document.body`. If a component isn't found, then it'll return `document.body.firstElementChild`.
+   */
+  root?: AnyHTMLElement;
+  /**
+   * Similar to `root`, except returns the component instance. If a root component was not found it'll return `null`.
+   */
+  rootInstance?: any;
+  /**
+   * Convenience function to set `document.body.innerHTML` and `waitForChanges()`. Function argument should be a HTML string.
+   */
+  setContent: (html: string) => Promise<any>;
+  /**
+   * After changes have been made to a component, such as a update to a property or attribute, the test page does not automatically apply the changes. In order to wait for, and apply the update, call `await page.waitForChanges()`.
+   */
+  waitForChanges: () => Promise<any>;
+  /**
+   * Mocked testing `window`.
+   */
+  win: Window;
+  build: BuildConditionals;
+  flushLoadModule: (bundleId?: string) => Promise<any>;
+  flushQueue: () => Promise<any>;
+  styles: Map<string, string>;
+}
+/**
+ * Options pertaining to the creation and functionality of a {@link SpecPage}
+ */
+interface NewSpecPageOptions {
+  /**
+   * An array of components to test. Component classes can be imported into the spec file, then their reference should be added to the `component` array in order to be used throughout the test.
+   */
+  components: any[];
+  /**
+   * Sets the mocked `document.cookie`.
+   */
+  cookie?: string;
+  /**
+   * Sets the mocked `dir` attribute on `<html>`.
+   */
+  direction?: string;
+  /**
+   * If `false`, do not flush the render queue on initial test setup.
+   */
+  flushQueue?: boolean;
+  /**
+   * The initial HTML used to generate the test. This can be useful to construct a collection of components working together, and assign HTML attributes. This value sets the mocked `document.body.innerHTML`.
+   */
+  html?: string;
+  /**
+   * The initial JSX used to generate the test.
+   * Use `template` when you want to initialize a component using their properties, instead of their HTML attributes.
+   * It will render the specified template (JSX) into `document.body`.
+   */
+  template?: () => any;
+  /**
+   * Sets the mocked `lang` attribute on `<html>`.
+   */
+  language?: string;
+  /**
+   * Useful for debugging hydrating components client-side. Sets that the `html` option already includes annotated prerender attributes and comments.
+   */
+  hydrateClientSide?: boolean;
+  /**
+   * Useful for debugging hydrating components server-side. The output HTML will also include prerender annotations.
+   */
+  hydrateServerSide?: boolean;
+  /**
+   * Sets the mocked `document.referrer`.
+   */
+  referrer?: string;
+  /**
+   * When a component is pre-rendered it includes HTML annotations, such as `s-id` attributes and `<!-t.0->` comments. This information is used by client-side hydrating. Default is `false`.
+   */
+  includeAnnotations?: boolean;
+  /**
+   * Sets the mocked browser's `location.href`.
+   */
+  url?: string;
+  /**
+   * Sets the mocked browser's `navigator.userAgent`.
+   */
+  userAgent?: string;
+  /**
+   * By default, any changes to component properties and attributes must `page.waitForChanges()` in order to test the updates. As an option, `autoApplyChanges` continuously flushes the queue on the background. Default is `false`.
+   */
+  autoApplyChanges?: boolean;
+  /**
+   * Set {@link BuildConditionals} for testing based off the metadata of the component under test.
+   * When `true` all `BuildConditionals` will be assigned to the global testing `BUILD` object, regardless of their
+   * value. When `false`, only `BuildConditionals` with a value of `true` will be assigned to the `BUILD` object.
+   */
+  strictBuild?: boolean;
+  /**
+   * Default values to be set on the platform runtime object {@see PlatformRuntime} when creating
+   * the spec page.
+   */
+  platform?: Partial<PlatformRuntime>;
+  /**
+   * Controls how shadow DOM components are serialized during `hydrateServerSide`.
+   * When set to `'scoped'`, shadow DOM components are rendered as scoped light DOM
+   * (matching the behavior of `serializeShadowRoot: 'scoped'` in production SSR).
+   * When set to `false`, shadow DOM components render with a real shadow root.
+   * Default is `false`.
+   */
+  serializeShadowRoot?: 'scoped' | false;
+  /**
+   * Override individual {@link BuildConditionals} for this test. Applied after all other
+   * BUILD setup so these values take final precedence. Useful for testing code paths that
+   * are gated behind a build flag (e.g. `{ signalBacking: true }`).
+   */
+  buildFlags?: Partial<BuildConditionals>;
+}
+type ChildType = VNode | number | string;
+type PropsType = VNodeProdData | number | string | null;
+interface VNodeProdData {
+  key?: string | number;
+  class?: {
+    [className: string]: boolean;
+  } | string;
+  className?: {
+    [className: string]: boolean;
+  } | string;
+  style?: any;
+  [key: string]: any;
+}
+/**
+ * An abstraction to bundle up four methods which _may_ be handled by
+ * dispatching work to workers running in other OS threads or may be called
+ * synchronously. Environment and `CompilerSystem` related setup code will
+ * determine which one, but in either case the call sites for these methods can
+ * dispatch to this shared interface.
+ */
+interface CompilerWorkerContext {
+  optimizeCss(inputOpts: OptimizeCssInput): Promise<OptimizeCssOutput>;
+  prepareModule(input: string, minifyOpts: any): Promise<{
+    output: string;
+    diagnostics: Diagnostic[];
+    sourceMap?: SourceMap$1;
+  }>;
+  prerenderWorker(prerenderRequest: PrerenderUrlRequest): Promise<PrerenderUrlResults>;
+  transformCssToEsm(input: TransformCssToEsmInput): Promise<TransformCssToEsmOutput>;
+}
+//#endregion
 //#region src/testing/testing-logger.d.ts
 declare class TestingLogger implements Logger {
   private isEnabled;
@@ -72,8 +4748,6 @@ declare function mockConfig(overrides?: Partial<UnvalidatedConfig>): Unvalidated
  * @returns the default configuration initialization object, with any overrides applied
  */
 declare const mockLoadConfigInit: (overrides?: Partial<LoadConfigInit>) => LoadConfigInit;
-declare function mockCompilerCtx(config?: ValidatedConfig): CompilerCtx;
-declare function mockBuildCtx(config?: ValidatedConfig, compilerCtx?: CompilerCtx): BuildCtx;
 declare function mockLogger(): TestingLogger;
 /**
  * Create a {@link d.CompilerSystem} entity for testing the compiler.
@@ -98,100 +4772,6 @@ declare function mockWindow(html?: string): Window;
  */
 declare const mockModule: (mod?: Partial<Module>) => Module;
 //#endregion
-//#region src/testing/create-test-compiler.d.ts
-/**
- * Options for creating a test compiler
- */
-interface CreateTestCompilerOptions {
-  /**
-   * Additional configuration overrides for the test compiler
-   */
-  config?: Partial<Config>;
-  /**
-   * Path to a tsconfig.json file. Defaults to {@link TESTING_TSCONFIG}.
-   * To add custom options, create a file that `extends` the base fixture:
-   * `{ "extends": "./path/to/tsconfig.testing.json", "compilerOptions": { ... } }`
-   */
-  tsconfig?: string;
-  /**
-   * Pre-validated compiler setup from {@link prepareTestCompiler}. When
-   * provided, the expensive `loadConfig` step is skipped and a fresh compiler
-   * is created directly from the cached validated config.
-   */
-  setup?: PreparedTestCompiler;
-}
-/**
- * Result of creating a test compiler
- */
-interface TestCompilerResult {
-  /**
-   * The compiler instance ready for testing
-   */
-  compiler: Compiler;
-  /**
-   * The validated configuration used to create the compiler
-   */
-  config: ValidatedConfig;
-  /**
-   * The compiler system instance
-   */
-  sys: CompilerSystem;
-}
-/**
- * A pre-validated compiler configuration that can be reused across multiple
- * `createTestCompiler` calls within the same test suite to avoid repeating
- * the expensive `loadConfig` step.
- *
- * Obtain via {@link prepareTestCompiler} in a `beforeAll` block, then pass as
- * `options.setup` to {@link createTestCompiler} in each `beforeEach`.
- */
-interface PreparedTestCompiler {
-  /** @internal */
-  _validatedConfig: ValidatedConfig;
-  /** @internal */
-  _tsconfigPath: string;
-}
-/**
- * Runs the expensive one-time setup for a test compiler suite: patching the
- * sys, reading and validating the tsconfig. Use this in a `beforeAll` block
- * when a describe block contains multiple tests that each need a fresh
- * compiler, to avoid repeating `loadConfig` on every test.
- *
- * @param options - Configuration options for preparing the test compiler
- * @returns A {@link PreparedTestCompiler} that can be passed to {@link createTestCompiler}
- *
- * @example
- * ```ts
- * let setup: PreparedTestCompiler;
- * beforeAll(async () => { setup = await prepareTestCompiler(); });
- * beforeEach(async () => {
- *   const { compiler } = await createTestCompiler({ setup });
- * });
- * ```
- */
-declare const prepareTestCompiler: (options?: Omit<CreateTestCompilerOptions, "setup">) => Promise<PreparedTestCompiler>;
-/**
- * Creates a test compiler instance with a hybrid filesystem (reads from disk, writes to memory).
- * This utility handles the common setup pattern for compiler tests.
- *
- * When multiple tests in the same suite need independent compiler instances,
- * pass a {@link PreparedTestCompiler} from {@link prepareTestCompiler} as
- * `options.setup` to skip the expensive `loadConfig` step on each test.
- *
- * @param options - Configuration options for the test compiler
- * @returns An object with the compiler, validated config, and system instance
- *
- * @example
- * ```ts
- * const { compiler, config } = await createTestCompiler({
- *   config: { minifyCss: true }
- * });
- * await compiler.fs.writeFile('/src/index.html', '<cmp-a></cmp-a>');
- * const result = await compiler.build();
- * ```
- */
-declare const createTestCompiler: (options?: CreateTestCompilerOptions) => Promise<TestCompilerResult>;
-//#endregion
 //#region src/testing/spec-page.d.ts
 /**
  * Creates a new spec page for unit testing
@@ -251,11 +4831,6 @@ interface ConsoleMocker {
   };
   teardownConsoleMocks: () => void;
 }
-/**
- * the callback that `withSilentWarn` expects to receive. Basically receives a mock
- * as its argument and returns a `Promise`, the value of which is returned by `withSilentWarn`
- * as well.
- */
 //#endregion
 //#region src/testing/platform/testing-build.d.ts
 declare const Build: UserBuildConditionals;
@@ -297,7 +4872,43 @@ declare function writeTask(cb: RafCallback): void;
  */
 declare function readTask(cb: RafCallback): void;
 //#endregion
+//#region src/app-data/index.d.ts
+declare const Env: {};
+//#endregion
+//#region src/runtime/asset-path.d.ts
+declare const getAssetPath: (path: string) => string;
+declare const setAssetPath: (path: string) => string;
+//#endregion
+//#region src/runtime/element.d.ts
+declare const getElement: (ref: any) => HostElement;
+//#endregion
+//#region src/runtime/event-emitter.d.ts
+declare const createEvent: (ref: RuntimeRef, name: string, flags: number) => {
+  emit: (detail: any) => CustomEvent<any>;
+};
+//#endregion
+//#region src/runtime/fragment.d.ts
+declare const Fragment: FunctionalComponent;
+//#endregion
+//#region src/runtime/mixin.d.ts
+type Ctor<T = {}> = new (...args: any[]) => T;
+declare function Mixin(...mixins: ((base: Ctor) => Ctor)[]): Ctor<{}>;
+//#endregion
+//#region src/runtime/mode.d.ts
+declare const getMode: (ref: RuntimeRef) => string;
+//#endregion
+//#region src/runtime/reactive-controller.d.ts
+declare const ReactiveControllerHost: <B extends MixedInCtor<ComponentInterface & HTMLElement>>(Base: B) => B & MixedInCtor<ReactiveControllerHostInterface>;
+//#endregion
+//#region src/runtime/update-component.d.ts
+declare const getRenderingRef: () => any;
+declare const forceUpdate: (ref: any) => boolean;
+//#endregion
+//#region src/runtime/vdom/h.d.ts
+declare const h: (nodeName: any, vnodeData: PropsType, ...children: ChildType[]) => VNode;
+declare const Host: {};
+//#endregion
 //#region src/testing/platform/index.d.ts
 declare const setMode: (handler: (elm: any) => string | undefined | null) => void;
 //#endregion
-export { Build, type CreateTestCompilerOptions, Env, Fragment, Host, Mixin, type PreparedTestCompiler, type SpecPage, type TestCompilerResult, createEvent, createTestCompiler, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockBuildCtx, mockCompilerCtx, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, prepareTestCompiler, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };
+export { Build, Env, Fragment, Host, Mixin, ReactiveControllerHost, type SpecPage, createEvent, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };