@hanzo/docs-core 16.2.5

package/dist/loader-BvlPPJX0.d.ts

@@ -0,0 +1,321 @@
+import { R as Root, I as Item, F as Folder, S as Separator } from './definitions-pJ7PybYY.js';
+import { I18nConfig } from './i18n/index.js';
+import { ReactNode } from 'react';
+
+interface Source<Config extends SourceConfig = SourceConfig> {
+    files: VirtualFile<Config>[];
+}
+interface SourceConfig {
+    pageData: PageData;
+    metaData: MetaData;
+}
+interface MetaData {
+    icon?: string | undefined;
+    title?: string | undefined;
+    root?: boolean | undefined;
+    pages?: string[] | undefined;
+    defaultOpen?: boolean | undefined;
+    collapsible?: boolean | undefined;
+    description?: string | undefined;
+}
+interface PageData {
+    icon?: string | undefined;
+    title?: string;
+    description?: string | undefined;
+}
+type VirtualFile<Config extends SourceConfig = SourceConfig> = VirtualPage<Config['pageData']> | VirtualMeta<Config['metaData']>;
+interface BaseVirtualFile {
+    /**
+     * Virtualized path (relative to content directory)
+     *
+     * @example `docs/page.mdx`
+     */
+    path: string;
+    /**
+     * Absolute path of the file
+     */
+    absolutePath?: string;
+}
+interface VirtualPage<Data extends PageData> extends BaseVirtualFile {
+    type: 'page';
+    /**
+     * Specified Slugs for page
+     */
+    slugs?: string[];
+    data: Data;
+}
+interface VirtualMeta<Data extends MetaData> extends BaseVirtualFile {
+    type: 'meta';
+    data: Data;
+}
+type _ConfigUnion_<T extends Record<string, Source>> = {
+    [K in keyof T]: T[K] extends Source<infer Config> ? {
+        pageData: Config['pageData'] & {
+            type: K;
+        };
+        metaData: Config['metaData'] & {
+            type: K;
+        };
+    } : never;
+}[keyof T];
+declare function multiple<T extends Record<string, Source>>(sources: T): Source<_ConfigUnion_<T>>;
+declare function source<Page extends PageData, Meta extends MetaData>(config: {
+    pages: VirtualPage<Page>[];
+    metas: VirtualMeta<Meta>[];
+}): Source<{
+    pageData: Page;
+    metaData: Meta;
+}>;
+/**
+ * update a source object in-place.
+ */
+declare function update<Config extends SourceConfig>(source: Source<Config>): {
+    files<Page extends PageData, Meta extends MetaData>(fn: (files: VirtualFile<Config>[]) => (VirtualPage<Page> | VirtualMeta<Meta>)[]): typeof update<{
+        pageData: Page;
+        metaData: Meta;
+    }>;
+    page<V extends PageData>(fn: (page: VirtualPage<Config["pageData"]>) => VirtualPage<V>): typeof update<{
+        pageData: V;
+        metaData: Config["metaData"];
+    }>;
+    meta<V extends MetaData>(fn: (meta: VirtualMeta<Config["metaData"]>) => VirtualMeta<V>): typeof update<{
+        pageData: Config["pageData"];
+        metaData: V;
+    }>;
+    build(): Source<Config>;
+};
+
+/**
+ * In memory file system.
+ */
+declare class FileSystem<File> {
+    files: Map<string, File>;
+    folders: Map<string, string[]>;
+    constructor(inherit?: FileSystem<File>);
+    read(path: string): File | undefined;
+    /**
+     * get the direct children of folder (in virtual file path)
+     */
+    readDir(path: string): string[] | undefined;
+    write(path: string, file: File): void;
+    /**
+     * Delete files at specified path.
+     *
+     * @param path - the target path.
+     * @param [recursive=false] - if set to `true`, it will also delete directories.
+     */
+    delete(path: string, recursive?: boolean): boolean;
+    getFiles(): string[];
+    makeDir(path: string): void;
+}
+
+type ContentStorage<Config extends SourceConfig = SourceConfig> = FileSystem<ContentStorageFile<Config>>;
+type ContentStorageFile<Config extends SourceConfig = SourceConfig> = {
+    path: string;
+    absolutePath?: string;
+    format: 'meta';
+    data: Config['metaData'];
+} | {
+    path: string;
+    absolutePath?: string;
+    format: 'page';
+    slugs: string[];
+    data: Config['pageData'];
+};
+/**
+ * @param defaultLanguage - language to use when i18n is not configured.
+ * @returns a map of locale and its content storage.
+ *
+ * in the storage, locale codes are removed from file paths, hence the same file will have same file paths in every storage.
+ */
+declare function buildContentStorage(loaderConfig: ResolvedLoaderConfig, defaultLanguage: string): Record<string, ContentStorage>;
+
+interface PageTreeBuilderContext<Config extends SourceConfig = SourceConfig> {
+    rootId: string;
+    generateNodeId: () => string;
+    options: PageTreeOptions;
+    transformers: PageTreeTransformer<Config>[];
+    builder: PageTreeBuilder;
+    storage: ContentStorage<Config>;
+    getUrl: ResolvedLoaderConfig['url'];
+    storages?: Record<string, ContentStorage<Config>>;
+    locale?: string;
+}
+interface PageTreeTransformer<Config extends SourceConfig = SourceConfig> {
+    file?: (this: PageTreeBuilderContext<Config>, node: Item, filePath?: string) => Item;
+    folder?: (this: PageTreeBuilderContext<Config>, node: Folder, folderPath: string, metaPath?: string) => Folder;
+    separator?: (this: PageTreeBuilderContext<Config>, node: Separator) => Separator;
+    root?: (this: PageTreeBuilderContext<Config>, node: Root) => Root;
+}
+interface PageTreeOptions<Config extends LoaderConfig = LoaderConfig> {
+    id?: string;
+    /**
+     * Remove references to the file path of original nodes (`$ref`)
+     *
+     * @defaultValue false
+     */
+    noRef?: boolean;
+    /**
+     * generate fallback page tree
+     *
+     * @defaultValue true
+     */
+    generateFallback?: boolean;
+    /**
+     * Additional page tree transformers to apply
+     */
+    transformers?: PageTreeTransformer<Config['source']>[];
+}
+interface PageTreeBuilder {
+    build: (storage: ContentStorage, options?: PageTreeOptions) => Root;
+    buildI18n: (storages: Record<string, ContentStorage>, options?: PageTreeOptions) => Record<string, Root>;
+}
+declare function createPageTreeBuilder(loaderConfig: ResolvedLoaderConfig): PageTreeBuilder;
+
+interface LoaderPlugin<Config extends LoaderConfig = LoaderConfig> {
+    name?: string;
+    /**
+     * Change the order of plugin:
+     * - `pre`: before normal plugins
+     * - `post`: after normal plugins
+     */
+    enforce?: 'pre' | 'post';
+    /**
+     * receive & replace loader options
+     */
+    config?: (config: ResolvedLoaderConfig) => ResolvedLoaderConfig | void | undefined;
+    /**
+     * transform the storage after loading
+     */
+    transformStorage?: (context: {
+        storage: ContentStorage<Config['source']>;
+    }) => void;
+    /**
+     * transform the generated page tree
+     */
+    transformPageTree?: PageTreeTransformer<Config['source']>;
+}
+type LoaderPluginOption<Config extends LoaderConfig = LoaderConfig> = LoaderPlugin<Config> | LoaderPluginOption<Config>[] | undefined;
+declare function buildPlugins(plugins: LoaderPluginOption[], sort?: boolean): LoaderPlugin[];
+
+type IconResolver = (icon: string | undefined) => ReactNode;
+
+interface LoaderConfig {
+    source: SourceConfig;
+    i18n: I18nConfig | undefined;
+}
+interface LoaderOptions<C extends LoaderConfig = LoaderConfig> {
+    baseUrl: string;
+    i18n?: C['i18n'];
+    url?: (slugs: string[], locale?: string) => string;
+    /**
+     * Additional options for page tree builder
+     */
+    pageTree?: PageTreeOptions<C>;
+    plugins?: LoaderPluginOption[] | ((context: {
+        typedPlugin: (plugin: LoaderPlugin<C>) => LoaderPlugin;
+    }) => LoaderPluginOption[]);
+    icon?: IconResolver;
+    slugs?: (info: {
+        path: string;
+    }) => string[];
+}
+interface ResolvedLoaderConfig {
+    source: Source;
+    url: (slugs: string[], locale?: string) => string;
+    plugins?: LoaderPlugin[];
+    pageTree?: PageTreeOptions;
+    i18n?: I18nConfig | undefined;
+}
+interface SharedFileInfo {
+    /**
+     * Virtualized file path (relative to content directory)
+     *
+     * @example `docs/page.mdx`
+     */
+    path: string;
+    /**
+     * Absolute path of the file
+     */
+    absolutePath?: string;
+}
+interface Page<Data = PageData> extends SharedFileInfo {
+    slugs: string[];
+    url: string;
+    data: Data;
+    locale?: string | undefined;
+}
+interface Meta<Data = MetaData> extends SharedFileInfo {
+    data: Data;
+}
+interface LoaderOutput<Config extends LoaderConfig> {
+    pageTree: Config['i18n'] extends I18nConfig ? Record<string, Root> : Root;
+    getPageTree: (locale?: string) => Root;
+    getPageByHref: (href: string, options?: {
+        language?: string;
+        /**
+         * resolve relative file paths in `href` from specified dirname, must be a virtual path.
+         */
+        dir?: string;
+    }) => {
+        page: Page<Config['source']['pageData']>;
+        hash?: string;
+    } | undefined;
+    /**
+     * @internal
+     */
+    _i18n?: I18nConfig;
+    /**
+     * Get a list of pages from specified language
+     *
+     * @param language - If empty, list pages from all languages.
+     */
+    getPages: (language?: string) => Page<Config['source']['pageData']>[];
+    /**
+     * get each language and its pages, empty if i18n is not enabled.
+     */
+    getLanguages: () => {
+        language: string;
+        pages: Page<Config['source']['pageData']>[];
+    }[];
+    /**
+     * Get page with slugs, the slugs can also be URI encoded.
+     *
+     * @param language - If empty, the default language will be used
+     */
+    getPage: (slugs: string[] | undefined, language?: string) => Page<Config['source']['pageData']> | undefined;
+    getNodePage: (node: Item, language?: string) => Page<Config['source']['pageData']> | undefined;
+    getNodeMeta: (node: Folder, language?: string) => Meta<Config['source']['metaData']> | undefined;
+    /**
+     * generate static params for Next.js SSG
+     *
+     * @param slug - customise parameter name for slugs
+     * @param lang - customise parameter name for lang
+     */
+    generateParams: <TSlug extends string = 'slug', TLang extends string = 'lang'>(slug?: TSlug, lang?: TLang) => (Record<TSlug, string[]> & Record<TLang, string>)[];
+    /**
+     * serialize page tree for non-RSC environments
+     */
+    serializePageTree: (tree: Root) => Promise<object>;
+}
+declare function createGetUrl(baseUrl: string, i18n?: I18nConfig): ResolvedLoaderConfig['url'];
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(source: Source<Config>, options: LoaderOptions<{
+    source: NoInfer<Config>;
+    i18n: I18n;
+}>): LoaderOutput<{
+    source: Config;
+    i18n: I18n;
+}>;
+declare function loader<Config extends SourceConfig, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<{
+    source: NoInfer<Config>;
+    i18n: I18n;
+}> & {
+    source: Source<Config>;
+}): LoaderOutput<{
+    source: Config;
+    i18n: I18n;
+}>;
+type InferPageType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Page<Config['source']['pageData']> : never;
+type InferMetaType<Utils extends LoaderOutput<any>> = Utils extends LoaderOutput<infer Config> ? Meta<Config['source']['metaData']> : never;
+
+export { type ContentStorage as C, FileSystem as F, type InferPageType as I, type LoaderPlugin as L, type MetaData as M, type PageData as P, type ResolvedLoaderConfig as R, type Source as S, type VirtualFile as V, type _ConfigUnion_ as _, type SourceConfig as a, type LoaderConfig as b, type LoaderOptions as c, type Page as d, type Meta as e, type LoaderOutput as f, createGetUrl as g, type InferMetaType as h, type PageTreeBuilderContext as i, type PageTreeTransformer as j, type PageTreeOptions as k, loader as l, multiple as m, type PageTreeBuilder as n, createPageTreeBuilder as o, type ContentStorageFile as p, buildContentStorage as q, type LoaderPluginOption as r, source as s, buildPlugins as t, update as u };

