@erudit-js/prose 3.0.0-dev.25

package/dist/elements/math/_global.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Inliner math is used to display mathematical expressions within a line of text.
+ * It supports line breaks and has a faint of brand color to distinguish it from regular text.
+ *
+ * **Caution:** Never write long mathematical expressions in inliner math because it looks horrible.
+ * Use it for variables, numbers, or short two to three term expressions only.
+ *
+ * Math is written using [LaTeX syntax](https://www.latex-project.org/) and rendered using [KaTeX](https://katex.org/docs/supported.html).
+ *
+ * You can also use nice colors in your math expressions:
+ * * `\brand{...}`
+ * * `\blue{...}`
+ * * `\green{...}`
+ * * `\yellow{...}`
+ * * `\red{...}`
+ * * `\default{...}` (to reset to default color)
+ *
+ * @title Inliner Math
+ * @layout inliner
+ * @example
+ * ```tsx
+ * <>
+ *   We need variables <M>x</M> and <M>y</M>.
+ *   They are wrapped in square roots <M>{math`\sqrt{x}`}</M> and <M>{math`\sqrt{y}`}</M>.
+ * </>
+ * ```
+ */
+export const M = '_tag_';
+
+/**
+ * Block math is used to display mathematical expressions as separate blocks.
+ * Use it for larger equations that need to be centered and stand out from the main text.
+ *
+ * Math is written using [LaTeX syntax](https://www.latex-project.org/) and rendered using [KaTeX](https://katex.org/docs/supported.html).
+ *
+ * You can also use nice colors in your math expressions:
+ * * `\brand{...}`
+ * * `\blue{...}`
+ * * `\green{...}`
+ * * `\yellow{...}`
+ * * `\red{...}`
+ * * `\default{...}` (to reset to default color)
+ *
+ * Use `freeze` prop to prevent line breaks in the rendered math (scrollbars will appear if the content overflows).
+ *
+ * @title Block Math
+ * @layout block
+ * @example
+ * ```tsx
+ * <BlockMath>{math`
+ *   A^2 + \green{B^2} = \brand{C^2}
+ * `}</BlockMath>
+ *
+ * <BlockMath freeze>{math`
+ *   \lim\limits_{x \to \infty} \frac{1}{x} = 0
+ * `}</BlockMath>
+ * ```
+ */
+export const BlockMath = '_tag_';
+
+/**
+ * Math template tag function for writing LaTeX math expressions.
+ * It allows not to escape backslashes in LaTeX commands.
+ *
+ * @example
+ * ```tsx
+ * const bad = `\\frac{a}{b}`;
+ * // But
+ * const good = math`\frac{a}{b}`;
+ * ```
+ */
+export const math: typeof String.raw;

package/dist/elements/math/_global.ts

@@ -0,0 +1,3 @@
+export default {
+    math: String.raw,
+};

package/dist/elements/math/app.d.ts

@@ -0,0 +1,16 @@
+declare const _default: (import("../../app/appElement.js").AppElement<{
+    name: "blockMath";
+    type: "block";
+    linkable: true;
+    Data: import("./block.js").BlockMathData;
+    Storage: import("./block.js").MathGroup;
+    Children: undefined;
+}> | import("../../app/appElement.js").AppElement<{
+    name: "inlinerMath";
+    type: "inliner";
+    linkable: true;
+    Data: string;
+    Storage: import("./inliner.js").InlinerMathStorage;
+    Children: undefined;
+}>)[];
+export default _default;

package/dist/elements/math/app.js

@@ -0,0 +1,20 @@
+import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { blockMathSchema } from "./block.js";
+import { inlinerMathSchema } from "./inliner.js";
+export default [defineEruditProseAppElement({
+	schema: blockMathSchema,
+	component: () => import("./components/BlockMath.vue"),
+	languages: {
+		en: () => import("./languages/en.js"),
+		ru: () => import("./languages/ru.js")
+	},
+	icon: () => import("./icon.svg?raw")
+}), defineEruditProseAppElement({
+	schema: inlinerMathSchema,
+	component: () => import("./components/InlinerMath.vue"),
+	languages: {
+		en: () => import("./languages/en.js"),
+		ru: () => import("./languages/ru.js")
+	},
+	icon: () => import("./icon.svg?raw")
+})];

package/dist/elements/math/block.d.ts

@@ -0,0 +1,75 @@
+import { type TagChildren } from '@jsprose/core';
+export declare const mathGroupTypes: readonly ["zero", "normal", "big"];
+export type MathGroupGapType = (typeof mathGroupTypes)[number] | 'custom';
+export interface MathGroupGapTemplate {
+    type: MathGroupGapType;
+}
+export interface MathGroupGapNone extends MathGroupGapTemplate {
+    type: 'zero';
+}
+export interface MathGroupGapNormal extends MathGroupGapTemplate {
+    type: 'normal';
+}
+export interface MathGroupGapBig extends MathGroupGapTemplate {
+    type: 'big';
+}
+export interface MathGroupGapCustom extends MathGroupGapTemplate {
+    type: 'custom';
+    size: string;
+}
+export type MathGroupGap = MathGroupGapNone | MathGroupGapNormal | MathGroupGapBig | MathGroupGapCustom;
+export type MathGroupPart = string | MathGroup;
+export interface MathGroup {
+    gap: MathGroupGap;
+    parts: MathGroupPart[];
+}
+export declare function resolveMathGroups(katex: string, isTopLevel?: boolean): Promise<MathGroup | string>;
+export interface BlockMathData {
+    katex: string;
+    freeze?: boolean;
+}
+export declare const blockMathSchema: {
+    name: "blockMath";
+    type: "block";
+    linkable: true;
+    Data: BlockMathData;
+    Storage: MathGroup;
+    Children: undefined;
+};
+export declare const BlockMath: import("@jsprose/core").Tag<"BlockMath", {
+    name: "blockMath";
+    type: "block";
+    linkable: true;
+    Data: BlockMathData;
+    Storage: MathGroup;
+    Children: undefined;
+}, {
+    freeze?: boolean;
+} & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+export declare const blockMathRegistryItem: import("@jsprose/core").RegistryItem<{
+    name: "blockMath";
+    type: "block";
+    linkable: true;
+    Data: BlockMathData;
+    Storage: MathGroup;
+    Children: undefined;
+}, {
+    BlockMath: import("@jsprose/core").Tag<"BlockMath", {
+        name: "blockMath";
+        type: "block";
+        linkable: true;
+        Data: BlockMathData;
+        Storage: MathGroup;
+        Children: undefined;
+    }, {
+        freeze?: boolean;
+    } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+}, (element: import("@jsprose/core").ProseElement<{
+    name: "blockMath";
+    type: "block";
+    linkable: true;
+    Data: BlockMathData;
+    Storage: MathGroup;
+    Children: undefined;
+}>) => Promise<MathGroup>>;
+export declare function createBlockMathStorage(katex: string): Promise<MathGroup>;

package/dist/elements/math/block.js

@@ -0,0 +1,115 @@
+import { defineRegistryItem, defineSchema, ensureTagChild, ProseError, textSchema } from "@jsprose/core";
+import { latexToHtml, normalizeKatex } from "./katex.js";
+import { defineEruditTag } from "../../tag.js";
+export const mathGroupTypes = [
+	"zero",
+	"normal",
+	"big"
+];
+function gapFromString(strGap) {
+	if (mathGroupTypes.includes(strGap)) {
+		return { type: strGap };
+	}
+	return {
+		type: "custom",
+		size: strGap
+	};
+}
+function gapsEqual(gap1, gap2) {
+	if (gap1.type !== gap2.type) {
+		return false;
+	}
+	if (gap1.type === "custom" && gap2.type === "custom") {
+		return gap1.size === gap2.size;
+	}
+	return true;
+}
+export async function resolveMathGroups(katex, isTopLevel = true) {
+	// If whole string does not contain any groups, return default group with rendered math
+	if (!katex.includes(">>")) {
+		const rendered = await latexToHtml(katex, "block");
+		if (isTopLevel) {
+			// Only top-level should return a group
+			return {
+				gap: { type: "normal" },
+				parts: [rendered]
+			};
+		}
+		// Recursive left side should return a plain string
+		return rendered;
+	}
+	// Find the rightmost delimiter and its gap specification
+	const delimiterRegex = />>(?:\{([^}]+)\})?/g;
+	let match;
+	let lastDelimiterMatch;
+	while ((match = delimiterRegex.exec(katex)) !== null) {
+		lastDelimiterMatch = match;
+	}
+	// Extract gap
+	const gap = gapFromString(lastDelimiterMatch[1] || "normal");
+	// Calculate positions
+	const lastDelimiterPos = lastDelimiterMatch.index;
+	const lastDelimiterLen = lastDelimiterMatch[0].length;
+	// Split the katex string
+	const leftPart = katex.slice(0, lastDelimiterPos);
+	const rightPart = katex.slice(lastDelimiterPos + lastDelimiterLen);
+	// Pushing rendered right part
+	const parts = [await latexToHtml(rightPart, "block")];
+	// Resolving left part
+	const leftGroup = await resolveMathGroups(leftPart, false);
+	if (typeof leftGroup === "string") {
+		parts.unshift(leftGroup);
+	} else {
+		// Left part is a group, meaning it contains gaps
+		if (gapsEqual(leftGroup.gap, gap)) {
+			// If gaps are equal, we can merge the two groups into (current) one
+			parts.unshift(...leftGroup.parts);
+		} else {
+			// Gaps are different, we need to keep the left group as is
+			parts.unshift(leftGroup);
+		}
+	}
+	return {
+		gap,
+		parts
+	};
+}
+export const blockMathSchema = defineSchema({
+	name: "blockMath",
+	type: "block",
+	linkable: true
+})();
+export const BlockMath = defineEruditTag({
+	tagName: "BlockMath",
+	schema: blockMathSchema
+})(({ element, tagName, props, children }) => {
+	ensureTagChild(tagName, children, textSchema);
+	const katex = normalizeKatex(children[0].data);
+	if (!katex) {
+		throw new ProseError(`<${tagName}> tag must contain non-empty KaTeX math expression.`);
+	}
+	element.data = {
+		katex,
+		freeze: props.freeze === true
+	};
+	element.storageKey = `$$ ${katex} $$`;
+});
+export const blockMathRegistryItem = defineRegistryItem({
+	schema: blockMathSchema,
+	tags: [BlockMath],
+	async createStorage(element) {
+		return createBlockMathStorage(element.data.katex);
+	}
+});
+export async function createBlockMathStorage(katex) {
+	let result = {
+		gap: { type: "normal" },
+		parts: ["<span style=\"color: red\">KaTeX Error!</span>"]
+	};
+	try {
+		result = await resolveMathGroups(katex);
+	} catch (error) {
+		console.error("Error while rendering math:", error);
+	}
+	return result;
+}

