@vx-oss/docs-satteri 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/compile-SBpZsgmI.d.ts

@@ -0,0 +1,42 @@
+import { Data, MdxCompileOptions, MdxToJsResult } from "satteri";
+//#region src/compile.d.ts
+type DocumentFormat = 'md' | 'mdx';
+interface CompileMdxOptions {
+  source: string;
+  filePath: string;
+  /**
+   * Which parser to use.
+   *
+   * Defaults to the `filePath` extension, so a `.md` file is not silently given
+   * MDX semantics.
+   */
+  format?: DocumentFormat;
+  frontmatter?: Record<string, unknown>;
+  isDevelopment?: boolean;
+  environment?: 'bundler' | 'runtime';
+  options: MdxCompileOptions;
+}
+type CompileMdxResult = MdxToJsResult;
+type OutputFormat = 'program' | 'function-body';
+interface AfterToJsContext {
+  result: MdxToJsResult;
+  outputFormat: OutputFormat;
+}
+interface CollectExportsContext {
+  data: Data;
+  /** declare `export const <name> = <valueCode>`, a repeated name replaces the earlier one */
+  addExport: (name: string, valueCode: string) => void;
+}
+interface ExtraPluginHooks {
+  /**
+   * Declare module exports. Runs after every plugin has seen the document, so
+   * `data` is final. Exports go into the tree as an ESM node, so the compiler
+   * emits them correctly for either output format.
+   */
+  collectExports?: (opts: CollectExportsContext) => void;
+  /** post-process the generated code, use {@link collectExports} for exports */
+  afterToJs?: (opts: AfterToJsContext) => void;
+}
+declare function compileMdx({ source, filePath, format, frontmatter, isDevelopment, environment, options: { mdastPlugins, hastPlugins, ...satteriOptions } }: CompileMdxOptions): Promise<CompileMdxResult>;
+//#endregion
+export { DocumentFormat as a, compileMdx as c, CompileMdxResult as i, CollectExportsContext as n, ExtraPluginHooks as o, CompileMdxOptions as r, OutputFormat as s, AfterToJsContext as t };

package/dist/compile.d.ts

@@ -0,0 +1,2 @@
+import { a as DocumentFormat, c as compileMdx, i as CompileMdxResult, n as CollectExportsContext, o as ExtraPluginHooks, r as CompileMdxOptions, s as OutputFormat, t as AfterToJsContext } from "./compile-SBpZsgmI.js";
+export { AfterToJsContext, CollectExportsContext, CompileMdxOptions, CompileMdxResult, DocumentFormat, ExtraPluginHooks, OutputFormat, compileMdx };

package/dist/compile.js

@@ -0,0 +1,63 @@
+import { markdownToJs, mdxToJs } from "satteri";
+import { pathToFileURL } from "node:url";
+//#region src/compile.ts
+async function compileMdx({ source, filePath, format = filePath.endsWith(".mdx") ? "mdx" : "md", frontmatter, isDevelopment = false, environment = "bundler", options: { mdastPlugins = [], hastPlugins = [], ...satteriOptions } }) {
+	const data = { ...satteriOptions.data };
+	if (frontmatter) data.frontmatter = frontmatter;
+	const plugins = [...mdastPlugins, ...hastPlugins];
+	const outputFormat = environment === "runtime" ? "function-body" : satteriOptions.outputFormat ?? "program";
+	const compileOptions = {
+		...satteriOptions,
+		mdastPlugins,
+		hastPlugins: [...hastPlugins, exportsPlugin(plugins)],
+		development: isDevelopment,
+		outputFormat,
+		fileURL: satteriOptions.fileURL ?? pathToFileURL(filePath),
+		data,
+		features: {
+			gfm: true,
+			frontmatter: false,
+			directive: true,
+			...satteriOptions.features
+		}
+	};
+	const result = await (format === "md" ? markdownToJs(source, compileOptions) : mdxToJs(source, compileOptions));
+	for (const plugin of plugins) plugin.afterToJs?.({
+		result,
+		outputFormat
+	});
+	return {
+		code: result.code,
+		data: result.data,
+		frontmatter: result.frontmatter
+	};
+}
+/** Emits the exports declared via {@link ExtraPluginHooks.collectExports} once
+*  per document, as an ESM node prepended to the tree. */
+function exportsPlugin(hooks) {
+	return {
+		name: "fd-exports",
+		after(root, ctx) {
+			const statements = /* @__PURE__ */ new Map();
+			const addExport = (name, valueCode) => {
+				statements.set(name, `export const ${name} = ${valueCode};`);
+			};
+			for (const hook of hooks) hook.collectExports?.({
+				data: ctx.data,
+				addExport
+			});
+			const { frontmatter, _valueToExport } = ctx.data;
+			if (frontmatter) addExport("frontmatter", JSON.stringify(frontmatter));
+			if (Array.isArray(_valueToExport)) for (const name of _valueToExport) {
+				if (!(name in ctx.data)) continue;
+				addExport(name, JSON.stringify(ctx.data[name]));
+			}
+			if (statements.size > 0) ctx.prependChild(root, {
+				type: "mdxjsEsm",
+				value: Array.from(statements.values()).join("\n")
+			});
+		}
+	};
+}
+//#endregion
+export { compileMdx };

