@stencil/core 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/compiler/browser.d.ts

@@ -0,0 +1,1534 @@
+import ts from "typescript";
+import "rolldown";
+//#region src/declarations/stencil-public-docs.d.ts
+interface JsonDocMethodParameter {
+  name: string;
+  type: string;
+  docs: string;
+}
+//#endregion
+//#region src/declarations/stencil-public-runtime.d.ts
+type ListenTargetOptions = 'body' | 'document' | 'window';
+//#endregion
+//#region src/declarations/stencil-public-compiler.d.ts
+type PageReloadStrategy = 'hmr' | 'pageReload' | null;
+/**
+ * Common system used by the compiler. All file reads, writes, access, etc. will all use
+ * this system. Additionally, throughout each build, the compiler will use an internal
+ * in-memory file system as to prevent unnecessary fs reads and writes. At the end of each
+ * build all actions the in-memory fs performed will be written to disk using this system.
+ * A NodeJS based system will use APIs such as `fs` and `crypto`, and a web-based system
+ * will use in-memory Maps and browser APIs. Either way, the compiler itself is unaware
+ * of the actual platform it's being ran on top of.
+ */
+interface CompilerSystem {
+  name: 'node' | 'in-memory';
+  version: string;
+  events?: BuildEvents;
+  details?: SystemDetails;
+  /**
+   * Add a callback which will be ran when destroy() is called.
+   */
+  addDestroy(cb: () => void): void;
+  /**
+   * Always returns a boolean, does not throw.
+   */
+  access(p: string): Promise<boolean>;
+  /**
+   * SYNC! Always returns a boolean, does not throw.
+   */
+  accessSync(p: string): boolean;
+  applyGlobalPatch?(fromDir: string): Promise<void>;
+  applyPrerenderGlobalPatch?(opts: {
+    devServerHostUrl: string;
+    window: any;
+  }): void;
+  cacheStorage?: CacheStorage;
+  checkVersion?: (logger: Logger, currentVersion: string) => Promise<() => void>;
+  copy?(copyTasks: Required<CopyTask>[], srcDir: string): Promise<CopyResults>;
+  /**
+   * Always returns a boolean if the files were copied or not. Does not throw.
+   */
+  copyFile(src: string, dst: string): Promise<boolean>;
+  /**
+   * Used to destroy any listeners, file watchers or child processes.
+   */
+  destroy(): Promise<void>;
+  /**
+   * Does not throw.
+   */
+  createDir(p: string, opts?: CompilerSystemCreateDirectoryOptions): Promise<CompilerSystemCreateDirectoryResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  createDirSync(p: string, opts?: CompilerSystemCreateDirectoryOptions): CompilerSystemCreateDirectoryResults;
+  homeDir(): string;
+  /**
+   * Used to determine if the current context of the terminal is TTY.
+   */
+  isTTY(): boolean;
+  /**
+   * Each platform has a different way to dynamically import modules.
+   */
+  dynamicImport?(p: string): Promise<any>;
+  /**
+   * Creates the worker controller for the current system.
+   *
+   * @param maxConcurrentWorkers the max number of concurrent workers to
+   * support
+   * @returns a worker controller appropriate for the current platform (node.js)
+   */
+  createWorkerController?(maxConcurrentWorkers: number): WorkerMainController;
+  encodeToBase64(str: string): string;
+  /**
+   * process.exit()
+   */
+  exit(exitCode: number): Promise<void>;
+  /**
+   * Optionally provide a fetch() function rather than using the built-in fetch().
+   * First arg is a url string or Request object (RequestInfo).
+   * Second arg is the RequestInit. Returns the Response object
+   */
+  fetch?(input: string | any, init?: any): Promise<any>;
+  /**
+   * Generates a sha1 digest encoded as HEX
+   */
+  generateContentHash?(content: string | any, length?: number): Promise<string>;
+  /**
+   * Generates a sha1 digest encoded as HEX from a file path
+   */
+  generateFileHash?(filePath: string | any, length?: number): Promise<string>;
+  /**
+   * Get the current directory.
+   */
+  getCurrentDirectory(): string;
+  /**
+   * The compiler's executing path.
+   */
+  getCompilerExecutingPath(): string;
+  getEnvironmentVar?(key: string): string;
+  /**
+   * Gets the absolute file path when for a dependency module.
+   */
+  getLocalModulePath(opts: {
+    rootDir: string;
+    moduleId: string;
+    path: string;
+  }): string;
+  /**
+   * Gets the full url when requesting a dependency module to fetch from a CDN.
+   */
+  getRemoteModuleUrl(opts: {
+    moduleId: string;
+    path?: string;
+    version?: string;
+  }): string;
+  /**
+   * Async glob task. Only available in NodeJS compiler system.
+   */
+  glob?(pattern: string, options: {
+    cwd?: string;
+    nodir?: boolean;
+    [key: string]: any;
+  }): Promise<string[]>;
+  /**
+   * The number of logical processors available to run threads on the user's computer (cpus).
+   */
+  hardwareConcurrency: number;
+  /**
+   * Tests if the path is a symbolic link or not. Always resolves a boolean. Does not throw.
+   */
+  isSymbolicLink(p: string): Promise<boolean>;
+  lazyRequire?: LazyRequire;
+  nextTick(cb: () => void): void;
+  /**
+   * Normalize file system path.
+   */
+  normalizePath(p: string): string;
+  onProcessInterrupt?(cb: () => void): void;
+  parseYarnLockFile?: (content: string) => {
+    type: 'success' | 'merge' | 'conflict';
+    object: any;
+  };
+  platformPath: PlatformPath;
+  /**
+   * All return paths are full normalized paths, not just the basenames. Always returns an array, does not throw.
+   */
+  readDir(p: string): Promise<string[]>;
+  /**
+   * SYNC! All return paths are full normalized paths, not just the basenames. Always returns an array, does not throw.
+   */
+  readDirSync(p: string): string[];
+  /**
+   * Returns undefined if file is not found. Does not throw.
+   */
+  readFile(p: string): Promise<string>;
+  readFile(p: string, encoding: 'utf8'): Promise<string>;
+  readFile(p: string, encoding: 'binary'): Promise<any>;
+  /**
+   * SYNC! Returns undefined if file is not found. Does not throw.
+   */
+  readFileSync(p: string, encoding?: string): string;
+  /**
+   * Does not throw.
+   */
+  realpath(p: string): Promise<CompilerSystemRealpathResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  realpathSync(p: string): CompilerSystemRealpathResults;
+  /**
+   * Remove a callback which will be ran when destroy() is called.
+   */
+  removeDestroy(cb: () => void): void;
+  /**
+   * Rename old path to new path. Does not throw.
+   */
+  rename(oldPath: string, newPath: string): Promise<CompilerSystemRenameResults>;
+  resolveModuleId?(opts: ResolveModuleIdOptions): Promise<ResolveModuleIdResults>;
+  resolvePath(p: string): string;
+  /**
+   * Does not throw.
+   */
+  removeDir(p: string, opts?: CompilerSystemRemoveDirectoryOptions): Promise<CompilerSystemRemoveDirectoryResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  removeDirSync(p: string, opts?: CompilerSystemRemoveDirectoryOptions): CompilerSystemRemoveDirectoryResults;
+  /**
+   * Does not throw.
+   */
+  removeFile(p: string): Promise<CompilerSystemRemoveFileResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  removeFileSync(p: string): CompilerSystemRemoveFileResults;
+  setupCompiler?: (c: {
+    ts: any;
+  }) => void;
+  /**
+   * Always returns an object. Does not throw. Check for "error" property if there's an error.
+   */
+  stat(p: string): Promise<CompilerFsStats>;
+  /**
+   * SYNC! Always returns an object. Does not throw. Check for "error" property if there's an error.
+   */
+  statSync(p: string): CompilerFsStats;
+  tmpDirSync(): string;
+  watchDirectory?(p: string, callback: CompilerFileWatcherCallback, recursive?: boolean): CompilerFileWatcher;
+  /**
+   * A `watchFile` implementation in order to hook into the rest of the {@link CompilerSystem} implementation that is
+   * used when running Stencil's compiler in "watch mode".
+   *
+   * It is analogous to TypeScript's `watchFile`  implementation.
+   *
+   * Note, this function may be called for full builds of Stencil projects by the TypeScript compiler. It should not
+   * assume that it will only be called in watch mode.
+   *
+   * This function should not perform any file watcher registration itself. Each `path` provided to it when called
+   * should already have been registered as a file to watch.
+   *
+   * @param path the path to the file that is being watched
+   * @param callback a callback to invoke when a file that is being watched has changed in some way
+   * @returns an object with a method for unhooking the file watcher from the system
+   */
+  watchFile?(path: string, callback: CompilerFileWatcherCallback): CompilerFileWatcher;
+  /**
+   * How many milliseconds to wait after a change before calling watch callbacks.
+   */
+  watchTimeout?: number;
+  /**
+   * Does not throw.
+   */
+  writeFile(p: string, content: string): Promise<CompilerSystemWriteFileResults>;
+  /**
+   * SYNC! Does not throw.
+   */
+  writeFileSync(p: string, content: string): CompilerSystemWriteFileResults;
+}
+interface ParsedPath {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+}
+interface PlatformPath {
+  normalize(p: string): string;
+  join(...paths: string[]): string;
+  resolve(...pathSegments: string[]): string;
+  isAbsolute(p: string): boolean;
+  relative(from: string, to: string): string;
+  dirname(p: string): string;
+  basename(p: string, ext?: string): string;
+  extname(p: string): string;
+  parse(p: string): ParsedPath;
+  sep: string;
+  delimiter: string;
+  posix: any;
+  win32: any;
+}
+interface ResolveModuleIdOptions {
+  moduleId: string;
+  containingFile?: string;
+  exts?: string[];
+  packageFilter?: (pkg: any, pkgFile: string) => any;
+}
+interface ResolveModuleIdResults {
+  moduleId: string;
+  resolveId: string;
+  pkgData: {
+    name: string;
+    version: string;
+    [key: string]: any;
+  };
+  pkgDirPath: string;
+}
+/**
+ * A controller which provides for communication and coordination between
+ * threaded workers.
+ */
+interface WorkerMainController<T extends Record<string, (...args: any[]) => Promise<any>> = Record<string, (...args: any[]) => Promise<any>>> {
+  /**
+   * Send a given set of arguments to a worker
+   */
+  send<K extends keyof T>(methodName: K, ...args: Parameters<T[K]>): ReturnType<T[K]>;
+  /**
+   * Handle a particular method
+   *
+   * @param name of the method to be passed to a worker
+   * @returns a Promise wrapping the results
+   */
+  handler<K extends keyof T>(name: K): T[K];
+  /**
+   * Destroy the worker represented by this instance, rejecting all outstanding
+   * tasks and killing the child process.
+   */
+  destroy(): void;
+  /**
+   * The current setting for the max number of workers
+   */
+  maxWorkers: number;
+}
+interface CopyResults {
+  diagnostics: Diagnostic[];
+  filePaths: string[];
+  dirPaths: string[];
+}
+interface SystemDetails {
+  cpuModel: string;
+  freemem(): number;
+  platform: 'darwin' | 'windows' | 'linux' | '';
+  release: string;
+  totalmem: number;
+}
+interface BuildOnEvents {
+  on(cb: (eventName: CompilerEventName, data: any) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileAdd, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileDelete, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventFileUpdate, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventDirAdd, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventDirDelete, cb: (path: string) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildStart, cb: (buildStart: CompilerBuildStart) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildFinish, cb: (buildResults: CompilerBuildResults) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildLog, cb: (buildLog: BuildLog) => void): BuildOnEventRemove;
+  on(eventName: CompilerEventBuildNoChange, cb: () => void): BuildOnEventRemove;
+}
+interface BuildEmitEvents {
+  emit(eventName: CompilerEventName, path: string): void;
+  emit(eventName: CompilerEventFileAdd, path: string): void;
+  emit(eventName: CompilerEventFileDelete, path: string): void;
+  emit(eventName: CompilerEventFileUpdate, path: string): void;
+  emit(eventName: CompilerEventDirAdd, path: string): void;
+  emit(eventName: CompilerEventDirDelete, path: string): void;
+  emit(eventName: CompilerEventBuildStart, buildStart: CompilerBuildStart): void;
+  emit(eventName: CompilerEventBuildFinish, buildResults: CompilerBuildResults): void;
+  emit(eventName: CompilerEventBuildNoChange, buildNoChange: BuildNoChangeResults): void;
+  emit(eventName: CompilerEventBuildLog, buildLog: BuildLog): void;
+  emit(eventName: CompilerEventFsChange, fsWatchResults: FsWatchResults): void;
+}
+interface FsWatchResults {
+  dirsAdded: string[];
+  dirsDeleted: string[];
+  filesUpdated: string[];
+  filesAdded: string[];
+  filesDeleted: string[];
+}
+interface BuildLog {
+  buildId: number;
+  messages: string[];
+  progress: number;
+}
+interface BuildNoChangeResults {
+  buildId: number;
+  noChange: boolean;
+}
+interface CompilerBuildResults {
+  buildId: number;
+  componentGraph?: BuildResultsComponentGraph;
+  components: ComponentCompilerMeta[];
+  diagnostics: Diagnostic[];
+  dirsAdded: string[];
+  dirsDeleted: string[];
+  duration: number;
+  filesAdded: string[];
+  filesChanged: string[];
+  filesDeleted: string[];
+  filesUpdated: string[];
+  hasError: boolean;
+  hasSuccessfulBuild: boolean;
+  hmr?: HotModuleReplacement;
+  ssrAppFilePath?: string;
+  isRebuild: boolean;
+  namespace: string;
+  fsNamespace: string;
+  outputs: BuildOutput[];
+  rootDir: string;
+  srcDir: string;
+  timestamp: string;
+}
+interface BuildResultsComponentGraph {
+  [scopeId: string]: string[];
+}
+interface BuildOutput {
+  type: string;
+  files: string[];
+}
+interface HotModuleReplacement {
+  componentsUpdated?: string[];
+  excludeHmr?: string[];
+  externalStylesUpdated?: string[];
+  imagesUpdated?: string[];
+  indexHtmlUpdated?: boolean;
+  inlineStylesUpdated?: HmrStyleUpdate[];
+  reloadStrategy: PageReloadStrategy;
+  scriptsAdded?: string[];
+  scriptsDeleted?: string[];
+  serviceWorkerUpdated?: boolean;
+  versionId?: string;
+}
+interface HmrStyleUpdate {
+  styleId: string;
+  styleTag: string;
+  styleText: string;
+}
+type BuildOnEventRemove = () => boolean;
+interface BuildEvents extends BuildOnEvents, BuildEmitEvents {
+  unsubscribeAll(): void;
+}
+interface CompilerBuildStart {
+  buildId: number;
+  timestamp: string;
+}
+/**
+ * A type describing a function to call when an event is emitted by a file watcher
+ * @param fileName the path of the file tied to event
+ * @param eventKind a variant describing the type of event that was emitter (added, edited, etc.)
+ */
+type CompilerFileWatcherCallback = (fileName: string, eventKind: CompilerFileWatcherEvent) => void;
+/**
+ * A type describing the different types of events that Stencil expects may happen when a file being watched is altered
+ * in some way
+ */
+type CompilerFileWatcherEvent = CompilerEventFileAdd | CompilerEventFileDelete | CompilerEventFileUpdate | CompilerEventDirAdd | CompilerEventDirDelete;
+type CompilerEventName = CompilerEventFsChange | CompilerEventFileUpdate | CompilerEventFileAdd | CompilerEventFileDelete | CompilerEventDirAdd | CompilerEventDirDelete | CompilerEventBuildStart | CompilerEventBuildFinish | CompilerEventBuildNoChange | CompilerEventBuildLog;
+type CompilerEventFsChange = 'fsChange';
+type CompilerEventFileUpdate = 'fileUpdate';
+type CompilerEventFileAdd = 'fileAdd';
+type CompilerEventFileDelete = 'fileDelete';
+type CompilerEventDirAdd = 'dirAdd';
+type CompilerEventDirDelete = 'dirDelete';
+type CompilerEventBuildStart = 'buildStart';
+type CompilerEventBuildFinish = 'buildFinish';
+type CompilerEventBuildLog = 'buildLog';
+type CompilerEventBuildNoChange = 'buildNoChange';
+interface CompilerFileWatcher {
+  close(): void | Promise<void>;
+}
+interface CompilerFsStats {
+  /**
+   * If it's a directory. `false` if there was an error.
+   */
+  isDirectory: boolean;
+  /**
+   * If it's a file. `false` if there was an error.
+   */
+  isFile: boolean;
+  /**
+   * If it's a symlink. `false` if there was an error.
+   */
+  isSymbolicLink: boolean;
+  /**
+   * The size of the file in bytes. `0` for directories or if there was an error.
+   */
+  size: number;
+  /**
+   * The timestamp indicating the last time this file was modified expressed in milliseconds since the POSIX Epoch.
+   */
+  mtimeMs?: number;
+  /**
+   * Error if there was one, otherwise `null`. `stat` and `statSync` do not throw errors but always returns this interface.
+   */
+  error: any;
+}
+interface CompilerSystemCreateDirectoryOptions {
+  /**
+   * Indicates whether parent directories should be created.
+   * @default false
+   */
+  recursive?: boolean;
+  /**
+   * A file mode. If a string is passed, it is parsed as an octal integer. If not specified
+   * @default 0o777.
+   */
+  mode?: number;
+}
+interface CompilerSystemCreateDirectoryResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  newDirs: string[];
+  error: any;
+}
+interface CompilerSystemRemoveDirectoryOptions {
+  /**
+   * Indicates whether child files and subdirectories should be removed.
+   * @default false
+   */
+  recursive?: boolean;
+}
+interface CompilerSystemRemoveDirectoryResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  removedDirs: string[];
+  removedFiles: string[];
+  error: any;
+}
+interface CompilerSystemRenameResults extends CompilerSystemRenamedPath {
+  renamed: CompilerSystemRenamedPath[];
+  oldDirs: string[];
+  oldFiles: string[];
+  newDirs: string[];
+  newFiles: string[];
+  error: any;
+}
+interface CompilerSystemRenamedPath {
+  oldPath: string;
+  newPath: string;
+  isFile: boolean;
+  isDirectory: boolean;
+}
+interface CompilerSystemRealpathResults {
+  path: string;
+  error: any;
+}
+interface CompilerSystemRemoveFileResults {
+  basename: string;
+  dirname: string;
+  path: string;
+  error: any;
+}
+interface CompilerSystemWriteFileResults {
+  path: string;
+  error: any;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+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 LazyRequire {
+  ensure(fromDir: string, moduleIds: string[]): Promise<Diagnostic[]>;
+  require(fromDir: string, moduleId: string): any;
+  getModulePath(fromDir: string, moduleId: string): string;
+}
+/**
+ * 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`. Set to `null` to leave the
+   * class's own export as-is (used with `componentMetadata: 'compilerstatic'` for
+   * unit-testing preprocessors). Default is `customelement`.
+   */
+  componentExport?: 'customelement' | 'module' | string | null | 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.
+   * Set to `null` to skip the assignment entirely (and leave any `styleUrl`
+   * import unresolved) - useful for unit-testing preprocessors that don't
+   * need real stylesheets.
+   */
+  style?: 'static' | string | null | 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;
+  /**
+   * Callback used to resolve parent-class source for inheritance-chain analysis.
+   * Called when a component's `extends` clause references a class from another
+   * module.  Return the resolved absolute path and source text of that module,
+   * or `null` to skip inheritance resolution for that specifier.
+   *
+   * @example
+   * ```ts
+   * transpile(myComponentCode, {
+   *   resolveImport: (specifier, importer) => {
+   *     const resolved = require.resolve(specifier, { paths: [path.dirname(importer)] });
+   *     return { code: fs.readFileSync(resolved, 'utf8'), path: resolved };
+   *   },
+   * });
+   * ```
+   */
+  resolveImport?: (specifier: string, importer: string) => {
+    code: string;
+    path: string;
+  } | null;
+  /**
+   * When `true` class declarations at the end of a `@Component` inheritance chain
+   * * that have no `extends` clause * will get `extends HTMLElement` injected, and a minimal
+   * `constructor() { super(); }`. Any stencil static meta-getters are also stripped.
+   */
+  transformAsBaseClass?: boolean;
+  /**
+   * Overrides for Stencil's BUILD feature flags in the generated output.
+   * When set, a BUILD mutation statement is prepended to the compiled code so
+   * that the specified flags take effect for this component at runtime.
+   */
+  buildOverrides?: BuildOverrides;
+}
+/**
+ * Keys of {@link BuildConditionals} that can be meaningfully overridden at
+ * transpile time — config-driven flags that are not derived from component
+ * scanning or runtime environment detection.
+ */
+type BuildOverrideKeys = 'hotModuleReplacement' | 'signalBacking' | 'vdomSignals' | 'lightDomPatches' | 'slotChildNodes' | 'slotCloneNode' | 'slotDomMutations' | 'slotTextContent' | 'lifecycleDOMEvents' | 'initializeNextTick';
+/**
+ * Subset of Stencil's BUILD feature flags that can be overridden at transpile
+ * time. Derived from {@link BuildConditionals} via `Pick` so the field list
+ * and types stay in sync with the authoritative definition.
+ */
+type BuildOverrides = Pick<BuildConditionals, BuildOverrideKeys>;
+type CompileTarget = 'latest' | 'esnext' | 'es2022' | 'es2020' | 'es2019' | 'es2018' | 'es2017' | string | undefined;
+interface TranspileResults {
+  code: string;
+  data?: any[];
+  diagnostics: Diagnostic[];
+  imports?: {
+    path: string;
+  }[];
+  inputFileExtension: string;
+  inputFilePath: string;
+  map: any;
+  outputFilePath: string;
+}
+//#endregion
+//#region src/declarations/stencil-private.d.ts
+interface PrintLine {
+  lineIndex: number;
+  lineNumber: number;
+  text: string;
+  errorCharStart: number;
+  errorLength?: number;
+}
+interface BuildFeatures {
+  style: boolean;
+  mode: boolean;
+  formAssociated: boolean;
+  shadowDom: boolean;
+  shadowDelegatesFocus: boolean;
+  shadowModeClosed: boolean;
+  shadowSlotAssignmentManual: boolean;
+  shadowClonable: boolean;
+  shadowSerializable: boolean;
+  scoped: boolean;
+  /**
+   * Every component has a render function
+   */
+  allRenderFn: boolean;
+  /**
+   * At least one component has a render function
+   */
+  hasRenderFn: boolean;
+  vdomRender: boolean;
+  vdomAttribute: boolean;
+  vdomClass: boolean;
+  vdomFunctional: boolean;
+  vdomKey: boolean;
+  vdomListener: boolean;
+  vdomPropOrAttr: boolean;
+  /** True when at least one component uses the explicit `attr:`/`prop:` JSX prefix. */
+  vdomPropOrAttrPrefix: boolean;
+  vdomRef: boolean;
+  vdomStyle: boolean;
+  vdomText: boolean;
+  vdomXlink: boolean;
+  vdomSignals: boolean;
+  slotRelocation: boolean;
+  patchAll: boolean;
+  patchChildren: boolean;
+  patchClone: boolean;
+  patchInsert: boolean;
+  slot: boolean;
+  svg: boolean;
+  element: boolean;
+  event: boolean;
+  hostListener: boolean;
+  hostListenerTargetWindow: boolean;
+  hostListenerTargetDocument: boolean;
+  hostListenerTargetBody: boolean;
+  hostListenerTarget: boolean;
+  method: boolean;
+  prop: boolean;
+  propChangeCallback: boolean;
+  propMutable: boolean;
+  state: boolean;
+  member: boolean;
+  updatable: boolean;
+  propBoolean: boolean;
+  propNumber: boolean;
+  propString: boolean;
+  serializer: boolean;
+  deserializer: boolean;
+  lifecycle: boolean;
+  asyncLoading: boolean;
+  observeAttribute: boolean;
+  reflect: boolean;
+  taskQueue: boolean;
+}
+interface BuildConditionals extends Partial<BuildFeatures> {
+  hotModuleReplacement?: boolean;
+  isDebug?: boolean;
+  isTesting?: boolean;
+  isDev?: boolean;
+  devTools?: boolean;
+  invisiblePrehydration?: boolean;
+  hydrateServerSide?: boolean;
+  hydrateClientSide?: boolean;
+  lifecycleDOMEvents?: boolean;
+  cssAnnotations?: boolean;
+  lazyLoad?: boolean;
+  profile?: boolean;
+  constructableCSS?: boolean;
+  /** True when `compat.lightDomPatches === true` - enables `applyLightDomPatches` shortcut. */
+  lightDomPatches?: boolean;
+  /** Patch `childNodes`/`children` getters on light-dom slotted components. */
+  slotChildNodes?: boolean;
+  /** Patch `cloneNode()` on light-dom slotted components. */
+  slotCloneNode?: boolean;
+  /** Patch `appendChild`/`insertBefore`/`removeChild` on light-dom slotted components. */
+  slotDomMutations?: boolean;
+  /** Patch `textContent` on light-dom slotted components. */
+  slotTextContent?: boolean;
+  hydratedAttribute?: boolean;
+  hydratedClass?: boolean;
+  hydratedSelectorName?: string;
+  /** True when a global-style input contains `@import "stencil-hydrate"` - suppresses dynamic style injection in the loader. */
+  staticHydrationStyles?: boolean;
+  initializeNextTick?: boolean;
+  asyncQueue?: boolean;
+  additionalTagTransformers?: boolean | 'prod';
+  signalBacking?: boolean;
+  /** True when JSX signal bypass is active - text nodes and attributes backed by Signal objects update the DOM directly. Auto-enabled when `signalBacking: true`. */
+  vdomSignals?: boolean;
+}
+/**
+ * Record, for a specific component, whether or not it has various features
+ * which need to be handled correctly in the compilation pipeline.
+ *
+ * Note: this must be serializable to JSON.
+ */
+interface ComponentCompilerFeatures {
+  hasAttribute: boolean;
+  hasAttributeChangedCallbackFn: boolean;
+  hasComponentWillLoadFn: boolean;
+  hasComponentDidLoadFn: boolean;
+  hasComponentShouldUpdateFn: boolean;
+  hasComponentWillUpdateFn: boolean;
+  hasComponentDidUpdateFn: boolean;
+  hasComponentWillRenderFn: boolean;
+  hasComponentDidRenderFn: boolean;
+  hasConnectedCallbackFn: boolean;
+  hasDeserializer: boolean;
+  hasDisconnectedCallbackFn: boolean;
+  hasElement: boolean;
+  hasEvent: boolean;
+  hasLifecycle: boolean;
+  hasListener: boolean;
+  hasListenerTarget: boolean;
+  hasListenerTargetWindow: boolean;
+  hasListenerTargetDocument: boolean;
+  hasListenerTargetBody: boolean;
+  hasMember: boolean;
+  hasMethod: boolean;
+  hasMode: boolean;
+  hasModernPropertyDecls: boolean;
+  hasPatchAll: boolean;
+  hasPatchChildren: boolean;
+  hasPatchClone: boolean;
+  hasPatchInsert: boolean;
+  hasProp: boolean;
+  hasPropBoolean: boolean;
+  hasPropNumber: boolean;
+  hasPropString: boolean;
+  hasPropMutable: boolean;
+  hasReflect: boolean;
+  hasRenderFn: boolean;
+  hasSerializer: boolean;
+  hasSlot: boolean;
+  hasState: boolean;
+  hasStyle: boolean;
+  hasVdomAttribute: boolean;
+  hasVdomClass: boolean;
+  hasVdomFunctional: boolean;
+  hasVdomKey: boolean;
+  hasVdomListener: boolean;
+  hasVdomPropOrAttr: boolean;
+  hasVdomPropOrAttrPrefix: boolean;
+  hasVdomRef: boolean;
+  hasVdomRender: boolean;
+  hasVdomStyle: boolean;
+  hasVdomText: boolean;
+  hasVdomXlink: boolean;
+  hasSignalsImport: boolean;
+  hasWatchCallback: boolean;
+  htmlAttrNames: string[];
+  htmlTagNames: string[];
+  htmlParts: string[];
+  htmlSlots: string[];
+  isUpdateable: boolean;
+  /**
+   * A plain component is one that doesn't have:
+   * - any members decorated with `@Prop()`, `@State()`, `@Element()`, `@Method()`
+   * - any methods decorated with `@Listen()`
+   * - any styles
+   * - any lifecycle methods, including `render()`
+   */
+  isPlain: boolean;
+  /**
+   * A collection of tag names of web components that a component references in its JSX/h() function
+   */
+  potentialCmpRefs: string[];
+}
+/**
+ * Metadata about a given component
+ *
+ * Note: must be serializable to JSON!
+ */
+interface ComponentCompilerMeta extends ComponentCompilerFeatures {
+  assetsDirs: CompilerAssetDir[];
+  /**
+   * The name to which an `ElementInternals` object (the return value of
+   * `HTMLElement.attachInternals`) should be attached at runtime. If this is
+   * `null` then `attachInternals` should not be called.
+   */
+  attachInternalsMemberName: string | null;
+  /**
+   * Custom states to initialize on the ElementInternals.states CustomStateSet.
+   * These are defined via @AttachInternals({ states: {...} }).
+   */
+  attachInternalsCustomStates: ComponentCompilerCustomState[];
+  componentClassName: string;
+  /**
+   * A list of web component tag names that are either:
+   * - directly referenced in a Stencil component's JSX/h() function
+   * - are referenced by a web component that is directly referenced in a Stencil component's JSX/h() function
+   */
+  dependencies: string[];
+  /**
+   * A list of web component tag names that either:
+   * - directly reference the current component directly in their JSX/h() function
+   * - indirectly/transitively reference the current component directly in their JSX/h() function
+   */
+  dependents: string[];
+  deserializers: ComponentCompilerChangeHandler[];
+  /**
+   * A list of web component tag names that are directly referenced in a Stencil component's JSX/h() function
+   */
+  directDependencies: string[];
+  /**
+   * A list of web component tag names that the current component directly in their JSX/h() function
+   */
+  directDependents: string[];
+  docs: CompilerJsDoc;
+  doesExtend: boolean;
+  elementRef: string;
+  encapsulation: Encapsulation;
+  events: ComponentCompilerEvent[];
+  excludeFromCollection: boolean;
+  /**
+   * Whether or not the component is form-associated
+   */
+  formAssociated: boolean;
+  internal: boolean;
+  isCollectionDependency: boolean;
+  jsFilePath: string;
+  listeners: ComponentCompilerListener[];
+  methods: ComponentCompilerMethod[];
+  properties: ComponentCompilerProperty[];
+  serializers: ComponentCompilerChangeHandler[];
+  shadowDelegatesFocus: boolean;
+  /**
+   * Whether the shadow root is preserved when the host element is deep-cloned via
+   * `Node.cloneNode(true)`. Only applicable when encapsulation is 'shadow'.
+   */
+  shadowClonable: boolean;
+  /**
+   * Whether the shadow root is marked serializable for `Element.getHTML({ serializableShadowRoots: true })`.
+   * Only applicable when encapsulation is 'shadow'.
+   */
+  shadowSerializable: boolean;
+  /**
+   * Shadow DOM mode. 'open' (default) or 'closed'.
+   * Only applicable when encapsulation is 'shadow'.
+   */
+  shadowMode: 'open' | 'closed' | null;
+  /**
+   * Slot assignment mode for shadow DOM. 'manual', enables imperative slotting
+   * using HTMLSlotElement.assign(). Only applicable when encapsulation is 'shadow'.
+   */
+  slotAssignment: 'manual' | null;
+  /**
+   * Per-component slot patches for non-shadow DOM components.
+   * These patches enable proper slot behavior without native Shadow DOM.
+   * Only applicable when encapsulation is 'none' or 'scoped'.
+   */
+  patches: ComponentPatches | null;
+  sourceFilePath: string;
+  sourceMapPath: string;
+  states: ComponentCompilerState[];
+  styleDocs: CompilerStyleDoc[];
+  styles: StyleCompiler[];
+  globalStyles: ComponentGlobalStyle[];
+  tagName: string;
+  virtualProperties: ComponentCompilerVirtualProperty[];
+  watchers: ComponentCompilerChangeHandler[];
+}
+/**
+ * The supported style encapsulation modes on a Stencil component:
+ * 1. 'shadow' - native Shadow DOM
+ * 2. 'scoped' - encapsulated styles and polyfilled slots
+ * 3. 'none' - a basic HTML element
+ */
+type Encapsulation = 'shadow' | 'scoped' | 'none';
+/**
+ * Per-component slot patches for non-shadow DOM components.
+ * These enable proper slot behavior when not using native Shadow DOM.
+ */
+interface ComponentPatches {
+  /** Apply all slot patches (equivalent to lightDomPatches) */
+  all?: boolean;
+  /** Patch child node accessors (children, firstChild, lastChild, etc.) */
+  children?: boolean;
+  /** Patch cloneNode() to handle slotted content */
+  clone?: boolean;
+  /** Patch appendChild(), insertBefore(), etc. for slot relocation */
+  insert?: boolean;
+}
+/**
+ * Intermediate Representation (IR) of a static property on a Stencil component
+ */
+interface ComponentCompilerStaticProperty {
+  mutable: boolean;
+  optional: boolean;
+  required: boolean;
+  type: ComponentCompilerPropertyType;
+  complexType: ComponentCompilerPropertyComplexType;
+  attribute?: string;
+  reflect?: boolean;
+  docs: CompilerJsDoc;
+  defaultValue?: string;
+  getter: boolean;
+  setter: boolean;
+  ogPropName?: string;
+}
+/**
+ * Intermediate Representation (IR) of a property on a Stencil component
+ */
+interface ComponentCompilerProperty extends ComponentCompilerStaticProperty {
+  name: string;
+  internal: boolean;
+}
+interface ComponentCompilerVirtualProperty {
+  name: string;
+  type: string;
+  docs: string;
+}
+type ComponentCompilerPropertyType = 'any' | 'string' | 'boolean' | 'number' | 'unknown';
+/**
+ * Information about a type used in a Stencil component or exported
+ * from a Stencil project.
+ */
+interface ComponentCompilerPropertyComplexType {
+  /**
+   * The string of the original type annotation in the Stencil source code
+   */
+  original: string;
+  /**
+   * A 'resolved' type, where e.g. imported types have been resolved and inlined
+   *
+   * For instance, an annotation like `(foo: Foo) => string;` will be
+   * converted to `(foo: { foo: string }) => string;`.
+   */
+  resolved: string;
+  /**
+   * A record of the types which were referenced in the assorted type
+   * annotation in the original source file.
+   */
+  references: ComponentCompilerTypeReferences;
+  /**
+   * @internal TypeScript AST node used for semantic type analysis during compilation.
+   * Not serialized, only used internally for improved type renaming logic.
+   */
+  _astNode?: any;
+}
+/**
+ * A record of `ComponentCompilerTypeReference` entities.
+ *
+ * Each key in this record is intended to be the names of the types used by a component. However, this is not enforced
+ * by the type system (I.E. any string can be used as a key).
+ *
+ * Note any key can be a user defined type or a TypeScript standard type.
+ */
+type ComponentCompilerTypeReferences = Record<string, ComponentCompilerTypeReference>;
+/**
+ * Describes a reference to a type used by a component.
+ */
+interface ComponentCompilerTypeReference {
+  /**
+   * A type may be defined:
+   * - locally (in the same file as the component that uses it)
+   * - globally
+   * - by importing it into a file (and is defined elsewhere)
+   */
+  location: 'local' | 'global' | 'import';
+  /**
+   * The path to the type reference, if applicable (global types should not need a path associated with them)
+   */
+  path?: string;
+  /**
+   * An ID for this type which is unique within a Stencil project.
+   */
+  id: string;
+  /**
+   * Whether this type was imported as a default import (e.g., `import MyEnum from './my-enum'`)
+   * vs a named import (e.g., `import { MyType } from './my-type'`)
+   */
+  isDefault?: boolean;
+  /**
+   * The name used in the import statement (before any user-defined alias).
+   * For `import { XAxisOption as moo }`, this would be "XAxisOption".
+   * This is the name exported by the source module.
+   */
+  referenceLocation?: string;
+}
+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 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;
+}
+/**
+ * A record of `TypesMemberNameData` entities.
+ *
+ * Each key in this record is intended to be the path to a file that declares one or more types used by a component.
+ * However, this is not enforced by the type system - users of this interface should not make any assumptions regarding
+ * the format of the path used as a key (relative vs. absolute)
+ */
+interface TypesImportData {
+  [key: string]: TypesMemberNameData[];
+}
+/**
+ * A type describing how Stencil may alias an imported type to avoid naming collisions when performing operations such
+ * as generating `components.d.ts` files.
+ */
+interface TypesMemberNameData {
+  /**
+   * The original name of the import before any aliasing was applied.
+   *
+   * i.e. if a component imports a type as follows:
+   * `import { MyType as MyCoolType } from './my-type';`
+   *
+   * the `originalName` would be 'MyType'. If the import is not aliased, then `originalName` and `localName` will be the same.
+   */
+  originalName: string;
+  /**
+   * The name of the type as it's used within a file.
+   */
+  localName: string;
+  /**
+   * An alias that Stencil may apply to the `localName` to avoid naming collisions. This name does not appear in the
+   * file that is using `localName`.
+   */
+  importName?: string;
+  /**
+   * Whether this is a default import/export (e.g., `import MyEnum from './my-enum'`)
+   * vs a named import/export (e.g., `import { MyType } from './my-type'`)
+   */
+  isDefault?: boolean;
+}
+interface TypesModule {
+  isDep: boolean;
+  tagName: string;
+  tagNameAsPascal: string;
+  htmlElementName: string;
+  component: string;
+  jsx: string;
+  element: string;
+  explicitAttributes: string | null;
+  explicitProperties: string | null;
+  requiredProps: Array<{
+    name: string;
+    type: string;
+    complexType?: ComponentCompilerProperty['complexType'];
+  }> | null;
+}
+//#endregion
+//#region src/compiler/sys/stencil-sys.d.ts
+/**
+ * Create an in-memory `CompilerSystem` object, optionally using a supplied
+ * logger instance
+ *
+ * This particular system being an 'in-memory' `CompilerSystem` is intended for
+ * use in the browser. In most cases, for instance when using Stencil through
+ * the CLI, a Node.js-specific `CompilerSystem` will be used instead. See
+ * {@link CompilerSystem} for more details.
+ *
+ * @param c an object wrapping a logger instance
+ * @returns a complete CompilerSystem, ready for use!
+ */
+declare const createSystem: (c?: {
+  logger?: Logger;
+}) => CompilerSystem;
+//#endregion
+//#region src/utils/shadow-css.d.ts
+declare const scopeCss: (cssText: string, scopeId: string, commentOriginalSelector: boolean) => string;
+//#endregion
+//#region src/compiler/transpile.d.ts
+/**
+ * The `transpile()` function inputs source code as a string, with various options
+ * within the second argument. The function is stateless and returns a `Promise` of the
+ * results, including diagnostics and the transpiled code. The `transpile()` function
+ * does not handle any bundling, minifying, or precompiling any CSS preprocessing like
+ * Sass or Less. The `transpileSync()` equivalent is available so the same function
+ * it can be called synchronously. However, TypeScript must be already loaded within
+ * the global for it to work, where as the async `transpile()` function will load
+ * TypeScript automatically.
+ *
+ * Since TypeScript is used, the source code will transpile from TypeScript to JavaScript,
+ * and does not require Babel presets. Additionally, the results includes an `imports`
+ * array of all the import paths found in the source file. The transpile options can be
+ * used to set the `module` format, such as `cjs`, and JavaScript `target` version, such
+ * as `es2017`.
+ *
+ * @param code the code to transpile
+ * @param opts options for the transpilation process
+ * @returns a Promise wrapping the results of the transpilation
+ */
+declare const transpile: (code: string, opts?: TranspileOptions) => Promise<TranspileResults>;
+/**
+ * Synchronous equivalent of the `transpile()` function. When used in a browser
+ * environment, TypeScript must already be available globally, where as the async
+ * `transpile()` function will load TypeScript automatically.
+ *
+ * @param code the code to transpile
+ * @param opts options for the transpilation process
+ * @returns the results of the transpilation
+ */
+declare const transpileSync: (code: string, opts?: TranspileOptions) => TranspileResults;
+//#endregion
+//#region src/compiler/types/generate-component-types.d.ts
+/**
+ * Generate a string based on the types that are defined within a component
+ * @param cmp the metadata for the component that a type definition string is generated for
+ * @param typeImportData locally/imported/globally used type names, which may be used to prevent naming collisions
+ * @param areTypesInternal `true` if types being generated are for a project's internal purposes, `false` otherwise
+ * @param signalBacking `true` if the component is using signal backing for its props; includes the signals map on the element interface
+ * @returns the generated types string alongside additional metadata
+ */
+declare const generateComponentTypes: (cmp: ComponentCompilerMeta, typeImportData: TypesImportData, areTypesInternal: boolean, signalBacking?: boolean) => TypesModule;
+//#endregion
+export { type BuildOverrides, type CompilerSystem, type Diagnostic, type Logger, type TranspileOptions, type TranspileResults, createSystem, generateComponentTypes, scopeCss, transpile, transpileSync, ts };