package/dist/elements/math/components/BlockMath.vue

@@ -0,0 +1,30 @@
+<script lang="ts" setup>
+import type { ProseElement } from '@jsprose/core';
+
+import {
+    type blockMathSchema,
+    type MathGroup as _MathGroup,
+    createBlockMathStorage,
+} from '../block.js';
+import { useElementStorage } from '../../../app/composables/storage.js';
+import MathGroup from './MathGroup.vue';
+import Block from '../../../app/shared/block/Block.vue';
+
+const { element } = defineProps<{
+    element: ProseElement<typeof blockMathSchema>;
+}>();
+
+const blockMathStorage =
+    (await useElementStorage<typeof blockMathSchema>(element)) ??
+    (await createBlockMathStorage(element.data.katex));
+
+const mathGroup: _MathGroup = blockMathStorage;
+</script>
+
+<template>
+    <Block :element>
+        <div :style="{ '--mathRowGap': '.6em' }">
+            <MathGroup :mathGroup :freeze="Boolean(element.data.freeze)" />
+        </div>
+    </Block>
+</template>

package/dist/elements/math/components/InlinerMath.vue

@@ -0,0 +1,65 @@
+<script lang="ts" setup>
+import 'katex/dist/katex.min.css';
+import type { ProseElement } from '@jsprose/core';
+
+import Inliner from '../../../app/shared/inliner/Inliner.vue';
+import {
+    createInlinerMathStorage,
+    type inlinerMathSchema,
+} from '../inliner.js';
+import { useElementStorage } from '../../../app/composables/storage.js';
+import Katex from './Katex.vue';
+
+const { element } = defineProps<{
+    element: ProseElement<typeof inlinerMathSchema>;
+}>();
+
+const inlinerMathStorage =
+    (await useElementStorage<typeof inlinerMathSchema>(element)) ??
+    (await createInlinerMathStorage(element.data));
+</script>
+
+<template>
+    <Inliner :element>
+        <template v-if="inlinerMathStorage.type === 'text'">
+            <span :class="[$style.inlinerMath, $style.textMath]">
+                <template v-for="token of inlinerMathStorage.tokens">
+                    <span :class="{ [$style.word]: token.type === 'word' }">
+                        {{ token.value }}
+                    </span>
+                </template>
+            </span>
+        </template>
+        <Katex
+            v-else
+            :class="$style.inlinerMath"
+            :math="inlinerMathStorage.mathHtml"
+            mode="inline"
+            :freeze="false"
+        />
+    </Inliner>
+</template>
+
+<style module>
+.inlinerMath {
+    --katex-color_default: light-dark(
+        color-mix(in hsl, var(--color-text-muted), var(--color-brand) 35%),
+        color-mix(in hsl, var(--color-text), var(--color-brand) 30%)
+    );
+}
+
+.textMath {
+    font:
+        normal 1.15em KaTeX_Main,
+        Times New Roman,
+        serif;
+    line-height: 1.2;
+    text-indent: 0;
+    color: var(--katex-color_default);
+
+    .word {
+        font-family: KaTeX_Math;
+        font-style: italic;
+    }
+}
+</style>