package/dist/index-AvS9vC2S.d.ts

@@ -0,0 +1,29 @@
+import { n as RehypeTocItemType } from "./rehype-toc-wT8IcPFi.js";
+import { StructuredData } from "@vx-oss/docs-core/mdx-plugins/remark-structure";
+import { TOCItemType } from "@vx-oss/docs-core/toc";
+//#region src/index.d.ts
+/** host compiler hooks (e.g. a bundler loader), used for watch-mode dependency tracking */
+interface CompilerHooks {
+  addDependency: (file: string) => void;
+}
+declare module 'satteri' {
+  interface DataMap {
+    /** `remark-structure` */
+    structuredData?: StructuredData;
+    /** `remark-heading` */
+    toc?: TOCItemType[];
+    /** `rehype-toc` */
+    rehypeToc?: RehypeTocItemType[];
+    /** `remark-llms` */
+    markdown?: string;
+    /** `remark-image` */
+    _imageImports?: string[];
+    _cwd?: string;
+    _compiler?: CompilerHooks;
+    _valueToExport?: string[];
+    frontmatter?: Record<string, unknown>;
+  }
+}
+type BuildEnvironment = 'bundler' | 'runtime';
+//#endregion
+export { CompilerHooks as n, BuildEnvironment as t };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { n as CompilerHooks, t as BuildEnvironment } from "./index-AvS9vC2S.js";
+export { BuildEnvironment, CompilerHooks };

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/local-md/client.d.ts

@@ -0,0 +1,2 @@
+import { i as fromSerialized, n as MarkdownRendererResult, r as MarkdownRendererSerializedOptions, t as MarkdownRenderer } from "../renderer-E5KzV19n.js";
+export { type MarkdownRenderer, type MarkdownRendererResult, type MarkdownRendererSerializedOptions, fromSerialized as rendererFromSerialized };

package/dist/local-md/client.js

@@ -0,0 +1,2 @@
+import { n as fromSerialized } from "../renderer-BtFWPZB8.js";
+export { fromSerialized as rendererFromSerialized };

package/dist/local-md/dev/react-client.d.ts

@@ -0,0 +1,2 @@
+import { DevClient } from "@vx-oss/docs-local-content/dev/ws/react";
+export { DevClient };

package/dist/local-md/dev/react-client.js

@@ -0,0 +1,2 @@
+import { DevClient } from "@vx-oss/docs-local-content/dev/ws/react";
+export { DevClient };

package/dist/local-md/dev/vite.d.ts

@@ -0,0 +1,2 @@
+import { LocalContentPluginOptions, localContentPlugin, watchWithVite } from "@vx-oss/docs-local-content/dev/vite";
+export { type LocalContentPluginOptions, localContentPlugin, watchWithVite };

package/dist/local-md/dev/vite.js

@@ -0,0 +1,2 @@
+import { localContentPlugin, watchWithVite } from "@vx-oss/docs-local-content/dev/vite";
+export { localContentPlugin, watchWithVite };

