@stencil/core 5.0.0-alpha.1 → 5.0.0-alpha.10

package/dist/declarations/stencil-public-compiler.d.ts

@@ -1,2 +1,4374 @@
-import { $ as CustomElementsExportBehavior, $n as JsonDocsValue, $t as PageReloadStrategy, A as CompilerFileWatcher, An as TranspileOptions, At as OptimizeJsInput, B as CompilerSystemRemoveDirectoryOptions, Bn as JsonDocsCustomState, Bt as OutputTargetDistCustomElements, C as CompilerEventDirAdd, Cn as SystemDetails, Ct as Logger, D as CompilerEventFileUpdate, Dn as TransformOptions, Dt as NodeResolveConfig, E as CompilerEventFileDelete, En as TestingRunOptions, Et as MakeDirectoryOptions, F as CompilerRequestResponse, Fn as WorkerMainController, Ft as OutputTargetBuild, G as CompilerSystemWriteFileResults, Gn as JsonDocsMethodReturn, Gt as OutputTargetDocsCustom, H as CompilerSystemRemoveFileResults, Hn as JsonDocsEvent, Ht as OutputTargetDistLazy, I as CompilerSystem, In as WorkerOptions, It as OutputTargetCopy, J as ConfigBundle, Jn as JsonDocsSlot, Jt as OutputTargetDocsReadme, K as CompilerWatcher, Kn as JsonDocsPart, Kt as OutputTargetDocsCustomElementsManifest, L as CompilerSystemCreateDirectoryOptions, Ln as JsonDocMethodParameter, Lt as OutputTargetCustom, M as CompilerFileWatcherEvent, Mn as UnvalidatedConfig, Mt as OutputTarget, N as CompilerFsStats, Nn as ValidatedConfig, Nt as OutputTargetBase, O as CompilerEventFsChange, On as TransformerConfig, Ot as OptimizeCssInput, P as CompilerRequest, Pn as WatcherCloseResults, Pt as OutputTargetBaseNext, Q as Credentials, Qn as JsonDocsUsage, Qt as OutputTargetWww, R as CompilerSystemCreateDirectoryResults, Rn as JsonDocs, Rt as OutputTargetDist, S as CompilerEventBuildStart, Sn as StencilDocsConfig, St as LogLevel, T as CompilerEventFileAdd, Tn as TestingConfig, Tt as LoggerTimeSpan, U as CompilerSystemRenameResults, Un as JsonDocsListener, Ut as OutputTargetDistLazyLoader, V as CompilerSystemRemoveDirectoryResults, Vn as JsonDocsDependencyGraph, Vt as OutputTargetDistGlobalStyles, W as CompilerSystemRenamedPath, Wn as JsonDocsMethod, Wt as OutputTargetDistTypes, X as CopyResults, Xn as JsonDocsTag, Xt as OutputTargetHydrate, Y as ConfigExtras, Yn as JsonDocsStyle, Yt as OutputTargetDocsVscode, Z as CopyTask, Zn as JsonDocsTypeLibrary, Zt as OutputTargetStats, _ as CompilerBuildStart, _n as ServiceWorkerConfig, _t as JestConfig, a as BuildNoChangeResults, an as PrerenderResults, at as EligiblePrimaryPackageOutputTarget, b as CompilerEventBuildLog, bn as StencilConfig, bt as LoadConfigInit, c as BuildOutput, cn as ResolveModuleIdResults, ct as FsStats, d as CacheStorage, dn as RobotsTxtResults, dt as HistoryApiFallback, en as ParsedPath, er as StyleDoc, et as CustomElementsExportBehaviorOptions, f as CliInitOptions, fn as RollupConfig, ft as HmrStyleUpdate, g as CompilerBuildResults, gn as SerializeDocumentOptions, gt as HydratedFlag, h as Compiler, hn as RollupOutputOptions, ht as HydrateFactoryOptions, i as BuildLog, in as PrerenderHydrateOptions, it as Diagnostic, j as CompilerFileWatcherCallback, jn as TranspileResults, jt as OptimizeJsOutput, k as CompilerEventName, kn as TranspileOnlyResults, kt as OptimizeCssOutput, l as BuildResultsComponentGraph, ln as ResolveModuleOptions, lt as FsWatchResults, m as CompileTarget, mn as RollupInterface, mt as HydrateDocumentOptions, n as BuildEmitEvents, nn as PlatformPath, nt as DevServerConfig, o as BuildOnEventRemove, on as PrerenderStartOptions, ot as EmulateConfig, p as CompileScriptMinifyOptions, pn as RollupInputOptions, pt as HotModuleReplacement, q as Config, qn as JsonDocsProp, qt as OutputTargetDocsJson, r as BuildEvents, rn as PrerenderConfig, rt as DevServerEditor, s as BuildOnEvents, sn as ResolveModuleIdOptions, st as EmulateViewport, t as AutoprefixerOptions, tn as Path, tt as DevServer, u as BundlingConfig, un as RobotsTxtOpts, ut as FsWatcherItem, v as CompilerDependency, vn as SitemapXmpOpts, vt as LOG_LEVELS, w as CompilerEventDirDelete, wn as Testing, wt as LoggerLineUpdater, x as CompilerEventBuildNoChange, xn as StencilDevServerConfig, xt as LoadConfigResults, y as CompilerEventBuildFinish, yn as SitemapXmpResults, yt as LazyRequire, z as CompilerSystemRealpathResults, zn as JsonDocsComponent, zt as OutputTargetDistCollection } from "../stencil-public-compiler-C_X1iolo.js";
-export { AutoprefixerOptions, BuildEmitEvents, BuildEvents, BuildLog, BuildNoChangeResults, BuildOnEventRemove, BuildOnEvents, BuildOutput, BuildResultsComponentGraph, BundlingConfig, CacheStorage, CliInitOptions, CompileScriptMinifyOptions, CompileTarget, Compiler, CompilerBuildResults, CompilerBuildStart, CompilerDependency, CompilerEventBuildFinish, CompilerEventBuildLog, CompilerEventBuildNoChange, CompilerEventBuildStart, CompilerEventDirAdd, CompilerEventDirDelete, CompilerEventFileAdd, CompilerEventFileDelete, CompilerEventFileUpdate, CompilerEventFsChange, CompilerEventName, CompilerFileWatcher, CompilerFileWatcherCallback, CompilerFileWatcherEvent, CompilerFsStats, CompilerRequest, CompilerRequestResponse, CompilerSystem, CompilerSystemCreateDirectoryOptions, CompilerSystemCreateDirectoryResults, CompilerSystemRealpathResults, CompilerSystemRemoveDirectoryOptions, CompilerSystemRemoveDirectoryResults, CompilerSystemRemoveFileResults, CompilerSystemRenameResults, CompilerSystemRenamedPath, CompilerSystemWriteFileResults, CompilerWatcher, Config, ConfigBundle, ConfigExtras, CopyResults, CopyTask, Credentials, CustomElementsExportBehavior, CustomElementsExportBehaviorOptions, DevServer, DevServerConfig, DevServerEditor, Diagnostic, EligiblePrimaryPackageOutputTarget, EmulateConfig, EmulateViewport, FsStats, FsWatchResults, FsWatcherItem, HistoryApiFallback, HmrStyleUpdate, HotModuleReplacement, HydrateDocumentOptions, HydrateFactoryOptions, HydratedFlag, JestConfig, JsonDocMethodParameter, JsonDocs, JsonDocsComponent, JsonDocsCustomState, JsonDocsDependencyGraph, JsonDocsEvent, JsonDocsListener, JsonDocsMethod, JsonDocsMethodReturn, JsonDocsPart, JsonDocsProp, JsonDocsSlot, JsonDocsStyle, JsonDocsTag, JsonDocsTypeLibrary, JsonDocsUsage, JsonDocsValue, LOG_LEVELS, LazyRequire, LoadConfigInit, LoadConfigResults, LogLevel, Logger, LoggerLineUpdater, LoggerTimeSpan, MakeDirectoryOptions, NodeResolveConfig, OptimizeCssInput, OptimizeCssOutput, OptimizeJsInput, OptimizeJsOutput, OutputTarget, OutputTargetBase, OutputTargetBaseNext, OutputTargetBuild, OutputTargetCopy, OutputTargetCustom, OutputTargetDist, OutputTargetDistCollection, OutputTargetDistCustomElements, OutputTargetDistGlobalStyles, OutputTargetDistLazy, OutputTargetDistLazyLoader, OutputTargetDistTypes, OutputTargetDocsCustom, OutputTargetDocsCustomElementsManifest, OutputTargetDocsJson, OutputTargetDocsReadme, OutputTargetDocsVscode, OutputTargetHydrate, OutputTargetStats, OutputTargetWww, PageReloadStrategy, ParsedPath, Path, PlatformPath, PrerenderConfig, PrerenderHydrateOptions, PrerenderResults, PrerenderStartOptions, ResolveModuleIdOptions, ResolveModuleIdResults, ResolveModuleOptions, RobotsTxtOpts, RobotsTxtResults, RollupConfig, RollupInputOptions, RollupInterface, RollupOutputOptions, SerializeDocumentOptions, ServiceWorkerConfig, SitemapXmpOpts, SitemapXmpResults, StencilConfig, StencilDevServerConfig, StencilDocsConfig, StyleDoc, SystemDetails, Testing, TestingConfig, TestingRunOptions, TransformOptions, TransformerConfig, TranspileOnlyResults, TranspileOptions, TranspileResults, UnvalidatedConfig, ValidatedConfig, WatcherCloseResults, WorkerMainController, WorkerOptions };
+import { ListenTargetOptions, ResolutionHandler } from "./stencil-public-runtime.js";
+import { InputOptions, SourceMap as RolldownSourceMap } from "rolldown";
+//#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;
+};
+/**
+ * Create an `Ok` given a value. This doesn't do any checking that the value is
+ * 'ok-ish' since doing so would make an undue assumption about what is 'ok'.
+ * Instead, this trusts the user to determine, at the call site, whether
+ * something is `ok()` or `err()`.
+ *
+ * @param value the value to wrap up in an `Ok`
+ * @returns an Ok wrapping the value
+ */
+//#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];
+/**
+ * Collected instructions for all pending filesystem operations saved
+ * to the in-memory filesystem.
+ */
+/**
+ * Results from committing pending filesystem operations
+ */
+interface FsCommitResults {
+  filesCopied: FileCopyTuple[];
+  filesWritten: string[];
+  filesDeleted: string[];
+  dirsDeleted: string[];
+  dirsAdded: string[];
+}
+/**
+ * Given the current state of the in-memory proxy filesystem, collect all of
+ * the changes that need to be made in order to commit the currently-pending
+ * operations (e.g. write, copy, delete) to the OS filesystem.
+ *
+ * @param items the storage data structure for the in-memory FS cache
+ * @returns a collection of all the operations that need to be done
+ */
+//#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[];
+  /**
+   * 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-private.d.ts
+interface SourceMap {
+  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;
+  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;
+  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?: RolldownSourceMap;
+}
+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;
+  hasVdomRef: boolean;
+  hasVdomRender: boolean;
+  hasVdomStyle: boolean;
+  hasVdomText: boolean;
+  hasVdomXlink: boolean;
+  hasSignalsImport: boolean;
+  hasWatchCallback: boolean;
+  htmlAttrNames: string[];
+  htmlTagNames: string[];
+  htmlParts: 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;
+  /**
+   * 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;
+}
+interface EntryModule {
+  entryKey: string;
+  cmps: ComponentCompilerMeta[];
+}
+/**
+ * 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[];
+  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;
+  hasVdomRef: boolean;
+  hasVdomRender: boolean;
+  hasVdomStyle: boolean;
+  hasVdomText: boolean;
+  hasVdomXlink: boolean;
+  hasSignalsImport: boolean;
+}
+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;
+}
+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[];
+}
+/**
+ * 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;
+  }>;
+  prerenderWorker(prerenderRequest: PrerenderUrlRequest): Promise<PrerenderUrlResults>;
+  transformCssToEsm(input: TransformCssToEsmInput): Promise<TransformCssToEsmOutput>;
+}
+//#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.
+   * By default, Stencil does not come with Sass or PostCSS support.
+   * However, either can be added using the plugin array.
+   */
+  plugins?: any[];
+  /**
+   * 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;
+  /**
+   * 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`.
+   */
+  suppressReservedPublicNameWarnings?: boolean;
+  /**
+   * When `true`, Stencil will suppress diagnostics which warn about event names conflicting with native DOM event names. Defaults to `false`.
+   */
+  suppressReservedEventNameWarnings?: 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 integration and bundler edge cases.
+   */
+  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?: any[];
+    after?: any[];
+  };
+  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;
+  /**
+   * 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[];
+  stencilCoreResolvedId?: 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 for framework integration and bundler edge cases.
+ * These are opt-in runtime 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;
+}
+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 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;
+}
+interface DevServerEditor {
+  id: string;
+  name?: string;
+  supported?: boolean;
+  priority?: number;
+}
+type PageReloadStrategy = 'hmr' | 'pageReload' | null;
+/**
+ * The prerender config is used when prerendering a `www` output target.
+ * Within `stencil.config.ts`, set the path to the prerendering
+ * config file path using the `prerenderConfig` property, such as:
+ *
+ * ```tsx
+ * import { Config } from '@stencil/core';
+ * export const config: Config = {
+ *   outputTargets: [
+ *     {
+ *       type: 'www',
+ *       baseUrl: 'https://stenciljs.com/',
+ *       prerenderConfig: './prerender.config.ts',
+ *     }
+ *   ]
+ * };
+ * ```
+ *
+ * The `prerender.config.ts` should export a `config` object using
+ * the `PrerenderConfig` interface.
+ *
+ * ```tsx
+ * import { PrerenderConfig } from '@stencil/core';
+ * export const config: PrerenderConfig = {
+ *   ...
+ * };
+ * ```
+ *
+ * For more info: https://stenciljs.com/docs/static-site-generation
+ */
+interface PrerenderConfig {
+  /**
+   * Run after each `document` is hydrated, but before it is serialized
+   * into an HTML string. Hook is passed the `document` and its `URL`.
+   */
+  afterSsr?(document: Document, url: URL, results: PrerenderUrlResults): any | Promise<any>;
+  /**
+   * Run before each `document` is hydrated. Hook is passed the `document` it's `URL`.
+   */
+  beforeSsr?(document: Document, url: URL): any | Promise<any>;
+  /**
+   * Runs after the template Document object has serialize into an
+   * HTML formatted string. Returns an HTML string to be used as the
+   * base template for all prerendered pages.
+   */
+  afterSerializeTemplate?(html: string): string | Promise<string>;
+  /**
+   * Runs before the template Document object is serialize into an
+   * HTML formatted string. Returns the Document to be serialized which
+   * will become the base template html for all prerendered pages.
+   */
+  beforeSerializeTemplate?(document: Document): Document | Promise<Document>;
+  /**
+   * A hook to be used to generate the canonical `<link>` tag
+   * which goes in the `<head>` of every prerendered page. Returning `null`
+   * will not add a canonical url tag to the page.
+   */
+  canonicalUrl?(url: URL): string | null;
+  /**
+   * While prerendering, crawl same-origin URLs found within `<a href>` elements.
+   * Defaults to `true`.
+   */
+  crawlUrls?: boolean;
+  /**
+   * URLs to start the prerendering from. By default the root URL of `/` is used.
+   */
+  entryUrls?: string[];
+  /**
+   * Return `true` the given `<a>` element should be crawled or not.
+   */
+  filterAnchor?(attrs: {
+    [attrName: string]: string;
+  }, base?: URL): boolean;
+  /**
+   * Return `true` if the given URL should be prerendered or not.
+   */
+  filterUrl?(url: URL, base: URL): boolean;
+  /**
+   * Returns the file path which the prerendered HTML content
+   * should be written to.
+   */
+  filePath?(url: URL, filePath: string): string;
+  /**
+   * Returns the prerender options to use for each individual prerendered page.
+   */
+  prerenderOptions?(url: URL): PrerenderOptions;
+  /**
+   * Returns the template file's content. The template is the base
+   * HTML used for all prerendered pages.
+   */
+  loadTemplate?(filePath: string): string | Promise<string>;
+  /**
+   * Used to normalize the page's URL from a given a string and the current
+   * page's base URL. Largely used when reading an anchor's `href` attribute
+   * value and normalizing it into a `URL`.
+   */
+  normalizeUrl?(href: string, base: URL): URL;
+  robotsTxt?(opts: RobotsTxtOpts): string | RobotsTxtResults;
+  sitemapXml?(opts: SitemapXmpOpts): string | SitemapXmpResults;
+  /**
+   * Static Site Generated (SSG). Does not include Stencil's client-side
+   * JavaScript, custom elements or preload modules.
+   */
+  staticSite?: boolean;
+  /**
+   * If the prerendered URLs should have a trailing "/"" or not. Defaults to `false`.
+   */
+  trailingSlash?: boolean;
+}
+interface SsrDocumentOptions {
+  /**
+   * Build ID that will be added to `<html data-stencil-build="BUILD_ID">`. By default
+   * a random ID will be generated
+   */
+  buildId?: string;
+  /**
+   * Sets the `href` attribute on the `<link rel="canonical">`
+   * tag within the `<head>`. If the value is not defined it will
+   * ensure a canonical link tag is no included in the `<head>`.
+   */
+  canonicalUrl?: string;
+  /**
+   * Include the HTML comments and attributes used by the client-side
+   * JavaScript to read the structure of the HTML and rebuild each
+   * component. Defaults to `true`.
+   */
+  clientSsrAnnotations?: boolean;
+  /**
+   * Constrain `setTimeout()` to 1ms, but still async. Also
+   * only allows `setInterval()` to fire once, also constrained to 1ms.
+   * Defaults to `true`.
+   */
+  constrainTimeouts?: boolean;
+  /**
+   * Sets `document.cookie`
+   */
+  cookie?: string;
+  /**
+   * Sets the `dir` attribute on the top level `<html>`.
+   */
+  direction?: string;
+  /**
+   * Component tag names listed here will not be prerendered, nor will
+   * hydrated on the client-side. Components listed here will be ignored
+   * as custom elements and treated no differently than a `<div>`.
+   */
+  excludeComponents?: string[];
+  /**
+   * Sets the `lang` attribute on the top level `<html>`.
+   */
+  language?: string;
+  /**
+   * Maximum number of components to hydrate on one page. Defaults to `300`.
+   */
+  maxHydrateCount?: number;
+  /**
+   * Sets `document.referrer`
+   */
+  referrer?: string;
+  /**
+   * Removes every `<script>` element found in the `document`. Defaults to `false`.
+   */
+  removeScripts?: boolean;
+  /**
+   * Removes CSS not used by elements within the `document`. Defaults to `true`.
+   */
+  removeUnusedStyles?: boolean;
+  /**
+   * The url the runtime uses for the resources, such as the assets directory.
+   */
+  resourcesUrl?: string;
+  /**
+   * Prints out runtime console logs to the NodeJS process. Defaults to `false`.
+   */
+  runtimeLogging?: boolean;
+  /**
+   * Component tags listed here will only be prerendered or server-side-rendered
+   * and will not be client-side hydrated. This is useful for components that
+   * are not dynamic and do not need to be defined as a custom element within the
+   * browser. For example, a header or footer component would be a good example that
+   * may not require any client-side JavaScript.
+   */
+  staticComponents?: string[];
+  /**
+   * The amount of milliseconds to wait for a page to finish rendering until
+   * a timeout error is thrown. Defaults to `15000`.
+   */
+  timeout?: number;
+  /**
+   * Sets `document.title`.
+   */
+  title?: string;
+  /**
+   * Sets `location.href`
+   */
+  url?: string;
+  /**
+   * Sets `navigator.userAgent`
+   */
+  userAgent?: string;
+  /**
+   * Configure how Stencil serializes the components shadow root.
+   * - If set to `declarative-shadow-dom` the component will be rendered within a Declarative Shadow DOM.
+   * - If set to `scoped` Stencil will render the contents of the shadow root as a `scoped: true` component
+   *   and the shadow DOM will be created during client-side hydration.
+   * - Alternatively you can mix and match the two by providing an object with `declarative-shadow-dom` and `scoped` keys,
+   * the value arrays containing the tag names of the components that should be rendered in that mode.
+   *
+   * Examples:
+   * - `{ 'declarative-shadow-dom': ['my-component-1', 'another-component'], default: 'scoped' }`
+   * Render all components as `scoped` apart from `my-component-1` and `another-component`
+   * -  `{ 'scoped': ['an-option-component'], default: 'declarative-shadow-dom' }`
+   * Render all components within `declarative-shadow-dom` apart from `an-option-component`
+   * - `'scoped'` Render all components as `scoped`
+   * - `false` disables shadow root serialization
+   *
+   * *NOTE* `true` has been deprecated in favor of `declarative-shadow-dom` and `scoped`
+   * @default 'declarative-shadow-dom'
+   */
+  serializeShadowRoot?: 'declarative-shadow-dom' | 'scoped' | {
+    'declarative-shadow-dom'?: string[];
+    scoped?: string[];
+    default: 'declarative-shadow-dom' | 'scoped';
+  } | boolean;
+}
+/**
+ * Backwards compat for v4
+ * @deprecated - use SsrDocumentOptions instead
+ */
+interface HydrateDocumentOptions extends SsrDocumentOptions {}
+interface SerializeDocumentOptions extends SsrDocumentOptions {
+  /**
+   * Runs after the `document` has been hydrated.
+   */
+  afterSsr?(document: any): any | Promise<any>;
+  /**
+   * @deprecated Use `afterSsr` instead.
+   */
+  afterHydrate?(document: any): any | Promise<any>;
+  /**
+   * Sets an approximate line width the HTML should attempt to stay within.
+   * Note that this is "approximate", in that HTML may often not be able
+   * to be split at an exact line width. Additionally, new lines created
+   * is where HTML naturally already has whitespace, such as before an
+   * attribute or spaces between words. Defaults to `100`.
+   */
+  approximateLineWidth?: number;
+  /**
+   * Runs before the `document` has been hydrated.
+   */
+  beforeSsr?(document: any): any | Promise<any>;
+  /**
+   * @deprecated Use `beforeSsr` instead.
+   */
+  beforeHydrate?(document: any): any | Promise<any>;
+  /**
+   * Format the HTML in a nicely indented format.
+   * Defaults to `false`.
+   */
+  prettyHtml?: boolean;
+  /**
+   * Remove quotes from attribute values when possible.
+   * Defaults to `true`.
+   */
+  removeAttributeQuotes?: boolean;
+  /**
+   * Remove the `=""` from standardized `boolean` attributes,
+   * such as `hidden` or `checked`. Defaults to `true`.
+   */
+  removeBooleanAttributeQuotes?: boolean;
+  /**
+   * Remove these standardized attributes when their value is empty:
+   * `class`, `dir`, `id`, `lang`, and `name`, `title`. Defaults to `true`.
+   */
+  removeEmptyAttributes?: boolean;
+  /**
+   * Remove HTML comments. Defaults to `true`.
+   */
+  removeHtmlComments?: boolean;
+  /**
+   * The `fullDocument` flag determines the format of the rendered output. Set it to true to
+   * generate a complete HTML document, or false to render only the component.
+   * @default true
+   */
+  fullDocument?: boolean;
+  /**
+   * Style modes to render the component in.
+   * @see https://stenciljs.com/docs/styling#style-modes
+   */
+  modes?: ResolutionHandler[];
+}
+interface SsrFactoryOptions extends SerializeDocumentOptions {
+  serializeToHtml: boolean;
+  destroyWindow: boolean;
+  destroyDocument: boolean;
+}
+/**
+ * Backwards compat for v4
+ * @deprecated - use SsrFactoryOptions instead
+ */
+interface HydrateFactoryOptions extends SsrFactoryOptions {}
+interface PrerenderOptions extends SerializeDocumentOptions {
+  /**
+   * Adds `<link rel="modulepreload">` for modules that will eventually be requested.
+   * Defaults to `true`.
+   */
+  addModulePreloads?: boolean;
+  /**
+   * Hash the content of assets, such as images, fonts and css files,
+   * and add the hashed value as `v` querystring. For example,
+   * `/assets/image.png?v=abcd1234`. This allows for assets to be
+   * heavily cached by setting the server's response header with
+   * `Cache-Control: max-age=31536000, immutable`.
+   */
+  hashAssets?: 'querystring';
+  /**
+   * External stylesheets from `<link rel="stylesheet">` are instead inlined
+   * into `<style>` elements. Defaults to `false`.
+   */
+  inlineExternalStyleSheets?: boolean;
+  /**
+   * Minify CSS content within `<style>` elements. Defaults to `true`.
+   */
+  minifyStyleElements?: boolean;
+  /**
+   * Minify JavaScript content within `<script>` elements. Defaults to `true`.
+   */
+  minifyScriptElements?: boolean;
+  /**
+   * Entire `document` should be static. This is useful for specific pages that
+   * should be static, rather than the entire site. If the whole site should be static,
+   * use the `staticSite` property on the prerender config instead. If only certain
+   * components should be static then use `staticComponents` instead.
+   */
+  staticDocument?: boolean;
+}
+/**
+ * v4 backwards compat
+ * @deprecated - use PrerenderOptions instead
+ */
+interface PrerenderHydrateOptions extends PrerenderOptions {}
+interface RobotsTxtOpts {
+  urls: string[];
+  sitemapUrl: string;
+  baseUrl: string;
+  dir: string;
+}
+interface RobotsTxtResults {
+  content: string;
+  filePath: string;
+  url: string;
+}
+interface SitemapXmpOpts {
+  urls: string[];
+  baseUrl: string;
+  dir: string;
+}
+interface SitemapXmpResults {
+  content: string;
+  filePath: string;
+  url: string;
+}
+/**
+ * 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 TranspileOnlyResults {
+  diagnostics: Diagnostic[];
+  output: string;
+  sourceMap: any;
+}
+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 CompilerDependency {
+  name: string;
+  version: string;
+  main: string;
+  resources?: string[];
+}
+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;
+}
+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;
+}
+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;
+}
+type OutputTargetBuild = OutputTargetCollection | OutputTargetDistLazy;
+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 | OutputTargetWww | OutputTargetStats;
+/**
+ * A post-validation form of {@link OutputTargetWww} where `serviceWorker`
+ * has been normalized - `true` is resolved to a {@link ServiceWorkerConfig}.
+ */
+type ValidatedOutputTargetWww = Omit<OutputTargetWww, 'serviceWorker'> & {
+  serviceWorker?: ServiceWorkerConfig | null;
+};
+/**
+ * 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;
+}
+/**
+ * Results from an attempt to load a config. The values on this interface
+ * have not yet been validated and are not ready to be used for arbitrary
+ * operations around the codebase.
+ */
+interface LoadConfigResults {
+  config: ValidatedConfig;
+  diagnostics: Diagnostic[];
+  tsconfig: {
+    path: string;
+    compilerOptions: any;
+    files: string[];
+    include: string[];
+    exclude: string[];
+    extends: string;
+  };
+}
+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>;
+}
+interface WorkerOptions {
+  maxConcurrentWorkers?: number;
+  maxConcurrentTasksPerWorker?: number;
+  logger?: Logger;
+}
+interface ResolveModuleOptions {
+  manuallyResolve?: boolean;
+  packageJson?: boolean;
+}
+interface PrerenderStartOptions {
+  buildId?: string;
+  ssrAppFilePath?: string;
+  componentGraph?: BuildResultsComponentGraph;
+  srcIndexHtmlPath?: string;
+}
+interface PrerenderResults {
+  buildId: string;
+  diagnostics: Diagnostic[];
+  urls: number;
+  duration: number;
+  average: number;
+}
+/**
+ * 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 OptimizeJsInput {
+  input: string;
+  filePath?: string;
+  target?: 'latest';
+  pretty?: boolean;
+  sourceMap?: boolean;
+}
+interface OptimizeJsOutput {
+  output: string;
+  sourceMap: any;
+  diagnostics: Diagnostic[];
+}
+interface LazyRequire {
+  ensure(fromDir: string, moduleIds: string[]): Promise<Diagnostic[]>;
+  require(fromDir: string, moduleId: string): any;
+  getModulePath(fromDir: string, moduleId: string): string;
+}
+interface Compiler {
+  build(): Promise<CompilerBuildResults>;
+  createWatcher(): Promise<CompilerWatcher>;
+  destroy(): Promise<void>;
+  sys: CompilerSystem;
+  /**
+   * @internal - Testing only. Access to the in-memory filesystem
+   */
+  fs?: InMemoryFileSystem;
+  /**
+   * @internal - Testing only. Access to the validated configuration
+   */
+  config?: ValidatedConfig;
+  /**
+   * @internal - Testing only. Access to the compiler context
+   */
+  compilerCtx?: CompilerCtx;
+}
+interface CompilerWatcher extends BuildOnEvents {
+  start: () => Promise<WatcherCloseResults>;
+  close: () => Promise<WatcherCloseResults>;
+  request: (data: CompilerRequest) => Promise<CompilerRequestResponse>;
+}
+interface CompilerRequest {
+  path?: string;
+}
+interface WatcherCloseResults {
+  exitCode: number;
+}
+interface CompilerRequestResponse {
+  path: string;
+  nodeModuleId: string;
+  nodeModuleVersion: string;
+  nodeResolvedPath: string;
+  cachePath: string;
+  cacheHit: boolean;
+  content: string;
+  status: number;
+}
+/**
+ * Options for Stencil's string-to-string transpiler
+ */
+interface TranspileOptions {
+  /**
+   * A component can be defined as a custom element by using `customelement`, or the
+   * component class can be exported by using `module`. Default is `customelement`.
+   */
+  componentExport?: 'customelement' | 'module' | string | undefined;
+  /**
+   * Sets how and if component metadata should be assigned on the compiled
+   * component output. The `compilerstatic` value will set the metadata to
+   * a static `COMPILER_META` getter on the component class. This option
+   * is useful for unit testing preprocessors. Default is `null`.
+   */
+  componentMetadata?: 'runtimestatic' | 'compilerstatic' | string | undefined;
+  /**
+   * The actual internal import path for any `@stencil/core` imports.
+   * Default is `@stencil/core/runtime/client/standalone`.
+   */
+  coreImportPath?: string;
+  /**
+   * The current working directory. Default is `/`.
+   */
+  currentDirectory?: string;
+  /**
+   * The filename of the code being compiled. Default is `module.tsx`.
+   */
+  file?: string;
+  /**
+   * Module format to use for the compiled code output, which can be either `esm` or `cjs`.
+   * Default is `esm`.
+   */
+  module?: 'cjs' | 'esm' | string;
+  /**
+   * Sets how and if any properties, methods and events are proxied on the
+   * component class. The `defineproperty` value sets the getters and setters
+   * using Object.defineProperty. Default is `defineproperty`.
+   */
+  proxy?: 'defineproperty' | string | undefined;
+  /**
+   * How component styles should be associated to the component. The `static`
+   * setting will assign the styles as a static getter on the component class.
+   */
+  style?: 'static' | string | undefined;
+  /**
+   * How style data should be added for imports. For example, the `queryparams` value
+   * adds the component's tagname and encapsulation info as querystring parameter
+   * to the style's import, such as `style.css?tag=my-tag&encapsulation=shadow`. This
+   * style data can be used by bundlers to further optimize each component's css.
+   * Set to `null` to not include the querystring parameters. Default is `queryparams`.
+   */
+  styleImportData?: 'queryparams' | string | undefined;
+  /**
+   * The JavaScript source target TypeScript should transpile to. Values can be
+   * `latest`, `esnext`, `es2020`, `es2017`, or `es2015`. Defaults to `latest`.
+   */
+  target?: CompileTarget;
+  /**
+   * Create a source map. Using `inline` will inline the source map into the
+   * code, otherwise the source map will be in the returned `map` property.
+   * Default is `true`.
+   */
+  sourceMap?: boolean | 'inline';
+  /**
+   * Base directory to resolve non-relative module names. Same as the `baseUrl`
+   * TypeScript compiler option: https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping
+   */
+  baseUrl?: string;
+  /**
+   * List of path mapping entries for module names to locations relative to the `baseUrl`.
+   * Same as the `paths` TypeScript compiler option:
+   * https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping
+   */
+  paths?: {
+    [key: string]: string[];
+  };
+  /**
+   * JSX mode for TypeScript compilation. Can be 'react', 'react-jsx', 'react-jsxdev', etc.
+   * Same as the `jsx` TypeScript compiler option.
+   */
+  jsx?: number;
+  /**
+   * Module specifier for JSX factory. Used with automatic JSX runtime.
+   * Same as the `jsxImportSource` TypeScript compiler option.
+   */
+  jsxImportSource?: string;
+  /**
+   * Passed in Stencil Compiler System, otherwise falls back to the internal in-memory only system.
+   */
+  sys?: CompilerSystem;
+  /**
+   * This option enables the same behavior as {@link Config.transformAliasedImportPaths}, transforming paths aliased in
+   * `tsconfig.json` to relative paths.
+   */
+  transformAliasedImportPaths?: boolean;
+  /**
+   * List of tags to transform, by default only the incoming component tag is transformed
+   */
+  tagsToTransform?: string[];
+  /**
+   * Adds `transformTag` calls to css strings and querySelector(All) calls
+   */
+  additionalTagTransformers?: boolean;
+  /**
+   * A map of virtual file paths to source text for modules that the component
+   * under transpilation extends from.  When provided, `transpile()` builds a
+   * minimal multi-file TypeScript program from these sources so that
+   * {@link https://stenciljs.com/docs/component-lifecycle inheritance chains}
+   * can be resolved without requiring the parent files to exist on disk.
+   *
+   * Keys are the same import paths used in the component's `import` statements
+   * (relative paths are resolved against `currentDirectory`).  Values are the
+   * TypeScript/JavaScript source text of that module.
+   *
+   * @example
+   * ```ts
+   * transpile(myComponentCode, {
+   *   extraFiles: {
+   *     './base-component.ts': baseComponentSourceText,
+   *   },
+   * });
+   * ```
+   */
+  extraFiles?: Record<string, string>;
+}
+type CompileTarget = 'latest' | 'esnext' | 'es2020' | 'es2019' | 'es2018' | 'es2017' | 'es2015' | string | undefined;
+interface TranspileResults {
+  code: string;
+  data?: any[];
+  diagnostics: Diagnostic[];
+  imports?: {
+    path: string;
+  }[];
+  inputFileExtension: string;
+  inputFilePath: string;
+  map: any;
+  outputFilePath: string;
+}
+interface TransformOptions {
+  coreImportPath: string;
+  componentExport: 'lazy' | 'module' | 'customelement' | null;
+  componentMetadata: 'runtimestatic' | 'compilerstatic' | null;
+  currentDirectory: string;
+  file?: string;
+  isolatedModules?: boolean;
+  module?: 'cjs' | 'esm';
+  proxy: 'defineproperty' | null;
+  style: 'static' | null;
+  styleImportData: 'queryparams' | null;
+  target?: string;
+  /**
+   * @see {@link TranspileOptions.extraFiles}
+   */
+  extraFiles?: Record<string, string>;
+}
+interface CompileScriptMinifyOptions {
+  target?: CompileTarget;
+  pretty?: boolean;
+}
+interface DevServer extends BuildEmitEvents {
+  address: string;
+  basePath: string;
+  browserUrl: string;
+  protocol: string;
+  port: number;
+  root: string;
+  close(): Promise<void>;
+}
+interface CliInitOptions {
+  args: string[];
+  logger: Logger;
+  sys: CompilerSystem;
+}
+//#endregion
+export { AutoprefixerOptions, BuildEmitEvents, BuildEvents, BuildLog, BuildNoChangeResults, BuildOnEventRemove, BuildOnEvents, BuildOutput, BuildResultsComponentGraph, CacheStorage, CliInitOptions, CompileScriptMinifyOptions, CompileTarget, Compiler, CompilerBuildResults, CompilerBuildStart, CompilerDependency, CompilerEventBuildFinish, CompilerEventBuildLog, CompilerEventBuildNoChange, CompilerEventBuildStart, CompilerEventDirAdd, CompilerEventDirDelete, CompilerEventFileAdd, CompilerEventFileDelete, CompilerEventFileUpdate, CompilerEventFsChange, CompilerEventName, CompilerFileWatcher, CompilerFileWatcherCallback, CompilerFileWatcherEvent, CompilerFsStats, CompilerRequest, CompilerRequestResponse, CompilerSystem, CompilerSystemCreateDirectoryOptions, CompilerSystemCreateDirectoryResults, CompilerSystemRealpathResults, CompilerSystemRemoveDirectoryOptions, CompilerSystemRemoveDirectoryResults, CompilerSystemRemoveFileResults, CompilerSystemRenameResults, CompilerSystemRenamedPath, CompilerSystemWriteFileResults, CompilerWatcher, Config, ConfigBundle, ConfigCompat, CopyResults, CopyTask, Credentials, CustomElementsExportBehavior, CustomElementsExportBehaviorOptions, DevServer, DevServerConfig, DevServerEditor, Diagnostic, FsWatchResults, HistoryApiFallback, HmrStyleUpdate, HotModuleReplacement, HydrateDocumentOptions, HydrateFactoryOptions, HydratedFlag, JsonDocMethodParameter, JsonDocs, JsonDocsComponent, JsonDocsCustomState, JsonDocsDependencyGraph, JsonDocsEvent, JsonDocsListener, JsonDocsMethod, JsonDocsMethodReturn, JsonDocsPart, JsonDocsProp, JsonDocsSlot, JsonDocsStyle, JsonDocsTag, JsonDocsTypeLibrary, JsonDocsUsage, JsonDocsValue, LOG_LEVELS, LazyRequire, LightDomPatches, LoadConfigInit, LoadConfigResults, LogLevel, Logger, LoggerLineUpdater, LoggerTimeSpan, NodeResolveConfig, OptimizeCssInput, OptimizeCssOutput, OptimizeJsInput, OptimizeJsOutput, OutputTarget, OutputTargetAssets, OutputTargetBase, OutputTargetBaseNext, OutputTargetBuild, OutputTargetCollection, OutputTargetCopy, OutputTargetCustom, OutputTargetDistLazy, OutputTargetDocsCustom, OutputTargetDocsCustomElementsManifest, OutputTargetDocsJson, OutputTargetDocsReadme, OutputTargetDocsVscode, OutputTargetGlobalStyle, OutputTargetLoaderBundle, OutputTargetSsr, OutputTargetSsrWasm, OutputTargetStandalone, OutputTargetStats, OutputTargetTypes, OutputTargetWww, PageReloadStrategy, ParsedPath, PlatformPath, PrerenderConfig, PrerenderHydrateOptions, PrerenderOptions, PrerenderResults, PrerenderStartOptions, ResolveModuleIdOptions, ResolveModuleIdResults, ResolveModuleOptions, RobotsTxtOpts, RobotsTxtResults, RolldownConfig, SerializeDocumentOptions, ServiceWorkerConfig, SitemapXmpOpts, SitemapXmpResults, SsrDocumentOptions, SsrFactoryOptions, StencilConfig, StencilDevServerConfig, StencilDocsConfig, StyleDoc, SystemDetails, TransformOptions, TranspileOnlyResults, TranspileOptions, TranspileResults, UnvalidatedConfig, ValidatedConfig, ValidatedOutputTargetWww, WatcherCloseResults, WorkerMainController, WorkerOptions };