@xyd-js/content 0.1.0-xyd.4 → 0.1.0-xyd.5

package/dist/index.d.ts

@@ -1,1733 +1,8 @@
-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 { Sidebar, PageFrontMatter, Header } from '@xyd-js/core';
 
 declare function compileBySlug(slug: string, mdx: boolean): Promise<string>;
 
-// ## Interfaces
+declare function pageFrontMatters(navigation: Sidebar[]): Promise<PageFrontMatter>;
+declare function filterNavigationByLevels(headers: Header[], slug: string): (nav: Sidebar) => boolean;
 
-/**
- * Info associated with nodes by the ecosystem.
- *
- * This space is guaranteed to never be specified by unist or specifications
- * implementing unist.
- * But you can use it in utilities and plugins to store data.
- *
- * This type can be augmented to register custom data.
- * For example:
- *
- * ```ts
- * declare module 'unist' {
- *   interface Data {
- *     // `someNode.data.myId` is typed as `number | undefined`
- *     myId?: number | undefined
- *   }
- * }
- * ```
- */
-interface Data {}
-
-/**
- * One place in a source file.
- */
-interface Point {
-    /**
-     * Line in a source file (1-indexed integer).
-     */
-    line: number;
-
-    /**
-     * Column in a source file (1-indexed integer).
-     */
-    column: number;
-    /**
-     * Character in a source file (0-indexed integer).
-     */
-    offset?: number | undefined;
-}
-
-/**
- * Position of a node in a source document.
- *
- * A position is a range between two points.
- */
-interface Position$1 {
-    /**
-     * Place of the first character of the parsed source region.
-     */
-    start: Point;
-
-    /**
-     * Place of the first character after the parsed source region.
-     */
-    end: Point;
-}
-
-/**
- * Abstract unist node.
- *
- * The syntactic unit in unist syntax trees are called nodes.
- *
- * This interface is supposed to be extended.
- * If you can use {@link Literal} or {@link Parent}, you should.
- * But for example in markdown, a `thematicBreak` (`***`), is neither literal
- * nor parent, but still a node.
- */
-interface Node$1 {
-    /**
-     * Node type.
-     */
-    type: string;
-
-    /**
-     * Info from the ecosystem.
-     */
-    data?: Data | undefined;
-
-    /**
-     * Position of a node in a source document.
-     *
-     * Nodes that are generated (not in the original source document) must not
-     * have a position.
-     */
-    position?: Position$1 | undefined;
-}
-
-type CustomTag = {
-    name: RegExp;
-    depth: (name: string) => number;
-};
-interface RemarkMdxTocOptions {
-    name?: string;
-    customTags?: CustomTag[];
-    minDepth?: number;
-}
-
-declare function mdxOptions(toc: RemarkMdxTocOptions): {
-    remarkPlugins: (unified.Plugin<[], Node$1, Node$1> | typeof remarkFrontmatter | unified.Plugin<[(remark_mdx_frontmatter.RemarkMdxFrontmatterOptions | undefined)?], mdast.Root, mdast.Root> | typeof remarkGfm)[];
-    rehypePlugins: never[];
-};
-
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-
-interface BaseNodeWithoutComments {
-    // Every leaf interface that extends BaseNode must specify a type property.
-    // The type property should be a string literal. For example, Identifier
-    // has: `type: "Identifier"`
-    type: string;
-    loc?: SourceLocation | null | undefined;
-    range?: [number, number] | undefined;
-}
-
-interface BaseNode extends BaseNodeWithoutComments {
-    leadingComments?: Comment[] | undefined;
-    trailingComments?: Comment[] | undefined;
-}
-
-interface NodeMap {
-    AssignmentProperty: AssignmentProperty;
-    CatchClause: CatchClause;
-    Class: Class;
-    ClassBody: ClassBody;
-    Expression: Expression;
-    Function: Function;
-    Identifier: Identifier;
-    Literal: Literal;
-    MethodDefinition: MethodDefinition;
-    ModuleDeclaration: ModuleDeclaration;
-    ModuleSpecifier: ModuleSpecifier;
-    Pattern: Pattern;
-    PrivateIdentifier: PrivateIdentifier;
-    Program: Program;
-    Property: Property;
-    PropertyDefinition: PropertyDefinition;
-    SpreadElement: SpreadElement;
-    Statement: Statement;
-    Super: Super;
-    SwitchCase: SwitchCase;
-    TemplateElement: TemplateElement;
-    VariableDeclarator: VariableDeclarator;
-}
-
-type Node = NodeMap[keyof NodeMap];
-
-interface Comment extends BaseNodeWithoutComments {
-    type: "Line" | "Block";
-    value: string;
-}
-
-interface SourceLocation {
-    source?: string | null | undefined;
-    start: Position;
-    end: Position;
-}
-
-interface Position {
-    /** >= 1 */
-    line: number;
-    /** >= 0 */
-    column: number;
-}
-
-interface Program extends BaseNode {
-    type: "Program";
-    sourceType: "script" | "module";
-    body: Array<Directive | Statement | ModuleDeclaration>;
-    comments?: Comment[] | undefined;
-}
-
-interface Directive extends BaseNode {
-    type: "ExpressionStatement";
-    expression: Literal;
-    directive: string;
-}
-
-interface BaseFunction extends BaseNode {
-    params: Pattern[];
-    generator?: boolean | undefined;
-    async?: boolean | undefined;
-    // The body is either BlockStatement or Expression because arrow functions
-    // can have a body that's either. FunctionDeclarations and
-    // FunctionExpressions have only BlockStatement bodies.
-    body: BlockStatement | Expression;
-}
-
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-
-type Statement =
-    | ExpressionStatement
-    | BlockStatement
-    | StaticBlock
-    | EmptyStatement
-    | DebuggerStatement
-    | WithStatement
-    | ReturnStatement
-    | LabeledStatement
-    | BreakStatement
-    | ContinueStatement
-    | IfStatement
-    | SwitchStatement
-    | ThrowStatement
-    | TryStatement
-    | WhileStatement
-    | DoWhileStatement
-    | ForStatement
-    | ForInStatement
-    | ForOfStatement
-    | Declaration;
-
-interface BaseStatement extends BaseNode {}
-
-interface EmptyStatement extends BaseStatement {
-    type: "EmptyStatement";
-}
-
-interface BlockStatement extends BaseStatement {
-    type: "BlockStatement";
-    body: Statement[];
-    innerComments?: Comment[] | undefined;
-}
-
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-    type: "StaticBlock";
-}
-
-interface ExpressionStatement extends BaseStatement {
-    type: "ExpressionStatement";
-    expression: Expression;
-}
-
-interface IfStatement extends BaseStatement {
-    type: "IfStatement";
-    test: Expression;
-    consequent: Statement;
-    alternate?: Statement | null | undefined;
-}
-
-interface LabeledStatement extends BaseStatement {
-    type: "LabeledStatement";
-    label: Identifier;
-    body: Statement;
-}
-
-interface BreakStatement extends BaseStatement {
-    type: "BreakStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface ContinueStatement extends BaseStatement {
-    type: "ContinueStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface WithStatement extends BaseStatement {
-    type: "WithStatement";
-    object: Expression;
-    body: Statement;
-}
-
-interface SwitchStatement extends BaseStatement {
-    type: "SwitchStatement";
-    discriminant: Expression;
-    cases: SwitchCase[];
-}
-
-interface ReturnStatement extends BaseStatement {
-    type: "ReturnStatement";
-    argument?: Expression | null | undefined;
-}
-
-interface ThrowStatement extends BaseStatement {
-    type: "ThrowStatement";
-    argument: Expression;
-}
-
-interface TryStatement extends BaseStatement {
-    type: "TryStatement";
-    block: BlockStatement;
-    handler?: CatchClause | null | undefined;
-    finalizer?: BlockStatement | null | undefined;
-}
-
-interface WhileStatement extends BaseStatement {
-    type: "WhileStatement";
-    test: Expression;
-    body: Statement;
-}
-
-interface DoWhileStatement extends BaseStatement {
-    type: "DoWhileStatement";
-    body: Statement;
-    test: Expression;
-}
-
-interface ForStatement extends BaseStatement {
-    type: "ForStatement";
-    init?: VariableDeclaration | Expression | null | undefined;
-    test?: Expression | null | undefined;
-    update?: Expression | null | undefined;
-    body: Statement;
-}
-
-interface BaseForXStatement extends BaseStatement {
-    left: VariableDeclaration | Pattern;
-    right: Expression;
-    body: Statement;
-}
-
-interface ForInStatement extends BaseForXStatement {
-    type: "ForInStatement";
-}
-
-interface DebuggerStatement extends BaseStatement {
-    type: "DebuggerStatement";
-}
-
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-
-interface BaseDeclaration extends BaseStatement {}
-
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-    type: "FunctionDeclaration";
-    /** It is null when a function declaration is a part of the `export default function` statement */
-    id: Identifier | null;
-    body: BlockStatement;
-}
-
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-    id: Identifier;
-}
-
-interface VariableDeclaration extends BaseDeclaration {
-    type: "VariableDeclaration";
-    declarations: VariableDeclarator[];
-    kind: "var" | "let" | "const";
-}
-
-interface VariableDeclarator extends BaseNode {
-    type: "VariableDeclarator";
-    id: Pattern;
-    init?: Expression | null | undefined;
-}
-
-interface ExpressionMap {
-    ArrayExpression: ArrayExpression;
-    ArrowFunctionExpression: ArrowFunctionExpression;
-    AssignmentExpression: AssignmentExpression;
-    AwaitExpression: AwaitExpression;
-    BinaryExpression: BinaryExpression;
-    CallExpression: CallExpression;
-    ChainExpression: ChainExpression;
-    ClassExpression: ClassExpression;
-    ConditionalExpression: ConditionalExpression;
-    FunctionExpression: FunctionExpression;
-    Identifier: Identifier;
-    ImportExpression: ImportExpression;
-    Literal: Literal;
-    LogicalExpression: LogicalExpression;
-    MemberExpression: MemberExpression;
-    MetaProperty: MetaProperty;
-    NewExpression: NewExpression;
-    ObjectExpression: ObjectExpression;
-    SequenceExpression: SequenceExpression;
-    TaggedTemplateExpression: TaggedTemplateExpression;
-    TemplateLiteral: TemplateLiteral;
-    ThisExpression: ThisExpression;
-    UnaryExpression: UnaryExpression;
-    UpdateExpression: UpdateExpression;
-    YieldExpression: YieldExpression;
-}
-
-type Expression = ExpressionMap[keyof ExpressionMap];
-
-interface BaseExpression extends BaseNode {}
-
-type ChainElement = SimpleCallExpression | MemberExpression;
-
-interface ChainExpression extends BaseExpression {
-    type: "ChainExpression";
-    expression: ChainElement;
-}
-
-interface ThisExpression extends BaseExpression {
-    type: "ThisExpression";
-}
-
-interface ArrayExpression extends BaseExpression {
-    type: "ArrayExpression";
-    elements: Array<Expression | SpreadElement | null>;
-}
-
-interface ObjectExpression extends BaseExpression {
-    type: "ObjectExpression";
-    properties: Array<Property | SpreadElement>;
-}
-
-interface PrivateIdentifier extends BaseNode {
-    type: "PrivateIdentifier";
-    name: string;
-}
-
-interface Property extends BaseNode {
-    type: "Property";
-    key: Expression | PrivateIdentifier;
-    value: Expression | Pattern; // Could be an AssignmentProperty
-    kind: "init" | "get" | "set";
-    method: boolean;
-    shorthand: boolean;
-    computed: boolean;
-}
-
-interface PropertyDefinition extends BaseNode {
-    type: "PropertyDefinition";
-    key: Expression | PrivateIdentifier;
-    value?: Expression | null | undefined;
-    computed: boolean;
-    static: boolean;
-}
-
-interface FunctionExpression extends BaseFunction, BaseExpression {
-    id?: Identifier | null | undefined;
-    type: "FunctionExpression";
-    body: BlockStatement;
-}
-
-interface SequenceExpression extends BaseExpression {
-    type: "SequenceExpression";
-    expressions: Expression[];
-}
-
-interface UnaryExpression extends BaseExpression {
-    type: "UnaryExpression";
-    operator: UnaryOperator;
-    prefix: true;
-    argument: Expression;
-}
-
-interface BinaryExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: BinaryOperator;
-    left: Expression | PrivateIdentifier;
-    right: Expression;
-}
-
-interface AssignmentExpression extends BaseExpression {
-    type: "AssignmentExpression";
-    operator: AssignmentOperator;
-    left: Pattern | MemberExpression;
-    right: Expression;
-}
-
-interface UpdateExpression extends BaseExpression {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    argument: Expression;
-    prefix: boolean;
-}
-
-interface LogicalExpression extends BaseExpression {
-    type: "LogicalExpression";
-    operator: LogicalOperator;
-    left: Expression;
-    right: Expression;
-}
-
-interface ConditionalExpression extends BaseExpression {
-    type: "ConditionalExpression";
-    test: Expression;
-    alternate: Expression;
-    consequent: Expression;
-}
-
-interface BaseCallExpression extends BaseExpression {
-    callee: Expression | Super;
-    arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-
-interface SimpleCallExpression extends BaseCallExpression {
-    type: "CallExpression";
-    optional: boolean;
-}
-
-interface NewExpression extends BaseCallExpression {
-    type: "NewExpression";
-}
-
-interface MemberExpression extends BaseExpression, BasePattern {
-    type: "MemberExpression";
-    object: Expression | Super;
-    property: Expression | PrivateIdentifier;
-    computed: boolean;
-    optional: boolean;
-}
-
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-
-interface BasePattern extends BaseNode {}
-
-interface SwitchCase extends BaseNode {
-    type: "SwitchCase";
-    test?: Expression | null | undefined;
-    consequent: Statement[];
-}
-
-interface CatchClause extends BaseNode {
-    type: "CatchClause";
-    param: Pattern | null;
-    body: BlockStatement;
-}
-
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-    type: "Identifier";
-    name: string;
-}
-
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-
-interface SimpleLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value: string | boolean | number | null;
-    raw?: string | undefined;
-}
-
-interface RegExpLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: RegExp | null | undefined;
-    regex: {
-        pattern: string;
-        flags: string;
-    };
-    raw?: string | undefined;
-}
-
-interface BigIntLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: bigint | null | undefined;
-    bigint: string;
-    raw?: string | undefined;
-}
-
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-
-type BinaryOperator =
-    | "=="
-    | "!="
-    | "==="
-    | "!=="
-    | "<"
-    | "<="
-    | ">"
-    | ">="
-    | "<<"
-    | ">>"
-    | ">>>"
-    | "+"
-    | "-"
-    | "*"
-    | "/"
-    | "%"
-    | "**"
-    | "|"
-    | "^"
-    | "&"
-    | "in"
-    | "instanceof";
-
-type LogicalOperator = "||" | "&&" | "??";
-
-type AssignmentOperator =
-    | "="
-    | "+="
-    | "-="
-    | "*="
-    | "/="
-    | "%="
-    | "**="
-    | "<<="
-    | ">>="
-    | ">>>="
-    | "|="
-    | "^="
-    | "&="
-    | "||="
-    | "&&="
-    | "??=";
-
-type UpdateOperator = "++" | "--";
-
-interface ForOfStatement extends BaseForXStatement {
-    type: "ForOfStatement";
-    await: boolean;
-}
-
-interface Super extends BaseNode {
-    type: "Super";
-}
-
-interface SpreadElement extends BaseNode {
-    type: "SpreadElement";
-    argument: Expression;
-}
-
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-    type: "ArrowFunctionExpression";
-    expression: boolean;
-    body: BlockStatement | Expression;
-}
-
-interface YieldExpression extends BaseExpression {
-    type: "YieldExpression";
-    argument?: Expression | null | undefined;
-    delegate: boolean;
-}
-
-interface TemplateLiteral extends BaseExpression {
-    type: "TemplateLiteral";
-    quasis: TemplateElement[];
-    expressions: Expression[];
-}
-
-interface TaggedTemplateExpression extends BaseExpression {
-    type: "TaggedTemplateExpression";
-    tag: Expression;
-    quasi: TemplateLiteral;
-}
-
-interface TemplateElement extends BaseNode {
-    type: "TemplateElement";
-    tail: boolean;
-    value: {
-        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
-        cooked?: string | null | undefined;
-        raw: string;
-    };
-}
-
-interface AssignmentProperty extends Property {
-    value: Pattern;
-    kind: "init";
-    method: boolean; // false
-}
-
-interface ObjectPattern extends BasePattern {
-    type: "ObjectPattern";
-    properties: Array<AssignmentProperty | RestElement>;
-}
-
-interface ArrayPattern extends BasePattern {
-    type: "ArrayPattern";
-    elements: Array<Pattern | null>;
-}
-
-interface RestElement extends BasePattern {
-    type: "RestElement";
-    argument: Pattern;
-}
-
-interface AssignmentPattern extends BasePattern {
-    type: "AssignmentPattern";
-    left: Pattern;
-    right: Expression;
-}
-
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
-    superClass?: Expression | null | undefined;
-    body: ClassBody;
-}
-
-interface ClassBody extends BaseNode {
-    type: "ClassBody";
-    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-
-interface MethodDefinition extends BaseNode {
-    type: "MethodDefinition";
-    key: Expression | PrivateIdentifier;
-    value: FunctionExpression;
-    kind: "constructor" | "method" | "get" | "set";
-    computed: boolean;
-    static: boolean;
-}
-
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-    type: "ClassDeclaration";
-    /** It is null when a class declaration is a part of the `export default class` statement */
-    id: Identifier | null;
-}
-
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-    id: Identifier;
-}
-
-interface ClassExpression extends BaseClass, BaseExpression {
-    type: "ClassExpression";
-    id?: Identifier | null | undefined;
-}
-
-interface MetaProperty extends BaseExpression {
-    type: "MetaProperty";
-    meta: Identifier;
-    property: Identifier;
-}
-
-type ModuleDeclaration =
-    | ImportDeclaration
-    | ExportNamedDeclaration
-    | ExportDefaultDeclaration
-    | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
-    local: Identifier;
-}
-
-interface ImportDeclaration extends BaseModuleDeclaration {
-    type: "ImportDeclaration";
-    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-    source: Literal;
-}
-
-interface ImportSpecifier extends BaseModuleSpecifier {
-    type: "ImportSpecifier";
-    imported: Identifier | Literal;
-}
-
-interface ImportExpression extends BaseExpression {
-    type: "ImportExpression";
-    source: Expression;
-}
-
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-    type: "ImportDefaultSpecifier";
-}
-
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-    type: "ImportNamespaceSpecifier";
-}
-
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
-    type: "ExportNamedDeclaration";
-    declaration?: Declaration | null | undefined;
-    specifiers: ExportSpecifier[];
-    source?: Literal | null | undefined;
-}
-
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-    type: "ExportSpecifier";
-    local: Identifier | Literal;
-    exported: Identifier | Literal;
-}
-
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-    type: "ExportDefaultDeclaration";
-    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
-}
-
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-    type: "ExportAllDeclaration";
-    exported: Identifier | Literal | null;
-    source: Literal;
-}
-
-interface AwaitExpression extends BaseExpression {
-    type: "AwaitExpression";
-    argument: Expression;
-}
-
-declare module 'estree' {
-	export interface Decorator extends BaseNode {
-		type: 'Decorator';
-		expression: Expression;
-	}
-	interface PropertyDefinition {
-		decorators: undefined[];
-	}
-	interface MethodDefinition {
-		decorators: undefined[];
-	}
-	interface BaseClass {
-		decorators: undefined[];
-	}
-}
-
-// 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<Program>;
-type AstNode = RollupAstNode<Node>;
-
-interface VitePluginInterface {
-    toc: RemarkMdxTocOptions;
-}
-declare function vitePlugins(options: VitePluginInterface): Plugin[];
-
-export { compileBySlug, mdxOptions, vitePlugins };
+export { compileBySlug, filterNavigationByLevels, pageFrontMatters };