package/dist/local-md/dev/ws.d.ts

@@ -0,0 +1,2 @@
+import { ConnectOptions, watchWithDevServer } from "@vx-oss/docs-local-content/dev/ws";
+export { type ConnectOptions, watchWithDevServer };

package/dist/local-md/dev/ws.js

@@ -0,0 +1,2 @@
+import { watchWithDevServer } from "@vx-oss/docs-local-content/dev/ws";
+export { watchWithDevServer };

package/dist/local-md/index.d.ts

@@ -0,0 +1,70 @@
+import { t as MarkdownRenderer } from "../renderer-E5KzV19n.js";
+import { StructuredData } from "../remark-structure.js";
+import { n as SatteriPresetOptions } from "../preset-DzMkd76i.js";
+import { SourceOptions, WatchableSource } from "@vx-oss/docs-local-content";
+import * as defaultSchemas from "@vx-oss/docs-core/source/schema";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { DynamicSource, MetaData, PageData, StaticSource } from "@vx-oss/docs-core/source";
+//#region src/local-md/compiler.d.ts
+type SatteriOptionsInput = SatteriPresetOptions | (() => SatteriPresetOptions | Promise<SatteriPresetOptions>);
+interface MarkdownCompilerOptions {
+  /** same shape as `@vx-oss/docs-satteri/preset`, or a function returning it */
+  satteriOptions?: SatteriOptionsInput;
+}
+interface CompileInput {
+  path: string;
+  value: string;
+  data?: {
+    frontmatter?: Record<string, unknown>;
+  };
+}
+interface CompileResult {
+  /** compiled function-body JavaScript. */
+  code: string;
+  filePath: string;
+  structuredData?: StructuredData;
+}
+interface MarkdownCompiler {
+  compile: (input: CompileInput) => Promise<CompileResult>;
+}
+declare function createMarkdownCompiler(config?: MarkdownCompilerOptions): MarkdownCompiler;
+//#endregion
+//#region src/local-md/index.d.ts
+declare const defaultInclude: string[];
+interface SatteriLocalMarkdownConfig<FrontmatterSchema extends StandardSchemaV1, MetaSchema extends StandardSchemaV1> extends MarkdownCompilerOptions {
+  /** root directory for content files */
+  dir: string;
+  /** a list of glob patterns, customize the content files to be scanned */
+  include?: string[];
+  frontmatterSchema?: FrontmatterSchema;
+  metaSchema?: MetaSchema;
+}
+interface SatteriLocalMarkdown<FrontmatterSchema extends StandardSchemaV1, MetaSchema extends StandardSchemaV1> extends WatchableSource {
+  /**
+   * Connect to the standalone dev server for hot reload. On Vite, prefer
+   * `watchWithVite()` from `@vx-oss/docs-local-content/dev/vite`.
+   */
+  devServer: (url?: string) => Promise<void>;
+  staticSource: <ModuleExports = Record<string, unknown>>(options?: SourceOptions) => Promise<StaticSource<{
+    pageData: LocalMarkdownPage<StandardSchemaV1.InferOutput<FrontmatterSchema>, ModuleExports>;
+    metaData: StandardSchemaV1.InferOutput<MetaSchema> & MetaData;
+  }>>;
+  dynamicSource: <ModuleExports = Record<string, unknown>>(options?: SourceOptions) => DynamicSource<{
+    pageData: LocalMarkdownPage<StandardSchemaV1.InferOutput<FrontmatterSchema>, ModuleExports>;
+    metaData: StandardSchemaV1.InferOutput<MetaSchema> & MetaData;
+  }>;
+  invalidateFile: (file: string) => void;
+}
+interface LocalMarkdownPage<Frontmatter = Record<string, unknown>, ModuleExports = Record<string, unknown>> extends PageData {
+  title: string;
+  description?: string;
+  icon?: string;
+  content: string;
+  frontmatter: Frontmatter;
+  /** compile the page, at most once until the file is invalidated */
+  load: () => Promise<MarkdownRenderer<ModuleExports>>;
+  structuredData: () => Promise<StructuredData>;
+}
+declare function localMd<FrontmatterSchema extends StandardSchemaV1 = typeof defaultSchemas.pageSchema, MetaSchema extends StandardSchemaV1 = typeof defaultSchemas.metaSchema>(config: SatteriLocalMarkdownConfig<FrontmatterSchema, MetaSchema>): SatteriLocalMarkdown<FrontmatterSchema, MetaSchema>;
+//#endregion
+export { type CompileResult, LocalMarkdownPage, type MarkdownCompiler, type MarkdownCompilerOptions, type MarkdownRenderer, SatteriLocalMarkdown, SatteriLocalMarkdownConfig, createMarkdownCompiler, defaultInclude, localMd };

