@xyd-js/content 0.1.0-xyd.2

package/dist/index.d.ts

@@ -0,0 +1,960 @@
+import * as mdast from 'mdast';
+import * as remark_mdx_frontmatter from 'remark-mdx-frontmatter';
+import * as unified from 'unified';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkGfm from 'remark-gfm';
+import * as estree from 'estree';
+
+declare function compileBySlug(slug: string, mdx: boolean): Promise<string>;
+
+type CustomTag = {
+    name: RegExp;
+    depth: (name: string) => number;
+};
+interface RemarkMdxTocOptions {
+    name?: string;
+    customTags?: CustomTag[];
+    minDepth?: number;
+}
+
+declare function mdxOptions(toc: RemarkMdxTocOptions): {
+    remarkPlugins: (unified.Plugin | typeof remarkFrontmatter | unified.Plugin<[(remark_mdx_frontmatter.RemarkMdxFrontmatterOptions | undefined)?], mdast.Root> | typeof remarkGfm)[];
+    rehypePlugins: never[];
+};
+
+declare module 'estree' {
+	export interface Decorator extends estree.BaseNode {
+		type: 'Decorator';
+		expression: estree.Expression;
+	}
+	interface PropertyDefinition {
+		decorators: estree.Decorator[];
+	}
+	interface MethodDefinition {
+		decorators: estree.Decorator[];
+	}
+	interface BaseClass {
+		decorators: estree.Decorator[];
+	}
+}
+
+// utils
+type NullValue = null | undefined | void;
+type MaybePromise<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[];
+	version: number;
+	x_google_ignoreList?: number[];
+}
+
+interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	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[];
+	version: number;
+	debugId?: string;
+	toString(): string;
+	toUrl(): string;
+}
+
+type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
+
+interface ModuleOptions {
+	attributes: Record<string, string>;
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+	ast?: ProgramNode;
+	code: string;
+	map?: SourceMapInput;
+}
+
+interface TransformModuleJSON {
+	ast?: ProgramNode;
+	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: ProgramNode;
+	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;
+	originalFileName?: string | null;
+	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: ProgramNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	exportedBindings: Record<string, string[]> | null;
+	exports: string[] | null;
+	hasDefaultExport: boolean | null;
+	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;
+
+type CustomPluginOptions = Record<string, any>;
+
+type LoggingFunctionWithPosition = (
+	log: RollupLog | string | (() => RollupLog | string),
+	pos?: number | { column: number; line: number }
+) => void;
+
+type ParseAst = (
+	input: string,
+	options?: { allowReturnOutsideFunction?: boolean; jsx?: boolean }
+) => ProgramNode;
+
+// declare AbortSignal here for environments without DOM lib or @types/node
+declare global {
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+	interface AbortSignal {}
+}
+
+interface PluginContext 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>;
+	parse: ParseAst;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: {
+			attributes?: 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;
+}
+
+type ResolvedIdMap = Record<string, ResolvedId>;
+
+interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
+	external?: boolean | 'absolute' | 'relative';
+	id: string;
+	resolvedBy?: string;
+}
+
+type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+
+type ResolveIdHook = (
+	this: PluginContext,
+	source: string,
+	importer: string | undefined,
+	options: { attributes: Record<string, string>; custom?: CustomPluginOptions; isEntry: boolean }
+) => ResolveIdResult;
+
+type ShouldTransformCachedModuleHook = (
+	this: PluginContext,
+	options: {
+		ast: ProgramNode;
+		code: string;
+		id: string;
+		meta: CustomPluginOptions;
+		moduleSideEffects: boolean | 'no-treeshake';
+		resolvedSources: ResolvedIdMap;
+		syntheticNamedExports: boolean | string;
+	}
+) => boolean | NullValue;
+
+type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+type HasModuleSideEffects = (id: string, external: boolean) => boolean;
+
+type LoadResult = SourceDescription | string | NullValue;
+
+type LoadHook = (this: PluginContext, id: string) => LoadResult;
+
+interface TransformPluginContext extends PluginContext {
+	debug: LoggingFunctionWithPosition;
+	error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	getCombinedSourcemap: () => SourceMap;
+	info: LoggingFunctionWithPosition;
+	warn: LoggingFunctionWithPosition;
+}
+
+type TransformResult = string | NullValue | Partial<SourceDescription>;
+
+type TransformHook = (
+	this: TransformPluginContext,
+	code: string,
+	id: string
+) => TransformResult;
+
+type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void;
+
+type RenderChunkHook = (
+	this: PluginContext,
+	code: string,
+	chunk: RenderedChunk,
+	options: NormalizedOutputOptions,
+	meta: { chunks: Record<string, RenderedChunk> }
+) => { code: string; map?: SourceMapInput } | string | NullValue;
+
+type ResolveDynamicImportHook = (
+	this: PluginContext,
+	specifier: string | AstNode,
+	importer: string,
+	options: { attributes: Record<string, string> }
+) => ResolveIdResult;
+
+type ResolveImportMetaHook = (
+	this: PluginContext,
+	property: string | null,
+	options: { chunkId: string; format: InternalModuleFormat; moduleId: string }
+) => string | NullValue;
+
+type ResolveFileUrlHook = (
+	this: PluginContext,
+	options: {
+		chunkId: string;
+		fileName: string;
+		format: InternalModuleFormat;
+		moduleId: string;
+		referenceId: string;
+		relativePath: string;
+	}
+) => string | NullValue;
+
+type AddonHookFunction = (
+	this: PluginContext,
+	chunk: RenderedChunk
+) => string | Promise<string>;
+type AddonHook = string | AddonHookFunction;
+
+type ChangeEvent = 'create' | 'update' | 'delete';
+type WatchChangeHook = (
+	this: PluginContext,
+	id: string,
+	change: { event: ChangeEvent }
+) => void;
+
+type OutputBundle = Record<string, OutputAsset | OutputChunk>;
+
+interface FunctionPluginHooks {
+	augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void;
+	buildEnd: (this: PluginContext, error?: Error) => void;
+	buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;
+	closeBundle: (this: PluginContext) => void;
+	closeWatcher: (this: PluginContext) => void;
+	generateBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		bundle: OutputBundle,
+		isWrite: boolean
+	) => void;
+	load: LoadHook;
+	moduleParsed: ModuleParsedHook;
+	onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue;
+	options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue;
+	outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue;
+	renderChunk: RenderChunkHook;
+	renderDynamicImport: (
+		this: PluginContext,
+		options: {
+			customResolution: string | null;
+			format: InternalModuleFormat;
+			moduleId: string;
+			targetModuleId: string | null;
+		}
+	) => { left: string; right: string } | NullValue;
+	renderError: (this: PluginContext, error?: Error) => void;
+	renderStart: (
+		this: PluginContext,
+		outputOptions: NormalizedOutputOptions,
+		inputOptions: NormalizedInputOptions
+	) => void;
+	resolveDynamicImport: ResolveDynamicImportHook;
+	resolveFileUrl: ResolveFileUrlHook;
+	resolveId: ResolveIdHook;
+	resolveImportMeta: ResolveImportMetaHook;
+	shouldTransformCachedModule: ShouldTransformCachedModuleHook;
+	transform: TransformHook;
+	watchChange: WatchChangeHook;
+	writeBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		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/no-empty-object-type
+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/no-empty-object-type
+		K extends ParallelPluginHooks ? { sequential?: boolean } : {}
+	>;
+};
+
+interface OutputPlugin
+	extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
+		Partial<Record<AddonHooks, ObjectHook<AddonHook>>> {
+	cacheKey?: string;
+	name: string;
+	version?: string;
+}
+
+interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
+	// for inter-plugin communication
+	api?: A;
+}
+
+type JsxPreset = 'react' | 'react-jsx' | 'preserve' | 'preserve-react';
+
+type NormalizedJsxOptions =
+	| NormalizedJsxPreserveOptions
+	| NormalizedJsxClassicOptions
+	| NormalizedJsxAutomaticOptions;
+
+interface NormalizedJsxPreserveOptions {
+	factory: string | null;
+	fragment: string | null;
+	importSource: string | null;
+	mode: 'preserve';
+}
+
+interface NormalizedJsxClassicOptions {
+	factory: string;
+	fragment: string;
+	importSource: string | null;
+	mode: 'classic';
+}
+
+interface NormalizedJsxAutomaticOptions {
+	factory: string;
+	importSource: string | null;
+	jsxImportSource: string;
+	mode: 'automatic';
+}
+
+type JsxOptions = Partial<NormalizedJsxOptions> & {
+	preset?: JsxPreset;
+};
+
+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;
+
+type ExternalOption =
+	| (string | RegExp)[]
+	| string
+	| RegExp
+	| ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue);
+
+type GlobalsOption = Record<string, string> | ((name: string) => string);
+
+type InputOption = string | string[] | Record<string, string>;
+
+type ManualChunksOption = Record<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<Plugin | NullValue | false | InputPluginOption[]>;
+
+interface InputOptions {
+	cache?: boolean | RollupCache;
+	context?: string;
+	experimentalCacheExpiry?: number;
+	experimentalLogSideEffects?: boolean;
+	external?: ExternalOption;
+	input?: InputOption;
+	jsx?: false | JsxPreset | JsxOptions;
+	logLevel?: LogLevelOption;
+	makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource';
+	maxParallelFileOps?: number;
+	moduleContext?: ((id: string) => string | NullValue) | Record<string, string>;
+	onLog?: LogHandlerWithDefault;
+	onwarn?: WarningHandlerWithDefault;
+	perf?: boolean;
+	plugins?: InputPluginOption;
+	preserveEntrySignatures?: PreserveEntrySignaturesOption;
+	preserveSymlinks?: boolean;
+	shimMissingExports?: boolean;
+	strictDeprecations?: boolean;
+	treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;
+	watch?: WatcherOptions | false;
+}
+
+interface NormalizedInputOptions {
+	cache: false | undefined | RollupCache;
+	context: string;
+	experimentalCacheExpiry: number;
+	experimentalLogSideEffects: boolean;
+	external: IsExternal;
+	input: string[] | Record<string, string>;
+	jsx: false | NormalizedJsxOptions;
+	logLevel: LogLevelOption;
+	makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource';
+	maxParallelFileOps: number;
+	moduleContext: (id: string) => string;
+	onLog: LogHandler;
+	perf: boolean;
+	plugins: Plugin[];
+	preserveEntrySignatures: PreserveEntrySignaturesOption;
+	preserveSymlinks: boolean;
+	shimMissingExports: boolean;
+	strictDeprecations: boolean;
+	treeshake: false | NormalizedTreeshakingOptions;
+}
+
+type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd';
+type ImportAttributesKey = 'with' | 'assert';
+
+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) => string | Promise<string>;
+
+type OutputPluginOption = MaybePromise<OutputPlugin | NullValue | false | OutputPluginOption[]>;
+
+type HashCharacters = 'base64' | 'base36' | 'hex';
+
+interface OutputOptions {
+	amd?: AmdOptions;
+	assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner?: string | AddonFunction;
+	chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact?: boolean;
+	// only required for bundle.write
+	dir?: string;
+	dynamicImportInCjs?: boolean;
+	entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule?: boolean | 'if-default-prop';
+	experimentalMinChunkSize?: number;
+	exports?: 'default' | 'named' | 'none' | 'auto';
+	extend?: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions?: boolean;
+	externalImportAttributes?: boolean;
+	externalLiveBindings?: boolean;
+	// only required for bundle.write
+	file?: string;
+	footer?: string | AddonFunction;
+	format?: ModuleFormat;
+	freeze?: boolean;
+	generatedCode?: GeneratedCodePreset | GeneratedCodeOptions;
+	globals?: GlobalsOption;
+	hashCharacters?: HashCharacters;
+	hoistTransitiveImports?: boolean;
+	importAttributesKey?: ImportAttributesKey;
+	indent?: string | boolean;
+	inlineDynamicImports?: boolean;
+	interop?: InteropType | GetInterop;
+	intro?: string | AddonFunction;
+	manualChunks?: ManualChunksOption;
+	minifyInternalExports?: boolean;
+	name?: string;
+	noConflict?: boolean;
+	outro?: string | AddonFunction;
+	paths?: OptionsPaths;
+	plugins?: OutputPluginOption;
+	preserveModules?: boolean;
+	preserveModulesRoot?: string;
+	reexportProtoFromExternal?: boolean;
+	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;
+	sourcemapDebugIds?: boolean;
+	strict?: boolean;
+	systemNullSetters?: boolean;
+	validate?: boolean;
+	virtualDirname?: string;
+}
+
+interface NormalizedOutputOptions {
+	amd: NormalizedAmdOptions;
+	assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner: AddonFunction;
+	chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact: boolean;
+	dir: string | undefined;
+	dynamicImportInCjs: boolean;
+	entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule: boolean | 'if-default-prop';
+	experimentalMinChunkSize: number;
+	exports: 'default' | 'named' | 'none' | 'auto';
+	extend: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions: boolean;
+	externalImportAttributes: boolean;
+	externalLiveBindings: boolean;
+	file: string | undefined;
+	footer: AddonFunction;
+	format: InternalModuleFormat;
+	freeze: boolean;
+	generatedCode: NormalizedGeneratedCodeOptions;
+	globals: GlobalsOption;
+	hashCharacters: HashCharacters;
+	hoistTransitiveImports: boolean;
+	importAttributesKey: ImportAttributesKey;
+	indent: true | string;
+	inlineDynamicImports: boolean;
+	interop: GetInterop;
+	intro: AddonFunction;
+	manualChunks: ManualChunksOption;
+	minifyInternalExports: boolean;
+	name: string | undefined;
+	noConflict: boolean;
+	outro: AddonFunction;
+	paths: OptionsPaths;
+	plugins: OutputPlugin[];
+	preserveModules: boolean;
+	preserveModulesRoot: string | undefined;
+	reexportProtoFromExternal: boolean;
+	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;
+	sourcemapDebugIds: boolean;
+	strict: boolean;
+	systemNullSetters: boolean;
+	validate: boolean;
+	virtualDirname: string;
+}
+
+type WarningHandlerWithDefault = (
+	warning: RollupLog,
+	defaultHandler: LoggingFunction
+) => void;
+
+interface PreRenderedAsset {
+	/** @deprecated Use "names" instead. */
+	name: string | undefined;
+	names: string[];
+	/** @deprecated Use "originalFileNames" instead. */
+	originalFileName: string | null;
+	originalFileNames: string[];
+	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 extends PreRenderedChunk {
+	dynamicImports: string[];
+	fileName: string;
+	implicitlyLoadedBefore: string[];
+	importedBindings: Record<string, string[]>;
+	imports: string[];
+	modules: Record<string, RenderedModule>;
+	referencedFiles: string[];
+}
+
+interface OutputChunk extends RenderedChunk {
+	code: string;
+	map: SourceMap | null;
+	sourcemapFileName: string | null;
+	preliminaryFileName: string;
+}
+
+type SerializablePluginCache = Record<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 AstNodeLocation {
+	end: number;
+	start: number;
+}
+
+type OmittedEstreeKeys =
+	| 'loc'
+	| 'range'
+	| 'leadingComments'
+	| 'trailingComments'
+	| 'innerComments'
+	| 'comments';
+type RollupAstNode<T> = Omit<T, OmittedEstreeKeys> & AstNodeLocation;
+
+type ProgramNode = RollupAstNode<estree.Program>;
+type AstNode = RollupAstNode<estree.Node>;
+
+interface VitePluginInterface {
+    toc: RemarkMdxTocOptions;
+}
+declare function vitePlugins(options: VitePluginInterface): Plugin[];
+
+export { compileBySlug, mdxOptions, vitePlugins };