rolldown 0.10.2 → 0.10.3

package/dist/shared/rolldown.1ea1dc1e.d.mts

@@ -1,1160 +0,0 @@
-// utils
-type NullValue$1 = null | undefined | void
-type MaybePromise$2<T> = T | Promise<T>
-
-type PartialNull<T> = {
-  [P in keyof T]: T[P] | null
-}
-
-interface RollupError extends RollupLog {
-  name?: string
-  stack?: string
-  watchFiles?: string[]
-}
-
-interface RollupLog {
-  binding?: string
-  cause?: unknown
-  code?: string
-  exporter?: string
-  frame?: string
-  hook?: string
-  id?: string
-  ids?: string[]
-  loc?: {
-    column: number
-    file?: string
-    line: number
-  }
-  message: string
-  meta?: any
-  names?: string[]
-  plugin?: string
-  pluginCode?: unknown
-  pos?: number
-  reexporter?: string
-  stack?: string
-  url?: string
-}
-
-type LogLevel = 'warn' | 'info' | 'debug'
-type LogLevelOption = LogLevel | 'silent'
-
-type SourceMapSegment =
-  | [number]
-  | [number, number, number, number]
-  | [number, number, number, number, number]
-
-interface ExistingDecodedSourceMap {
-  file?: string
-  readonly mappings: SourceMapSegment[][]
-  names: string[]
-  sourceRoot?: string
-  sources: string[]
-  sourcesContent?: (string | null)[]
-  version: number
-  x_google_ignoreList?: number[]
-}
-
-interface ExistingRawSourceMap {
-  file?: string
-  mappings: string
-  names: string[]
-  sourceRoot?: string
-  sources: string[]
-  sourcesContent?: (string | null)[]
-  version: number
-  x_google_ignoreList?: number[]
-}
-
-type DecodedSourceMapOrMissing =
-  | {
-      missing: true
-      plugin: string
-    }
-  | (ExistingDecodedSourceMap & { missing?: false })
-
-interface SourceMap {
-  file: string
-  mappings: string
-  names: string[]
-  sources: string[]
-  sourcesContent: (string | null)[]
-  version: number
-  toString(): string
-  toUrl(): string
-}
-
-type SourceMapInput$1 =
-  | ExistingRawSourceMap
-  | string
-  | null
-  | { mappings: '' }
-
-interface ModuleOptions {
-  assertions: Record<string, string>
-  meta: CustomPluginOptions
-  moduleSideEffects: boolean | 'no-treeshake'
-  syntheticNamedExports: boolean | string
-}
-
-interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
-  ast?: AcornNode
-  code: string
-  map?: SourceMapInput$1
-}
-
-interface TransformModuleJSON {
-  ast?: AcornNode
-  code: string
-  // note if plugins use new this.cache to opt-out auto transform cache
-  customTransformCache: boolean
-  originalCode: string
-  originalSourcemap: ExistingDecodedSourceMap | null
-  sourcemapChain: DecodedSourceMapOrMissing[]
-  transformDependencies: string[]
-}
-
-interface ModuleJSON extends TransformModuleJSON, ModuleOptions {
-  ast: AcornNode
-  dependencies: string[]
-  id: string
-  resolvedIds: ResolvedIdMap
-  transformFiles: EmittedFile[] | undefined
-}
-
-interface PluginCache {
-  delete(id: string): boolean
-  get<T = any>(id: string): T
-  has(id: string): boolean
-  set<T = any>(id: string, value: T): void
-}
-
-type LoggingFunction = (
-  log: RollupLog | string | (() => RollupLog | string),
-) => void
-
-interface MinimalPluginContext {
-  debug: LoggingFunction
-  error: (error: RollupError | string) => never
-  info: LoggingFunction
-  meta: PluginContextMeta
-  warn: LoggingFunction
-}
-
-interface EmittedAsset {
-  fileName?: string
-  name?: string
-  needsCodeReference?: boolean
-  source?: string | Uint8Array
-  type: 'asset'
-}
-
-interface EmittedChunk {
-  fileName?: string
-  id: string
-  implicitlyLoadedAfterOneOf?: string[]
-  importer?: string
-  name?: string
-  preserveSignature?: PreserveEntrySignaturesOption
-  type: 'chunk'
-}
-
-interface EmittedPrebuiltChunk {
-  code: string
-  exports?: string[]
-  fileName: string
-  map?: SourceMap
-  sourcemapFileName?: string
-  type: 'prebuilt-chunk'
-}
-
-type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk
-
-type EmitFile = (emittedFile: EmittedFile) => string
-
-interface ModuleInfo extends ModuleOptions {
-  ast: AcornNode | null
-  code: string | null
-  dynamicImporters: readonly string[]
-  dynamicallyImportedIdResolutions: readonly ResolvedId[]
-  dynamicallyImportedIds: readonly string[]
-  exportedBindings: Record<string, string[]> | null
-  exports: string[] | null
-  hasDefaultExport: boolean | null
-  /** @deprecated Use `moduleSideEffects` instead */
-  hasModuleSideEffects: boolean | 'no-treeshake'
-  id: string
-  implicitlyLoadedAfterOneOf: readonly string[]
-  implicitlyLoadedBefore: readonly string[]
-  importedIdResolutions: readonly ResolvedId[]
-  importedIds: readonly string[]
-  importers: readonly string[]
-  isEntry: boolean
-  isExternal: boolean
-  isIncluded: boolean | null
-}
-
-type GetModuleInfo = (moduleId: string) => ModuleInfo | null
-
-interface CustomPluginOptions {
-  [plugin: string]: any
-}
-
-type LoggingFunctionWithPosition = (
-  log: RollupLog | string | (() => RollupLog | string),
-  pos?: number | { column: number; line: number },
-) => void
-
-interface PluginContext$1 extends MinimalPluginContext {
-  addWatchFile: (id: string) => void
-  cache: PluginCache
-  debug: LoggingFunction
-  emitFile: EmitFile
-  error: (error: RollupError | string) => never
-  getFileName: (fileReferenceId: string) => string
-  getModuleIds: () => IterableIterator<string>
-  getModuleInfo: GetModuleInfo
-  getWatchFiles: () => string[]
-  info: LoggingFunction
-  load: (
-    options: { id: string; resolveDependencies?: boolean } & Partial<
-      PartialNull<ModuleOptions>
-    >,
-  ) => Promise<ModuleInfo>
-  /** @deprecated Use `this.getModuleIds` instead */
-  moduleIds: IterableIterator<string>
-  parse: (input: string, options?: any) => AcornNode
-  resolve: (
-    source: string,
-    importer?: string,
-    options?: {
-      assertions?: Record<string, string>
-      custom?: CustomPluginOptions
-      isEntry?: boolean
-      skipSelf?: boolean
-    },
-  ) => Promise<ResolvedId | null>
-  setAssetSource: (
-    assetReferenceId: string,
-    source: string | Uint8Array,
-  ) => void
-  warn: LoggingFunction
-}
-
-interface PluginContextMeta {
-  rollupVersion: string
-  watchMode: boolean
-}
-
-interface ResolvedId extends ModuleOptions {
-  external: boolean | 'absolute'
-  id: string
-  resolvedBy: string
-}
-
-interface ResolvedIdMap {
-  [key: string]: ResolvedId
-}
-
-interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
-  external?: boolean | 'absolute' | 'relative'
-  id: string
-  resolvedBy?: string
-}
-
-type ResolveIdResult = string | NullValue$1 | false | PartialResolvedId
-
-type ResolveIdHook = (
-  this: PluginContext$1,
-  source: string,
-  importer: string | undefined,
-  options: {
-    assertions: Record<string, string>
-    custom?: CustomPluginOptions
-    isEntry: boolean
-  },
-) => ResolveIdResult
-
-type ShouldTransformCachedModuleHook = (
-  this: PluginContext$1,
-  options: {
-    ast: AcornNode
-    code: string
-    id: string
-    meta: CustomPluginOptions
-    moduleSideEffects: boolean | 'no-treeshake'
-    resolvedSources: ResolvedIdMap
-    syntheticNamedExports: boolean | string
-  },
-) => boolean | NullValue$1
-
-type IsExternal = (
-  source: string,
-  importer: string | undefined,
-  isResolved: boolean,
-) => boolean
-
-type HasModuleSideEffects = (id: string, external: boolean) => boolean
-
-type LoadResult = SourceDescription | string | NullValue$1
-
-type LoadHook = (this: PluginContext$1, id: string) => LoadResult
-
-interface TransformPluginContext extends PluginContext$1 {
-  debug: LoggingFunctionWithPosition
-  error: (
-    error: RollupError | string,
-    pos?: number | { column: number; line: number },
-  ) => never
-  getCombinedSourcemap: () => SourceMap
-  info: LoggingFunctionWithPosition
-  warn: LoggingFunctionWithPosition
-}
-
-type TransformResult = string | NullValue$1 | Partial<SourceDescription>
-
-type TransformHook = (
-  this: TransformPluginContext,
-  code: string,
-  id: string,
-) => TransformResult
-
-type ModuleParsedHook = (this: PluginContext$1, info: ModuleInfo) => void
-
-type RenderChunkHook = (
-  this: PluginContext$1,
-  code: string,
-  chunk: RenderedChunk$1,
-  options: NormalizedOutputOptions$1,
-  meta: { chunks: Record<string, RenderedChunk$1> },
-) => { code: string; map?: SourceMapInput$1 } | string | NullValue$1
-
-type ResolveDynamicImportHook = (
-  this: PluginContext$1,
-  specifier: string | AcornNode,
-  importer: string,
-  options: { assertions: Record<string, string> },
-) => ResolveIdResult
-
-type ResolveImportMetaHook = (
-  this: PluginContext$1,
-  property: string | null,
-  options: { chunkId: string; format: InternalModuleFormat; moduleId: string },
-) => string | NullValue$1
-
-type ResolveFileUrlHook = (
-  this: PluginContext$1,
-  options: {
-    chunkId: string
-    fileName: string
-    format: InternalModuleFormat
-    moduleId: string
-    referenceId: string
-    relativePath: string
-  },
-) => string | NullValue$1
-
-type AddonHookFunction = (
-  this: PluginContext$1,
-  chunk: RenderedChunk$1,
-) => string | Promise<string>
-type AddonHook = string | AddonHookFunction
-
-type ChangeEvent = 'create' | 'update' | 'delete'
-type WatchChangeHook = (
-  this: PluginContext$1,
-  id: string,
-  change: { event: ChangeEvent },
-) => void
-
-interface OutputBundle {
-  [fileName: string]: OutputAsset | OutputChunk
-}
-
-interface FunctionPluginHooks {
-  augmentChunkHash: (this: PluginContext$1, chunk: RenderedChunk$1) => string | void
-  buildEnd: (this: PluginContext$1, error?: Error) => void
-  buildStart: (this: PluginContext$1, options: NormalizedInputOptions) => void
-  closeBundle: (this: PluginContext$1) => void
-  closeWatcher: (this: PluginContext$1) => void
-  generateBundle: (
-    this: PluginContext$1,
-    options: NormalizedOutputOptions$1,
-    bundle: OutputBundle,
-    isWrite: boolean,
-  ) => void
-  load: LoadHook
-  moduleParsed: ModuleParsedHook
-  onLog: (
-    this: MinimalPluginContext,
-    level: LogLevel,
-    log: RollupLog,
-  ) => boolean | NullValue$1
-  options: (
-    this: MinimalPluginContext,
-    options: InputOptions$1,
-  ) => InputOptions$1 | NullValue$1
-  outputOptions: (
-    this: PluginContext$1,
-    options: OutputOptions$1,
-  ) => OutputOptions$1 | NullValue$1
-  renderChunk: RenderChunkHook
-  renderDynamicImport: (
-    this: PluginContext$1,
-    options: {
-      customResolution: string | null
-      format: InternalModuleFormat
-      moduleId: string
-      targetModuleId: string | null
-    },
-  ) => { left: string; right: string } | NullValue$1
-  renderError: (this: PluginContext$1, error?: Error) => void
-  renderStart: (
-    this: PluginContext$1,
-    outputOptions: NormalizedOutputOptions$1,
-    inputOptions: NormalizedInputOptions,
-  ) => void
-  resolveDynamicImport: ResolveDynamicImportHook
-  resolveFileUrl: ResolveFileUrlHook
-  resolveId: ResolveIdHook
-  resolveImportMeta: ResolveImportMetaHook
-  shouldTransformCachedModule: ShouldTransformCachedModuleHook
-  transform: TransformHook
-  watchChange: WatchChangeHook
-  writeBundle: (
-    this: PluginContext$1,
-    options: NormalizedOutputOptions$1,
-    bundle: OutputBundle,
-  ) => void
-}
-
-type OutputPluginHooks =
-  | 'augmentChunkHash'
-  | 'generateBundle'
-  | 'outputOptions'
-  | 'renderChunk'
-  | 'renderDynamicImport'
-  | 'renderError'
-  | 'renderStart'
-  | 'resolveFileUrl'
-  | 'resolveImportMeta'
-  | 'writeBundle'
-
-type SyncPluginHooks =
-  | 'augmentChunkHash'
-  | 'onLog'
-  | 'outputOptions'
-  | 'renderDynamicImport'
-  | 'resolveFileUrl'
-  | 'resolveImportMeta'
-
-type AsyncPluginHooks = Exclude<
-  keyof FunctionPluginHooks,
-  SyncPluginHooks
->
-
-type FirstPluginHooks =
-  | 'load'
-  | 'renderDynamicImport'
-  | 'resolveDynamicImport'
-  | 'resolveFileUrl'
-  | 'resolveId'
-  | 'resolveImportMeta'
-  | 'shouldTransformCachedModule'
-
-type SequentialPluginHooks =
-  | 'augmentChunkHash'
-  | 'generateBundle'
-  | 'onLog'
-  | 'options'
-  | 'outputOptions'
-  | 'renderChunk'
-  | 'transform'
-
-type ParallelPluginHooks = Exclude<
-  keyof FunctionPluginHooks | AddonHooks,
-  FirstPluginHooks | SequentialPluginHooks
->
-
-type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro'
-
-type MakeAsync<Function_> = Function_ extends (
-  this: infer This,
-  ...parameters: infer Arguments
-) => infer Return
-  ? (this: This, ...parameters: Arguments) => Return | Promise<Return>
-  : never
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-type ObjectHook<T, O = {}> =
-  | T
-  | ({ handler: T; order?: 'pre' | 'post' | null } & O)
-
-type PluginHooks = {
-  [K in keyof FunctionPluginHooks]: ObjectHook<
-    K extends AsyncPluginHooks
-      ? MakeAsync<FunctionPluginHooks[K]>
-      : FunctionPluginHooks[K],
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    K extends ParallelPluginHooks ? { sequential?: boolean } : {}
-  >
-}
-
-interface OutputPlugin
-  extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
-    Partial<{ [K in AddonHooks]: ObjectHook<AddonHook> }> {
-  cacheKey?: string
-  name: string
-  version?: string
-}
-
-interface Plugin$1<A = any> extends OutputPlugin, Partial<PluginHooks> {
-  // for inter-plugin communication
-  api?: A
-}
-
-type TreeshakingPreset = 'smallest' | 'safest' | 'recommended'
-
-interface NormalizedTreeshakingOptions {
-  annotations: boolean
-  correctVarValueBeforeDeclaration: boolean
-  manualPureFunctions: readonly string[]
-  moduleSideEffects: HasModuleSideEffects
-  propertyReadSideEffects: boolean | 'always'
-  tryCatchDeoptimization: boolean
-  unknownGlobalSideEffects: boolean
-}
-
-interface TreeshakingOptions
-  extends Partial<Omit<NormalizedTreeshakingOptions, 'moduleSideEffects'>> {
-  moduleSideEffects?: ModuleSideEffectsOption
-  preset?: TreeshakingPreset
-}
-
-interface ManualChunkMeta {
-  getModuleIds: () => IterableIterator<string>
-  getModuleInfo: GetModuleInfo
-}
-type GetManualChunk = (
-  id: string,
-  meta: ManualChunkMeta,
-) => string | NullValue$1
-
-type ExternalOption =
-  | (string | RegExp)[]
-  | string
-  | RegExp
-  | ((
-      source: string,
-      importer: string | undefined,
-      isResolved: boolean,
-    ) => boolean | NullValue$1)
-
-type GlobalsOption =
-  | { [name: string]: string }
-  | ((name: string) => string)
-
-type InputOption = string | string[] | { [entryAlias: string]: string }
-
-type ManualChunksOption =
-  | { [chunkAlias: string]: string[] }
-  | GetManualChunk
-
-type LogHandlerWithDefault = (
-  level: LogLevel,
-  log: RollupLog,
-  defaultHandler: LogOrStringHandler,
-) => void
-
-type LogOrStringHandler = (
-  level: LogLevel | 'error',
-  log: RollupLog | string,
-) => void
-
-type LogHandler = (level: LogLevel, log: RollupLog) => void
-
-type ModuleSideEffectsOption =
-  | boolean
-  | 'no-external'
-  | string[]
-  | HasModuleSideEffects
-
-type PreserveEntrySignaturesOption =
-  | false
-  | 'strict'
-  | 'allow-extension'
-  | 'exports-only'
-
-type SourcemapPathTransformOption = (
-  relativeSourcePath: string,
-  sourcemapPath: string,
-) => string
-
-type SourcemapIgnoreListOption = (
-  relativeSourcePath: string,
-  sourcemapPath: string,
-) => boolean
-
-type InputPluginOption = MaybePromise$2<
-  Plugin$1 | NullValue$1 | false | InputPluginOption[]
->
-
-interface InputOptions$1 {
-  acorn?: Record<string, unknown>
-  acornInjectPlugins?:
-    | ((...arguments_: any[]) => unknown)[]
-    | ((...arguments_: any[]) => unknown)
-  cache?: boolean | RollupCache
-  context?: string
-  experimentalCacheExpiry?: number
-  experimentalLogSideEffects?: boolean
-  external?: ExternalOption
-  /** @deprecated Use the "inlineDynamicImports" output option instead. */
-  inlineDynamicImports?: boolean
-  input?: InputOption
-  logLevel?: LogLevelOption
-  makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource'
-  /** @deprecated Use the "manualChunks" output option instead. */
-  manualChunks?: ManualChunksOption
-  maxParallelFileOps?: number
-  /** @deprecated Use the "maxParallelFileOps" option instead. */
-  maxParallelFileReads?: number
-  moduleContext?:
-    | ((id: string) => string | NullValue$1)
-    | { [id: string]: string }
-  onLog?: LogHandlerWithDefault
-  onwarn?: WarningHandlerWithDefault
-  perf?: boolean
-  plugins?: InputPluginOption
-  preserveEntrySignatures?: PreserveEntrySignaturesOption
-  /** @deprecated Use the "preserveModules" output option instead. */
-  preserveModules?: boolean
-  preserveSymlinks?: boolean
-  shimMissingExports?: boolean
-  strictDeprecations?: boolean
-  treeshake?: boolean | TreeshakingPreset | TreeshakingOptions
-  watch?: WatcherOptions | false
-}
-
-interface NormalizedInputOptions {
-  acorn: Record<string, unknown>
-  acornInjectPlugins: (() => unknown)[]
-  cache: false | undefined | RollupCache
-  context: string
-  experimentalCacheExpiry: number
-  experimentalLogSideEffects: boolean
-  external: IsExternal
-  /** @deprecated Use the "inlineDynamicImports" output option instead. */
-  inlineDynamicImports: boolean | undefined
-  input: string[] | { [entryAlias: string]: string }
-  logLevel: LogLevelOption
-  makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource'
-  /** @deprecated Use the "manualChunks" output option instead. */
-  manualChunks: ManualChunksOption | undefined
-  maxParallelFileOps: number
-  /** @deprecated Use the "maxParallelFileOps" option instead. */
-  maxParallelFileReads: number
-  moduleContext: (id: string) => string
-  onLog: LogHandler
-  onwarn: (warning: RollupLog) => void
-  perf: boolean
-  plugins: Plugin$1[]
-  preserveEntrySignatures: PreserveEntrySignaturesOption
-  /** @deprecated Use the "preserveModules" output option instead. */
-  preserveModules: boolean | undefined
-  preserveSymlinks: boolean
-  shimMissingExports: boolean
-  strictDeprecations: boolean
-  treeshake: false | NormalizedTreeshakingOptions
-}
-
-type InternalModuleFormat =
-  | 'amd'
-  | 'cjs'
-  | 'es'
-  | 'iife'
-  | 'system'
-  | 'umd'
-
-type ModuleFormat =
-  | InternalModuleFormat
-  | 'commonjs'
-  | 'esm'
-  | 'module'
-  | 'systemjs'
-
-type GeneratedCodePreset = 'es5' | 'es2015'
-
-interface NormalizedGeneratedCodeOptions {
-  arrowFunctions: boolean
-  constBindings: boolean
-  objectShorthand: boolean
-  reservedNamesAsProps: boolean
-  symbols: boolean
-}
-
-interface GeneratedCodeOptions extends Partial<NormalizedGeneratedCodeOptions> {
-  preset?: GeneratedCodePreset
-}
-
-type OptionsPaths = Record<string, string> | ((id: string) => string)
-
-type InteropType =
-  | 'compat'
-  | 'auto'
-  | 'esModule'
-  | 'default'
-  | 'defaultOnly'
-
-type GetInterop = (id: string | null) => InteropType
-
-type AmdOptions = (
-  | {
-      autoId?: false
-      id: string
-    }
-  | {
-      autoId: true
-      basePath?: string
-      id?: undefined
-    }
-  | {
-      autoId?: false
-      id?: undefined
-    }
-) & {
-  define?: string
-  forceJsExtensionForImports?: boolean
-}
-
-type NormalizedAmdOptions = (
-  | {
-      autoId: false
-      id?: string
-    }
-  | {
-      autoId: true
-      basePath: string
-    }
-) & {
-  define: string
-  forceJsExtensionForImports: boolean
-}
-
-type AddonFunction = (chunk: RenderedChunk$1) => string | Promise<string>
-
-type OutputPluginOption = MaybePromise$2<
-  OutputPlugin | NullValue$1 | false | OutputPluginOption[]
->
-
-interface OutputOptions$1 {
-  amd?: AmdOptions
-  assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string)
-  banner?: string | AddonFunction
-  chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string)
-  compact?: boolean
-  // only required for bundle.write
-  dir?: string
-  /** @deprecated Use the "renderDynamicImport" plugin hook instead. */
-  dynamicImportFunction?: string
-  dynamicImportInCjs?: boolean
-  entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string)
-  esModule?: boolean | 'if-default-prop'
-  /** @deprecated This option is no longer needed and ignored. */
-  experimentalDeepDynamicChunkOptimization?: boolean
-  experimentalMinChunkSize?: number
-  exports?: 'default' | 'named' | 'none' | 'auto'
-  extend?: boolean
-  externalImportAssertions?: boolean
-  externalLiveBindings?: boolean
-  // only required for bundle.write
-  file?: string
-  footer?: string | AddonFunction
-  format?: ModuleFormat
-  freeze?: boolean
-  generatedCode?: GeneratedCodePreset | GeneratedCodeOptions
-  globals?: GlobalsOption
-  hoistTransitiveImports?: boolean
-  indent?: string | boolean
-  inlineDynamicImports?: boolean
-  interop?: InteropType | GetInterop
-  intro?: string | AddonFunction
-  manualChunks?: ManualChunksOption
-  minifyInternalExports?: boolean
-  name?: string
-  /** @deprecated Use "generatedCode.symbols" instead. */
-  namespaceToStringTag?: boolean
-  noConflict?: boolean
-  outro?: string | AddonFunction
-  paths?: OptionsPaths
-  plugins?: OutputPluginOption
-  /** @deprecated Use "generatedCode.constBindings" instead. */
-  preferConst?: boolean
-  preserveModules?: boolean
-  preserveModulesRoot?: string
-  sanitizeFileName?: boolean | ((fileName: string) => string)
-  sourcemap?: boolean | 'inline' | 'hidden'
-  sourcemapBaseUrl?: string
-  sourcemapExcludeSources?: boolean
-  sourcemapFile?: string
-  sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string)
-  sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption
-  sourcemapPathTransform?: SourcemapPathTransformOption
-  strict?: boolean
-  systemNullSetters?: boolean
-  validate?: boolean
-}
-
-interface NormalizedOutputOptions$1 {
-  amd: NormalizedAmdOptions
-  assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string)
-  banner: AddonFunction
-  chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string)
-  compact: boolean
-  dir: string | undefined
-  /** @deprecated Use the "renderDynamicImport" plugin hook instead. */
-  dynamicImportFunction: string | undefined
-  dynamicImportInCjs: boolean
-  entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string)
-  esModule: boolean | 'if-default-prop'
-  /** @deprecated This option is no longer needed and ignored. */
-  experimentalDeepDynamicChunkOptimization: boolean
-  experimentalMinChunkSize: number
-  exports: 'default' | 'named' | 'none' | 'auto'
-  extend: boolean
-  externalImportAssertions: boolean
-  externalLiveBindings: boolean
-  file: string | undefined
-  footer: AddonFunction
-  format: InternalModuleFormat
-  freeze: boolean
-  generatedCode: NormalizedGeneratedCodeOptions
-  globals: GlobalsOption
-  hoistTransitiveImports: boolean
-  indent: true | string
-  inlineDynamicImports: boolean
-  interop: GetInterop
-  intro: AddonFunction
-  manualChunks: ManualChunksOption
-  minifyInternalExports: boolean
-  name: string | undefined
-  /** @deprecated Use "generatedCode.symbols" instead. */
-  namespaceToStringTag: boolean
-  noConflict: boolean
-  outro: AddonFunction
-  paths: OptionsPaths
-  plugins: OutputPlugin[]
-  /** @deprecated Use "generatedCode.constBindings" instead. */
-  preferConst: boolean
-  preserveModules: boolean
-  preserveModulesRoot: string | undefined
-  sanitizeFileName: (fileName: string) => string
-  sourcemap: boolean | 'inline' | 'hidden'
-  sourcemapBaseUrl: string | undefined
-  sourcemapExcludeSources: boolean
-  sourcemapFile: string | undefined
-  sourcemapFileNames:
-    | string
-    | ((chunkInfo: PreRenderedChunk) => string)
-    | undefined
-  sourcemapIgnoreList: SourcemapIgnoreListOption
-  sourcemapPathTransform: SourcemapPathTransformOption | undefined
-  strict: boolean
-  systemNullSetters: boolean
-  validate: boolean
-}
-
-type WarningHandlerWithDefault = (
-  warning: RollupLog,
-  defaultHandler: LoggingFunction,
-) => void
-
-interface PreRenderedAsset {
-  name: string | undefined
-  source: string | Uint8Array
-  type: 'asset'
-}
-
-interface OutputAsset extends PreRenderedAsset {
-  fileName: string
-  needsCodeReference: boolean
-}
-
-interface RenderedModule {
-  readonly code: string | null
-  originalLength: number
-  removedExports: string[]
-  renderedExports: string[]
-  renderedLength: number
-}
-
-interface PreRenderedChunk {
-  exports: string[]
-  facadeModuleId: string | null
-  isDynamicEntry: boolean
-  isEntry: boolean
-  isImplicitEntry: boolean
-  moduleIds: string[]
-  name: string
-  type: 'chunk'
-}
-
-interface RenderedChunk$1 extends PreRenderedChunk {
-  dynamicImports: string[]
-  fileName: string
-  implicitlyLoadedBefore: string[]
-  importedBindings: {
-    [imported: string]: string[]
-  }
-  imports: string[]
-  modules: {
-    [id: string]: RenderedModule
-  }
-  referencedFiles: string[]
-}
-
-interface OutputChunk extends RenderedChunk$1 {
-  code: string
-  map: SourceMap | null
-  sourcemapFileName: string | null
-  preliminaryFileName: string
-}
-
-interface SerializablePluginCache {
-  [key: string]: [number, any]
-}
-
-interface RollupCache {
-  modules: ModuleJSON[]
-  plugins?: Record<string, SerializablePluginCache>
-}
-
-interface ChokidarOptions {
-  alwaysStat?: boolean
-  atomic?: boolean | number
-  awaitWriteFinish?:
-    | {
-        pollInterval?: number
-        stabilityThreshold?: number
-      }
-    | boolean
-  binaryInterval?: number
-  cwd?: string
-  depth?: number
-  disableGlobbing?: boolean
-  followSymlinks?: boolean
-  ignoreInitial?: boolean
-  ignorePermissionErrors?: boolean
-  ignored?: any
-  interval?: number
-  persistent?: boolean
-  useFsEvents?: boolean
-  usePolling?: boolean
-}
-
-interface WatcherOptions {
-  buildDelay?: number
-  chokidar?: ChokidarOptions
-  clearScreen?: boolean
-  exclude?: string | RegExp | (string | RegExp)[]
-  include?: string | RegExp | (string | RegExp)[]
-  skipWrite?: boolean
-}
-
-interface AcornNode {
-  end: number
-  start: number
-  type: string
-}
-
-type MaybePromise$1<T> = T | Promise<T>
-type Nullable<T> = T | null | undefined
-type VoidNullable<T = void> = T | null | undefined | void
-declare class BindingOutputAsset {
-  get fileName(): string
-  get source(): string
-}
-
-declare class BindingOutputChunk {
-  get isEntry(): boolean
-  get isDynamicEntry(): boolean
-  get facadeModuleId(): string | null
-  get moduleIds(): Array<string>
-  get exports(): Array<string>
-  get fileName(): string
-  get modules(): Record<string, BindingRenderedModule>
-  get code(): string
-  get map(): string | null
-  get sourcemapFileName(): string | null
-}
-
-declare class BindingOutputs {
-  get chunks(): Array<BindingOutputChunk>
-  get assets(): Array<BindingOutputAsset>
-}
-
-declare class BindingPluginContext {
-  resolve(specifier: string, importer: string | undefined | null, extraOptions: BindingPluginContextResolveOptions): void
-}
-
-interface AliasItem {
-  find: string
-  replacements: Array<string>
-}
-
-interface BindingHookResolveIdExtraOptions {
-  isEntry: boolean
-  kind: string
-}
-
-interface BindingInputItem {
-  name?: string
-  import: string
-}
-
-interface BindingInputOptions {
-  external?: undefined | ((source: string, importer: string | undefined, isResolved: boolean) => boolean)
-  input: Array<BindingInputItem>
-  plugins: Array<BindingPluginOrParallelJsPluginPlaceholder>
-  resolve?: BindingResolveOptions
-  shimMissingExports?: boolean
-  platform?: 'node' | 'browser' | 'neutral'
-  logLevel?: 'silent' | 'error' | 'warn' | 'info'
-  cwd: string
-}
-
-interface BindingOutputOptions {
-  entryFileNames?: string
-  chunkFileNames?: string
-  banner?: Nullable<string> | ((chunk: RenderedChunk) => MaybePromise$1<VoidNullable<string>>)
-  dir?: string
-  exports?: 'default' | 'named' | 'none' | 'auto'
-  footer?: Nullable<string> | ((chunk: RenderedChunk) => MaybePromise$1<VoidNullable<string>>)
-  format?: 'es' | 'cjs'
-  plugins: Array<BindingPluginOrParallelJsPluginPlaceholder>
-  sourcemap?: 'file' | 'inline' | 'hidden'
-}
-
-interface BindingPluginContextResolveOptions {
-  importKind: string
-}
-
-interface BindingRenderedModule {
-  code?: string
-}
-
-interface BindingResolveOptions {
-  alias?: Array<AliasItem>
-  aliasFields?: Array<Array<string>>
-  conditionNames?: Array<string>
-  exportsFields?: Array<Array<string>>
-  extensions?: Array<string>
-  mainFields?: Array<string>
-  mainFiles?: Array<string>
-  modules?: Array<string>
-  symlinks?: boolean
-  tsconfigFilename?: string
-}
-
-interface RenderedChunk {
-  isEntry: boolean
-  isDynamicEntry: boolean
-  facadeModuleId?: string
-  moduleIds: Array<string>
-  exports: Array<string>
-  fileName: string
-  modules: Record<string, BindingRenderedModule>
-}
-
-type MaybePromise<T> = T | Promise<T>;
-interface AnyFn {
-    (...args: any[]): any;
-}
-interface AnyObj {
-}
-type NullValue<T = void> = T | undefined | null | void;
-
-interface SourceMapInputObject {
-    file?: string;
-    mappings: string;
-    names?: string[];
-    sources?: (string | null)[];
-    sourcesContent?: (string | null)[];
-    sourceRoot?: string;
-    version: number;
-}
-type SourceMapInput = SourceMapInputObject | string | null;
-
-interface OutputOptions {
-    dir?: OutputOptions$1['dir'];
-    format?: 'es';
-    exports?: OutputOptions$1['exports'];
-    sourcemap?: OutputOptions$1['sourcemap'];
-    banner?: OutputOptions$1['banner'];
-    footer?: OutputOptions$1['footer'];
-    entryFileNames?: string;
-    chunkFileNames?: string;
-}
-type NormalizedOutputOptions = BindingOutputOptions;
-
-type PluginContext = BindingPluginContext;
-type FormalHook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = {
-    handler: Handler;
-} & HookOptions;
-type Hook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = FormalHook<Handler, HookOptions> | Handler;
-interface Plugin {
-    name?: string;
-    buildStart?: Hook<(this: PluginContext, options: RolldownNormalizedInputOptions) => MaybePromise<NullValue>>;
-    resolveId?: Hook<(this: null, source: string, importer: string | undefined, extraOptions: BindingHookResolveIdExtraOptions) => MaybePromise<string | NullValue | false | {
-        id: string;
-        external?: boolean;
-    }>>;
-    load?: Hook<(this: null, id: string) => MaybePromise<NullValue | string | {
-        code: string;
-        map?: SourceMapInput;
-    }>>;
-    transform?: Hook<(this: null, code: string, id: string) => MaybePromise<NullValue | string | {
-        code: string;
-        map?: string | null | SourceMapInput;
-    }>>;
-    buildEnd?: Hook<(this: null, err?: Error) => MaybePromise<NullValue>>;
-    renderStart?: Hook<(outputOptions: BindingOutputOptions, inputOptions: RolldownNormalizedInputOptions) => MaybePromise<NullValue>>;
-    renderChunk?: Hook<(this: null, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => MaybePromise<NullValue | string | {
-        code: string;
-        map?: string | null | SourceMapInput;
-    }>>;
-    renderError?: Hook<(this: null, error: Error) => MaybePromise<NullValue>>;
-    generateBundle?: Hook<(bundle: BindingOutputs, isWrite: boolean) => MaybePromise<NullValue>>;
-    writeBundle?: Hook<(bundle: BindingOutputs) => MaybePromise<NullValue>>;
-}
-type ParallelPlugin = {
-    /** @internal */
-    _parallel: {
-        fileUrl: string;
-        options: unknown;
-    };
-};
-type DefineParallelPluginResult<Options> = (options: Options) => ParallelPlugin;
-declare function defineParallelPlugin<Options>(pluginPath: string): DefineParallelPluginResult<Options>;
-
-interface InputOptions {
-    input?: InputOptions$1['input'];
-    plugins?: (Plugin | ParallelPlugin)[];
-    external?: InputOptions$1['external'];
-    resolve?: RolldownResolveOptions;
-    cwd?: string;
-    platform?: BindingInputOptions['platform'];
-    shimMissingExports?: BindingInputOptions['shimMissingExports'];
-    logLevel?: BindingInputOptions['logLevel'];
-}
-type RolldownResolveOptions = Omit<BindingResolveOptions, 'alias'> & {
-    alias?: Record<string, string>;
-};
-type RolldownNormalizedInputOptions = Omit<NormalizedInputOptions, 'plugins'> & {
-    plugins: (Plugin | ParallelPlugin)[];
-    resolve?: BindingResolveOptions;
-    platform?: BindingInputOptions['platform'];
-};
-
-export { type DefineParallelPluginResult as D, type InputOptions as I, type MaybePromise as M, type OutputOptions as O, type Plugin as P, defineParallelPlugin as d };