package/dist/local-md/index.js

@@ -0,0 +1,104 @@
+import { t as applySatteriPreset } from "../preset-DdTDKnqd.js";
+import { compileMdx } from "../compile.js";
+import { t as fromJS } from "../renderer-BtFWPZB8.js";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createLocalSource } from "@vx-oss/docs-local-content";
+import { frontmatter } from "@vx-oss/docs-core/content/md/frontmatter";
+import * as defaultSchemas from "@vx-oss/docs-core/source/schema";
+//#region src/local-md/compiler.ts
+async function resolveOptions(input) {
+	const options = typeof input === "function" ? await input() : input;
+	return applySatteriPreset(options)("runtime");
+}
+function createMarkdownCompiler(config = {}) {
+	let resolved;
+	return { async compile(input) {
+		resolved ??= resolveOptions(config.satteriOptions);
+		const options = await resolved;
+		const result = await compileMdx({
+			source: input.value,
+			filePath: input.path,
+			format: input.path.endsWith(".mdx") ? "mdx" : "md",
+			frontmatter: input.data?.frontmatter,
+			environment: "runtime",
+			options: {
+				...options,
+				data: { ...options.data }
+			}
+		});
+		return {
+			code: result.code,
+			filePath: input.path,
+			structuredData: result.data.structuredData
+		};
+	} };
+}
+//#endregion
+//#region src/local-md/index.ts
+const defaultInclude = ["**/*.{md,mdx,json}"];
+function localMd(config) {
+	const { include = defaultInclude, frontmatterSchema = defaultSchemas.pageSchema, metaSchema = defaultSchemas.metaSchema } = config;
+	const compiler = createMarkdownCompiler(config);
+	async function compile(file, content, frontmatter) {
+		const res = await compiler.compile({
+			path: file.absolutePath,
+			value: content,
+			data: { frontmatter }
+		});
+		return fromJS({
+			code: res.code,
+			filePath: res.filePath,
+			baseUrl: pathToFileURL(res.filePath).href,
+			structuredData: res.structuredData
+		});
+	}
+	async function page(file) {
+		const parsed = frontmatter(await file.read());
+		const result = await frontmatterSchema["~standard"].validate(parsed.data);
+		if (result.issues) throw new Error(`invalid frontmatter in "${file.absolutePath}": ${formatIssues(result.issues)}`);
+		const frontmatter$1 = result.value;
+		const pageData = frontmatter$1;
+		let loaded;
+		const load = () => loaded ??= compile(file, parsed.content, frontmatter$1);
+		return {
+			title: pageData.title ?? path.basename(file.path, path.extname(file.path)),
+			description: pageData.description,
+			icon: pageData.icon,
+			["_openapi"]: pageData._openapi,
+			content: parsed.content,
+			frontmatter: frontmatter$1,
+			load,
+			structuredData: async () => (await load()).structuredData
+		};
+	}
+	async function meta(file) {
+		const result = await metaSchema["~standard"].validate(JSON.parse(await file.read()));
+		if (result.issues) throw new Error(`invalid data in "${file.absolutePath}": ${formatIssues(result.issues)}`);
+		return result.value;
+	}
+	return createLocalSource({
+		dir: config.dir,
+		integration: {
+			include,
+			async parse(file) {
+				switch (path.extname(file.path)) {
+					case ".json": return {
+						type: "meta",
+						data: await meta(file)
+					};
+					case ".md":
+					case ".mdx": return {
+						type: "page",
+						data: await page(file)
+					};
+				}
+			}
+		}
+	});
+}
+function formatIssues(issues) {
+	return issues.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("\n");
+}
+//#endregion
+export { createMarkdownCompiler, defaultInclude, localMd };