package/dist/elements/math/components/Katex.vue

@@ -0,0 +1,89 @@
+<script lang="ts" setup>
+import { h } from 'vue';
+import 'katex/dist/katex.min.css';
+
+const { mode, math, freeze } = defineProps<{
+    mode: 'inline' | 'block';
+    math: string;
+    freeze: boolean;
+}>();
+
+const MathComponent = h(mode === 'block' ? 'div' : 'span', {
+    innerHTML: math,
+});
+</script>
+
+<template>
+    <component
+        :is="MathComponent"
+        v-once
+        :class="[
+            $style.math,
+            {
+                [`nice-scrollbars overflow-auto ${$style.blockMath}`]:
+                    mode === 'block',
+                [$style.freeze]: freeze,
+            },
+        ]"
+    />
+</template>
+
+<style module>
+.math {
+    --katex-color_brand: var(--color-brand);
+    --katex-color_blue: light-dark(#0f82ff, #4aa0df);
+    --katex-color_green: light-dark(#519f19, #83c167);
+    --katex-color_yellow: light-dark(#c99029, #c1a267);
+    --katex-color_red: light-dark(#d73737, #fc6255);
+    --katex-color_default: var(--color-text);
+
+    color: var(--katex-color_default);
+
+    /* Map KaTeX color codes to CSS variables */
+    [style*='color:#100000'] {
+        color: var(--katex-color_brand) !important;
+    }
+    [style*='color:#200000'] {
+        color: var(--katex-color_blue) !important;
+    }
+    [style*='color:#300000'] {
+        color: var(--katex-color_green) !important;
+    }
+    [style*='color:#400000'] {
+        color: var(--katex-color_yellow) !important;
+    }
+    [style*='color:#500000'] {
+        color: var(--katex-color_red) !important;
+    }
+    [style*='color:#600000'] {
+        color: var(--katex-color_default) !important;
+    }
+}
+
+.blockMath {
+    overflow-x: auto;
+    overflow-y: hidden;
+
+    :global(.katex-display) {
+        margin: 0;
+        margin-top: calc(-1 * var(--mathRowGap));
+    }
+
+    :global(.base) {
+        margin-top: var(--mathRowGap);
+        padding-bottom: 1px;
+    }
+
+    &:not(.freeze) {
+        :global(.katex-display > .katex) {
+            max-width: 100% !important;
+            overflow: hidden !important;
+            white-space: normal !important;
+        }
+    }
+
+    &.freeze {
+        min-width: 0;
+    }
+}
+</style>

package/dist/elements/math/components/MathGroup.vue

@@ -0,0 +1,39 @@
+<script lang="ts" setup>
+import type { MathGroup } from '../block.js';
+import Katex from './Katex.vue';
+
+const { mathGroup } = defineProps<{
+    mathGroup: MathGroup;
+    freeze: boolean;
+}>();
+
+const columnGap = (() => {
+    switch (mathGroup.gap.type) {
+        case 'zero':
+            return '0px';
+        case 'normal':
+            return 'var(--proseAsideWidth)';
+        case 'big':
+            return 'calc(var(--proseAsideWidth) * 2)';
+        case 'custom':
+            return mathGroup.gap.size;
+    }
+})();
+</script>
+
+<template>
+    <div
+        :style="{ columnGap }"
+        class="flex flex-wrap items-center justify-center gap-y-(--mathRowGap)"
+    >
+        <template v-for="part of mathGroup.parts">
+            <Katex
+                v-if="typeof part === 'string'"
+                mode="block"
+                :math="part"
+                :freeze
+            />
+            <MathGroup v-else :mathGroup="part" :freeze="freeze" />
+        </template>
+    </div>
+</template>

package/dist/elements/math/core.d.ts

@@ -0,0 +1,66 @@
+declare const _default: [{
+    registryItem: import("@jsprose/core").RegistryItem<{
+        name: "inlinerMath";
+        type: "inliner";
+        linkable: true;
+        Data: string;
+        Storage: import("./inliner.js").InlinerMathStorage;
+        Children: undefined;
+    }, {
+        M: import("@jsprose/core").Tag<"M", {
+            name: "inlinerMath";
+            type: "inliner";
+            linkable: true;
+            Data: string;
+            Storage: import("./inliner.js").InlinerMathStorage;
+            Children: undefined;
+        }, import("@jsprose/core").TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+    }, (element: import("@jsprose/core").ProseElement<{
+        name: "inlinerMath";
+        type: "inliner";
+        linkable: true;
+        Data: string;
+        Storage: import("./inliner.js").InlinerMathStorage;
+        Children: undefined;
+    }>) => Promise<import("./inliner.js").InlinerMathStorage>>;
+    dependencies: {
+        katex: {
+            optimise: boolean;
+            transpile: boolean;
+        };
+    };
+}, {
+    registryItem: import("@jsprose/core").RegistryItem<{
+        name: "blockMath";
+        type: "block";
+        linkable: true;
+        Data: import("./block.js").BlockMathData;
+        Storage: import("./block.js").MathGroup;
+        Children: undefined;
+    }, {
+        BlockMath: import("@jsprose/core").Tag<"BlockMath", {
+            name: "blockMath";
+            type: "block";
+            linkable: true;
+            Data: import("./block.js").BlockMathData;
+            Storage: import("./block.js").MathGroup;
+            Children: undefined;
+        }, {
+            freeze?: boolean;
+        } & import("@jsprose/core").TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+    }, (element: import("@jsprose/core").ProseElement<{
+        name: "blockMath";
+        type: "block";
+        linkable: true;
+        Data: import("./block.js").BlockMathData;
+        Storage: import("./block.js").MathGroup;
+        Children: undefined;
+    }>) => Promise<import("./block.js").MathGroup>>;
+    dependencies: {
+        katex: {
+            optimise: boolean;
+            transpile: boolean;
+        };
+    };
+}];
+export default _default;

package/dist/elements/math/core.js

@@ -0,0 +1,11 @@
+import { defineEruditProseCoreElements } from "../../coreElement.js";
+import { blockMathRegistryItem } from "./block.js";
+import { inlinerMathRegistryItem } from "./inliner.js";
+import { katexDependency } from "./katex.js";
+export default defineEruditProseCoreElements({
+	registryItem: inlinerMathRegistryItem,
+	dependencies: katexDependency
+}, {
+	registryItem: blockMathRegistryItem,
+	dependencies: katexDependency
+});

package/dist/elements/math/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 -960 960 960">
+    <path d="M221-120q-45 0-73-24t-28-64q0-32 17-51.5t43-19.5q25 0 42.5 17t17.5 41q0 5-.5 9t-1.5 9q5-1 8.5-5.5T252-221l62-339h-74q-17 0-28.5-11.5T200-600q0-17 11.5-28.5T240-640h89l21-114q7-38 37.5-62t72.5-24q44 0 72 26t28 65q0 30-17 49.5T500-680q-25 0-42.5-17T440-739q0-5 .5-9t1.5-9q-6 2-9 6t-5 12l-17 99h149q17 0 28.5 11.5T600-600q0 15-9.5 26T567-561l53 60 53-60q-14-2-23.5-13t-9.5-26q0-17 11.5-28.5T680-640h120q17 0 28.5 11.5T840-600q0 17-11.5 28.5T800-560h-22L673-440l105 120h22q17 0 28.5 11.5T840-280q0 17-11.5 28.5T800-240H680q-17 0-28.5-11.5T640-280q0-15 9.5-26t23.5-13l-53-61-53 61q14 2 23.5 13t9.5 26q0 17-11.5 28.5T560-240H440q-17 0-28.5-11.5T400-280q0-17 11.5-28.5T440-320h22l105-120-105-120h-66l-64 344q-8 45-37 70.5T221-120Z"/>
+</svg>

package/dist/elements/math/inliner.d.ts

@@ -0,0 +1,64 @@
+import { type TagChildren } from '@jsprose/core';
+export type InlinerMathType = 'katex' | 'text';
+interface InlinerMathBase {
+    type: InlinerMathType;
+}
+export interface InlinerMathKatex extends InlinerMathBase {
+    type: 'katex';
+    mathHtml: string;
+}
+export type InlinerMathToken = {
+    type: 'word' | 'other';
+    value: string;
+};
+export interface InlinerMathText extends InlinerMathBase {
+    type: 'text';
+    tokens: InlinerMathToken[];
+}
+export type InlinerMathStorage = InlinerMathKatex | InlinerMathText;
+/**
+ * Try to use simple text mode for inline math as it is significantly better for SEO, faster and smaller.
+ */
+export declare function tryTextInlinerMath(expression: string): InlinerMathText | undefined;
+export declare const inlinerMathSchema: {
+    name: "inlinerMath";
+    type: "inliner";
+    linkable: true;
+    Data: string;
+    Storage: InlinerMathStorage;
+    Children: undefined;
+};
+export declare const M: import("@jsprose/core").Tag<"M", {
+    name: "inlinerMath";
+    type: "inliner";
+    linkable: true;
+    Data: string;
+    Storage: InlinerMathStorage;
+    Children: undefined;
+}, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+export declare const inlinerMathRegistryItem: import("@jsprose/core").RegistryItem<{
+    name: "inlinerMath";
+    type: "inliner";
+    linkable: true;
+    Data: string;
+    Storage: InlinerMathStorage;
+    Children: undefined;
+}, {
+    M: import("@jsprose/core").Tag<"M", {
+        name: "inlinerMath";
+        type: "inliner";
+        linkable: true;
+        Data: string;
+        Storage: InlinerMathStorage;
+        Children: undefined;
+    }, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+}, (element: import("@jsprose/core").ProseElement<{
+    name: "inlinerMath";
+    type: "inliner";
+    linkable: true;
+    Data: string;
+    Storage: InlinerMathStorage;
+    Children: undefined;
+}>) => Promise<InlinerMathStorage>>;
+export declare function createInlinerMathStorage(katex: string): Promise<InlinerMathStorage>;
+export {};