package/dist/mdx-plugins/codeblock-utils.d.ts

@@ -0,0 +1,29 @@
+import { MdxJsxAttribute, MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+import { BlockContent, Text } from 'mdast';
+
+interface CodeBlockTabsOptions {
+    attributes?: MdxJsxAttribute[];
+    defaultValue?: string;
+    persist?: {
+        id: string;
+    } | false;
+    triggers: {
+        value: string;
+        children: (BlockContent | Text)[];
+    }[];
+    tabs: {
+        value: string;
+        children: BlockContent[];
+    }[];
+}
+declare function generateCodeBlockTabs({ persist, defaultValue, triggers, tabs, ...options }: CodeBlockTabsOptions): MdxJsxFlowElement;
+interface CodeBlockAttributes<Name extends string = string> {
+    attributes: Partial<Record<Name, string | null>>;
+    rest: string;
+}
+/**
+ * Parse Fumadocs-style code block attributes from meta string, like `title="hello world"`
+ */
+declare function parseCodeBlockAttributes<Name extends string = string>(meta: string, allowedNames?: Name[]): CodeBlockAttributes<Name>;
+
+export { type CodeBlockAttributes, type CodeBlockTabsOptions, generateCodeBlockTabs, parseCodeBlockAttributes };

package/dist/mdx-plugins/codeblock-utils.js

@@ -0,0 +1,9 @@
+import {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes
+} from "../chunk-TWIDBWFG.js";
+import "../chunk-U67V476Y.js";
+export {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes
+};

package/dist/mdx-plugins/index.d.ts

@@ -0,0 +1,20 @@
+export { Options as RemarkGfmOptions, default as remarkGfm } from 'remark-gfm';
+export { CodeBlockIcon, RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab } from './rehype-code.js';
+export { RemarkImageOptions, remarkImage } from './remark-image.js';
+export { StructureOptions, StructuredData, remarkStructure, remarkStructureDefaultOptions, structure } from './remark-structure.js';
+export { RemarkHeadingOptions, remarkHeading } from './remark-heading.js';
+export { RemarkAdmonitionOptions, remarkAdmonition } from './remark-admonition.js';
+export { RemarkDirectiveAdmonitionOptions, remarkDirectiveAdmonition } from './remark-directive-admonition.js';
+export { RehypeTocOptions, rehypeToc } from './rehype-toc.js';
+export { RemarkCodeTabOptions, remarkCodeTab } from './remark-code-tab.js';
+export { RemarkStepsOptions, remarkSteps } from './remark-steps.js';
+export { RemarkNpmOptions, remarkNpm } from './remark-npm.js';
+export { CodeBlockAttributes, CodeBlockTabsOptions, generateCodeBlockTabs, parseCodeBlockAttributes } from './codeblock-utils.js';
+export { RemarkMdxFilesOptions, remarkMdxFiles } from './remark-mdx-files.js';
+export { RemarkMdxMermaidOptions, remarkMdxMermaid } from './remark-mdx-mermaid.js';
+import 'hast';
+import '@shikijs/rehype';
+import 'unified';
+import 'shiki';
+import 'mdast';
+import 'mdast-util-mdx-jsx';

package/dist/mdx-plugins/index.js

@@ -0,0 +1,73 @@
+import {
+  remarkImage
+} from "../chunk-5PMI7QDD.js";
+import {
+  remarkMdxFiles
+} from "../chunk-ADBHPKXG.js";
+import {
+  remarkMdxMermaid
+} from "../chunk-FUUVPEA5.js";
+import {
+  remarkNpm
+} from "../chunk-GLRQBLGN.js";
+import {
+  remarkSteps
+} from "../chunk-XJ6ZQNEX.js";
+import {
+  remarkStructure,
+  remarkStructureDefaultOptions,
+  structure
+} from "../chunk-JUF4WZ6G.js";
+import {
+  rehypeCode,
+  rehypeCodeDefaultOptions,
+  transformerIcon,
+  transformerTab
+} from "../chunk-X2HFD5QJ.js";
+import {
+  rehypeToc
+} from "../chunk-EFVXL2PP.js";
+import {
+  remarkAdmonition
+} from "../chunk-W6WTLKRA.js";
+import {
+  remarkCodeTab
+} from "../chunk-CH7YHH7V.js";
+import {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes
+} from "../chunk-TWIDBWFG.js";
+import {
+  remarkDirectiveAdmonition
+} from "../chunk-APKPSBSB.js";
+import {
+  default as default2
+} from "../chunk-ONG4RVCR.js";
+import "../chunk-XN2LKXFZ.js";
+import {
+  remarkHeading
+} from "../chunk-MA6O2UUE.js";
+import "../chunk-VLSDGCJE.js";
+import "../chunk-U67V476Y.js";
+export {
+  generateCodeBlockTabs,
+  parseCodeBlockAttributes,
+  rehypeCode,
+  rehypeCodeDefaultOptions,
+  rehypeToc,
+  remarkAdmonition,
+  remarkCodeTab,
+  remarkDirectiveAdmonition,
+  default2 as remarkGfm,
+  remarkHeading,
+  remarkImage,
+  remarkMdxFiles,
+  remarkMdxMermaid,
+  remarkNpm,
+  remarkSteps,
+  remarkStructure,
+  remarkStructureDefaultOptions,
+  structure,
+  transformerIcon,
+  transformerTab
+};

package/dist/mdx-plugins/rehype-code.d.ts

@@ -0,0 +1,55 @@
+import { Root } from 'hast';
+import { RehypeShikiOptions } from '@shikijs/rehype';
+import { Processor, Transformer } from 'unified';
+import { ShikiTransformer } from 'shiki';
+
+type CodeBlockIcon = {
+    viewBox: string;
+    fill: string;
+    d: string;
+} | string;
+interface IconOptions {
+    shortcuts?: Record<string, string>;
+    extend?: Record<string, CodeBlockIcon>;
+}
+/**
+ * Inject icons to `icon` property (as HTML)
+ */
+declare function transformerIcon(options?: IconOptions): ShikiTransformer;
+
+declare const rehypeCodeDefaultOptions: RehypeCodeOptions;
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+type RehypeCodeOptions = DistributiveOmit<RehypeShikiOptions, 'lazy'> & {
+    /**
+     * Load languages and themes on-demand.
+     * @defaultValue true
+     */
+    lazy?: boolean;
+    /**
+     * The regex engine to use.
+     *
+     * @defaultValue 'js'
+     */
+    engine?: 'js' | 'oniguruma';
+    /**
+     * Filter meta string before processing
+     */
+    filterMetaString?: (metaString: string) => string;
+    /**
+     * Add icon to code blocks
+     */
+    icon?: IconOptions | false;
+    /**
+     * Wrap code blocks in `<Tab>` component when "tab" meta string presents
+     *
+     * @defaultValue true
+     */
+    tab?: boolean;
+};
+/**
+ * Handle codeblocks
+ */
+declare function rehypeCode(this: Processor, _options?: Partial<RehypeCodeOptions>): Transformer<Root, Root>;
+declare function transformerTab(): ShikiTransformer;
+
+export { type CodeBlockIcon, type RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };

package/dist/mdx-plugins/rehype-code.js

@@ -0,0 +1,15 @@
+import {
+  rehypeCode,
+  rehypeCodeDefaultOptions,
+  transformerIcon,
+  transformerTab
+} from "../chunk-X2HFD5QJ.js";
+import "../chunk-TWIDBWFG.js";
+import "../chunk-XN2LKXFZ.js";
+import "../chunk-U67V476Y.js";
+export {
+  rehypeCode,
+  rehypeCodeDefaultOptions,
+  transformerIcon,
+  transformerTab
+};

package/dist/mdx-plugins/rehype-toc.d.ts

@@ -0,0 +1,14 @@
+import { Processor, Transformer } from 'unified';
+import { Root } from 'hast';
+
+interface RehypeTocOptions {
+    /**
+     * Export generated toc as a variable
+     *
+     * @defaultValue true
+     */
+    exportToc?: boolean;
+}
+declare function rehypeToc(this: Processor, { exportToc }?: RehypeTocOptions): Transformer<Root, Root>;
+
+export { type RehypeTocOptions, rehypeToc };

package/dist/mdx-plugins/rehype-toc.js

@@ -0,0 +1,7 @@
+import {
+  rehypeToc
+} from "../chunk-EFVXL2PP.js";
+import "../chunk-U67V476Y.js";
+export {
+  rehypeToc
+};

package/dist/mdx-plugins/remark-admonition.d.ts

@@ -0,0 +1,20 @@
+import { Transformer } from 'unified';
+import { Root } from 'mdast';
+
+interface RemarkAdmonitionOptions {
+    tag?: string;
+    /**
+     * Map type to another type
+     */
+    typeMap?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax
+ *
+ * Useful when Migrating from Docusaurus
+ *
+ * @deprecated Use `remarkDirectiveAdmonition` with `remark-directive` configured instead.
+ */
+declare function remarkAdmonition(options?: RemarkAdmonitionOptions): Transformer<Root, Root>;
+
+export { type RemarkAdmonitionOptions, remarkAdmonition };

package/dist/mdx-plugins/remark-admonition.js

@@ -0,0 +1,8 @@
+import {
+  remarkAdmonition
+} from "../chunk-W6WTLKRA.js";
+import "../chunk-VLSDGCJE.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkAdmonition
+};

package/dist/mdx-plugins/remark-code-tab.d.ts

@@ -0,0 +1,30 @@
+import { Processor, Transformer } from 'unified';
+import { Code, Root } from 'mdast';
+import { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+
+type TabType = keyof typeof Types;
+interface RemarkCodeTabOptions {
+    Tabs?: TabType;
+    /**
+     * Parse MDX in tab values
+     *
+     * @defaultValue false
+     */
+    parseMdx?: boolean;
+}
+declare module 'mdast' {
+    interface CodeData {
+        tab?: string;
+    }
+}
+declare const Types: {
+    CodeBlockTabs: {
+        convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+    };
+    Tabs: {
+        convert(processor: Processor, nodes: Code[], withMdx?: boolean, withParent?: boolean): MdxJsxFlowElement;
+    };
+};
+declare function remarkCodeTab(this: Processor, options?: RemarkCodeTabOptions): Transformer<Root, Root>;
+
+export { type RemarkCodeTabOptions, remarkCodeTab };

package/dist/mdx-plugins/remark-code-tab.js

@@ -0,0 +1,8 @@
+import {
+  remarkCodeTab
+} from "../chunk-CH7YHH7V.js";
+import "../chunk-TWIDBWFG.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkCodeTab
+};

package/dist/mdx-plugins/remark-directive-admonition.d.ts

@@ -0,0 +1,27 @@
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
+
+interface RemarkDirectiveAdmonitionOptions {
+    /**
+     * the tag names of Callout component.
+     */
+    tags?: {
+        CalloutContainer?: string;
+        CalloutTitle?: string;
+        CalloutDescription?: string;
+    };
+    /**
+     * All supported admonition types and their linked Callout type.
+     *
+     * When specified, all defaults will be cleared.
+     */
+    types?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax in Docusaurus, useful for migrating from Docusaurus.
+ *
+ * Requires [`remark-directive`](https://github.com/remarkjs/remark-directive) to be configured.
+ */
+declare function remarkDirectiveAdmonition({ tags: { CalloutContainer, CalloutTitle, CalloutDescription, }, types, }?: RemarkDirectiveAdmonitionOptions): Transformer<Root, Root>;
+
+export { type RemarkDirectiveAdmonitionOptions, remarkDirectiveAdmonition };

package/dist/mdx-plugins/remark-directive-admonition.js

@@ -0,0 +1,7 @@
+import {
+  remarkDirectiveAdmonition
+} from "../chunk-APKPSBSB.js";
+import "../chunk-U67V476Y.js";
+export {
+  remarkDirectiveAdmonition
+};

package/dist/mdx-plugins/remark-gfm.d.ts

@@ -0,0 +1 @@
+export { Options as RemarkGfmOptions, default as remarkGfm } from 'remark-gfm';

package/dist/mdx-plugins/remark-gfm.js

@@ -0,0 +1,7 @@
+import {
+  default as default2
+} from "../chunk-ONG4RVCR.js";
+import "../chunk-U67V476Y.js";
+export {
+  default2 as remarkGfm
+};