package/dist/preset-DdTDKnqd.js

@@ -0,0 +1,104 @@
+import { remarkHeading } from "./remark-heading.js";
+import { remarkImage } from "./remark-image.js";
+import { remarkCodeTab } from "./remark-code-tab.js";
+import { remarkNpm } from "./remark-npm.js";
+import { remarkStructure } from "./remark-structure.js";
+import { rehypeCode } from "./rehype-code.js";
+import { rehypeToc } from "./rehype-toc.js";
+import { rehypeKatex } from "./rehype-katex.js";
+import { defineHastPlugin } from "satteri";
+//#region src/rehype-table.ts
+const TABLE_STRUCTURE = [
+	"table",
+	"thead",
+	"tbody",
+	"tfoot",
+	"tr"
+];
+function isWhitespaceText(node) {
+	return node.type === "text" && (node.value ?? "").trim().length === 0;
+}
+function rehypeTable() {
+	return defineHastPlugin({
+		name: "rehype-table",
+		element: {
+			filter: TABLE_STRUCTURE,
+			visit(node, ctx) {
+				const element = node;
+				for (let i = element.children.length - 1; i >= 0; i--) if (isWhitespaceText(element.children[i])) ctx.removeChildAt(element, i);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/preset.ts
+function pluginOption(def, options = []) {
+	const list = def(Array.isArray(options) ? options : []).filter(Boolean);
+	if (typeof options === "function") return options(list);
+	return list;
+}
+const RESOLVED_PRESET = Symbol.for("fumadocs.satteri.resolved-preset");
+function applySatteriPreset(options = {}) {
+	return async (environment = "bundler") => {
+		if (RESOLVED_PRESET in options) {
+			const resolved = options;
+			return {
+				...resolved,
+				outputFormat: environment === "runtime" ? "function-body" : resolved.outputFormat
+			};
+		}
+		if (options.preset === "minimal") {
+			const { preset: _preset, ...rest } = options;
+			return markResolved({
+				...rest,
+				outputFormat: environment === "runtime" ? "function-body" : rest.outputFormat
+			});
+		}
+		const { valueToExport = [], rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, remarkCodeTabOptions, remarkNpmOptions, rehypeKatexOptions, mdastPlugins, hastPlugins, features, data, ...rest } = options;
+		const resolvedMdast = pluginOption((plugins) => [
+			remarkHeading({
+				generateToc: false,
+				...remarkHeadingOptions
+			}),
+			remarkImageOptions !== false && remarkImage(remarkImageOptions),
+			remarkCodeTabOptions !== false && remarkCodeTab(remarkCodeTabOptions),
+			remarkNpmOptions !== false && remarkNpm(remarkNpmOptions),
+			...plugins,
+			remarkStructureOptions !== false && remarkStructure({
+				exportAs: "structuredData",
+				...remarkStructureOptions
+			})
+		], mdastPlugins);
+		const resolvedHast = pluginOption((plugins) => [
+			Boolean(features?.math) && rehypeKatexOptions !== false && rehypeKatex(rehypeKatexOptions),
+			rehypeCodeOptions !== false && rehypeCode({
+				tab: false,
+				...rehypeCodeOptions
+			}),
+			...plugins,
+			rehypeTable(),
+			rehypeToc()
+		], hastPlugins);
+		return markResolved({
+			...rest,
+			data: {
+				...data,
+				...valueToExport.length > 0 ? { _valueToExport: valueToExport } : {}
+			},
+			outputFormat: environment === "runtime" ? "function-body" : rest.outputFormat,
+			features: {
+				gfm: true,
+				directive: true,
+				...features
+			},
+			mdastPlugins: resolvedMdast,
+			hastPlugins: resolvedHast
+		});
+	};
+}
+function markResolved(options) {
+	Object.defineProperty(options, RESOLVED_PRESET, { value: true });
+	return options;
+}
+//#endregion
+export { applySatteriPreset as t };

package/dist/preset-DzMkd76i.d.ts

@@ -0,0 +1,35 @@
+import { t as BuildEnvironment } from "./index-AvS9vC2S.js";
+import { StructureOptions } from "./remark-structure.js";
+import { t as RemarkHeadingOptions } from "./remark-heading-CYhI2Dkg.js";
+import { t as RemarkImageOptions } from "./remark-image-C28nbosW.js";
+import { t as RemarkCodeTabOptions } from "./remark-code-tab-BYruQJUs.js";
+import { t as RemarkNpmOptions } from "./remark-npm-DdmTKhyi.js";
+import { t as RehypeCodeOptions } from "./rehype-code-CLGqDUSe.js";
+import { t as RehypeKatexOptions } from "./rehype-katex-h_E-WUwT.js";
+import { HastPluginInput, MdastPluginInput, MdxCompileOptions, MdxOnlyOptions } from "satteri";
+//#region src/preset.d.ts
+type ResolvePlugins<T> = readonly T[] | ((plugins: T[]) => T[]);
+type DefaultSatteriOptions = Omit<MdxCompileOptions, 'mdastPlugins' | 'hastPlugins'> & {
+  mdastPlugins?: ResolvePlugins<MdastPluginInput>;
+  hastPlugins?: ResolvePlugins<HastPluginInput>;
+  valueToExport?: string[];
+  remarkStructureOptions?: StructureOptions | false;
+  remarkHeadingOptions?: RemarkHeadingOptions;
+  remarkImageOptions?: RemarkImageOptions | false;
+  remarkCodeTabOptions?: RemarkCodeTabOptions | false;
+  remarkNpmOptions?: RemarkNpmOptions | false;
+  rehypeCodeOptions?: RehypeCodeOptions | false;
+  /**
+   * KaTeX rendering, applied only when the `math` feature is enabled. Pass
+   * options to customize it, or `false` to keep math unrendered.
+   */
+  rehypeKatexOptions?: RehypeKatexOptions | false;
+};
+type SatteriPresetOptions = ({
+  preset?: 'fumadocs';
+} & DefaultSatteriOptions) | ({
+  preset: 'minimal';
+} & MdxOnlyOptions & Pick<MdxCompileOptions, 'mdastPlugins' | 'hastPlugins' | 'features' | 'data'>);
+declare function applySatteriPreset(options?: SatteriPresetOptions): (environment: BuildEnvironment) => Promise<MdxCompileOptions>;
+//#endregion
+export { SatteriPresetOptions as n, applySatteriPreset as r, DefaultSatteriOptions as t };

package/dist/preset.d.ts

@@ -0,0 +1,2 @@
+import { n as SatteriPresetOptions, r as applySatteriPreset, t as DefaultSatteriOptions } from "./preset-DzMkd76i.js";
+export { DefaultSatteriOptions, SatteriPresetOptions, applySatteriPreset };

package/dist/preset.js

@@ -0,0 +1,2 @@
+import { t as applySatteriPreset } from "./preset-DdTDKnqd.js";
+export { applySatteriPreset };

package/dist/rehype-code-CLGqDUSe.d.ts

@@ -0,0 +1,13 @@
+import { HastVisitorContext } from "satteri";
+import { RehypeCodeOptions, RehypeCodeOptions as RehypeCodeOptions$1 } from "@vx-oss/docs-core/mdx-plugins/rehype-code";
+import { Element } from "hast";
+//#region src/rehype-code.d.ts
+declare function rehypeCode$1(options?: Partial<RehypeCodeOptions>): {
+  name: string;
+  element: {
+    filter: string[];
+    visit(element: Readonly<Element>, ctx: HastVisitorContext): Promise<void>;
+  };
+};
+//#endregion
+export { rehypeCode$1 as n, RehypeCodeOptions$1 as t };

package/dist/rehype-code.d.ts

@@ -0,0 +1,2 @@
+import { n as rehypeCode, t as RehypeCodeOptions } from "./rehype-code-CLGqDUSe.js";
+export { type RehypeCodeOptions, rehypeCode };

package/dist/rehype-code.js

@@ -0,0 +1,79 @@
+import { defineHastPlugin } from "satteri";
+import { rehypeCode as rehypeCode$1 } from "@vx-oss/docs-core/mdx-plugins/rehype-code";
+//#region src/rehype-code.ts
+function unwrapReplacement(node) {
+	if (node.type === "root") return node.children;
+	return node;
+}
+const ATTRIBUTE_TO_PROP = {
+	class: "className",
+	tabindex: "tabIndex",
+	readonly: "readOnly",
+	contenteditable: "contentEditable"
+};
+function normalizeProperties(node) {
+	if (node.type === "element" && node.properties) {
+		for (const [attribute, prop] of Object.entries(ATTRIBUTE_TO_PROP)) if (attribute in node.properties) {
+			node.properties[prop] ??= node.properties[attribute];
+			delete node.properties[attribute];
+		}
+	}
+	if ("children" in node) for (const child of node.children) normalizeProperties(child);
+}
+function replaceHighlightedNode(element, next, ctx) {
+	if (!next) return;
+	const replacement = unwrapReplacement(next);
+	if (Array.isArray(replacement)) {
+		if (replacement.length === 0) return;
+		ctx.replaceNode(element, replacement[0]);
+		if (replacement.length > 1) ctx.insertAfter(element, replacement.slice(1));
+		return;
+	}
+	ctx.replaceNode(element, replacement);
+}
+function elementClasses(element) {
+	const className = element.properties.className;
+	if (Array.isArray(className)) return className.map(String);
+	if (typeof className === "string") return className.split(/\s+/);
+	return [];
+}
+const skipClasses = /* @__PURE__ */ new Set([
+	"shiki",
+	"language-math",
+	"math-inline",
+	"math-display"
+]);
+function shouldSkipHighlight(element) {
+	if (elementClasses(element).some((c) => skipClasses.has(c))) return true;
+	if (element.tagName === "pre") {
+		for (const child of element.children) if (child.type === "element" && shouldSkipHighlight(child)) return true;
+	}
+	return false;
+}
+function rehypeCode(options) {
+	const runBlock = rehypeCode$1.call({}, options);
+	const inline = options?.inline;
+	return defineHastPlugin({
+		name: "rehype-code",
+		element: {
+			filter: ["pre", "code"],
+			async visit(element, ctx) {
+				if (shouldSkipHighlight(element)) return;
+				if (element.tagName !== "pre" && !(element.tagName === "code" && inline)) return;
+				if (element.tagName === "code") {
+					const parent = ctx.parent(element);
+					if (parent?.type === "element" && parent.tagName === "pre") return;
+				}
+				const tree = {
+					type: "root",
+					children: [element]
+				};
+				await runBlock(tree, null, () => void 0);
+				normalizeProperties(tree);
+				replaceHighlightedNode(element, tree.children[0], ctx);
+			}
+		}
+	});
+}
+//#endregion
+export { rehypeCode };

package/dist/rehype-katex-h_E-WUwT.d.ts

@@ -0,0 +1,15 @@
+import { HastPluginDefinition } from "satteri";
+import { KatexOptions } from "katex";
+//#region src/rehype-katex.d.ts
+type RehypeKatexOptions = Omit<KatexOptions, 'displayMode' | 'throwOnError'>;
+/**
+ * Render `$…$`, `$$…$$`, and ```` ```math ```` blocks to KaTeX markup — the
+ * Satteri counterpart of `rehype-katex`. Satteri's `math` feature parses the
+ * syntax into `<code class="language-math …">` elements (raw TeX); this renders
+ * them.
+ *
+ * The preset adds this to the hast pipeline when `math` is enabled.
+ */
+declare function rehypeKatex(options?: RehypeKatexOptions): () => HastPluginDefinition;
+//#endregion
+export { rehypeKatex as n, RehypeKatexOptions as t };

package/dist/rehype-katex.d.ts

@@ -0,0 +1,2 @@
+import { n as rehypeKatex, t as RehypeKatexOptions } from "./rehype-katex-h_E-WUwT.js";
+export { RehypeKatexOptions, rehypeKatex };