explico 0.6.0 → 0.8.0

package/dist/reference/delimiter-size.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Rule N17: a nested scalable delimiter is sized by the engine, never by hand.
+ *
+ * The engine installs a KaTeX whose `\delimitershortfall` is `-1pt`
+ * (`katex-delimiters.mjs`), so a `\left`/`\right` pair is always
+ * strictly taller than what it wraps. Nesting depth therefore shows up on its
+ * own, and a hand-picked `\bigl`…`\Biggr` inside a nest only replaces a size
+ * that tracks the content with a fixed glyph that does not.
+ *
+ * This deliberately parses only sizing syntax. It does not decide whether a
+ * parenthesis, bracket, or brace is semantic, and it never recommends changing
+ * one delimiter shape into another. N16's alternating-shape preference remains
+ * a review-only authoring concern.
+ */
+declare const DELIMITER_SIZE_DIAGNOSTIC_CODE: "delimiter-manual-size";
+type DelimiterSizeName = 'automatic' | 'big' | 'Big' | 'bigg' | 'Bigg';
+interface DelimiterSizeSuggestion {
+    readonly open: string;
+    readonly close: string;
+    readonly latex: string;
+}
+interface DelimiterSizeDiagnostic {
+    readonly code: typeof DELIMITER_SIZE_DIAGNOSTIC_CODE;
+    readonly severity: 'warning';
+    readonly offset: number;
+    readonly line: number;
+    readonly column: number;
+    /** The hand-picked size that should become `\left`/`\right`. */
+    readonly size: Exclude<DelimiterSizeName, 'automatic'>;
+    readonly suggestion: DelimiterSizeSuggestion;
+    readonly message: string;
+}
+/**
+ * Warn when a pair that takes part in a nest of scalable delimiters is sized
+ * by hand instead of by `\left`/`\right`.
+ *
+ * A pair takes part in a nest when it contains, or sits inside, another pair
+ * this linter tracks. A lone hand-sized pair around otherwise bare content —
+ * `\bigl(x(t),\ y(t)\bigr)` for a tuple — is a deliberate typographic
+ * choice at a single level, has no hierarchy to get wrong, and is left alone.
+ *
+ * Only `()`, `[]`, and `\{\}` are parsed. Bare delimiters are intentionally
+ * ignored: N15 owns that separate error, while ordinary semantic notation
+ * such as `f(x)` and `\mathbb{E}[X]` must not trigger this size-only linter.
+ */
+declare function lintDelimiterSizes(latex: string): DelimiterSizeDiagnostic[];
+
+export { DELIMITER_SIZE_DIAGNOSTIC_CODE, type DelimiterSizeDiagnostic, type DelimiterSizeName, type DelimiterSizeSuggestion, lintDelimiterSizes };

package/dist/reference/delimiter-size.js

@@ -0,0 +1,153 @@
+const DELIMITER_SIZE_DIAGNOSTIC_CODE = "delimiter-manual-size";
+const SIZE_SPECS = [
+  {
+    name: "automatic",
+    rank: 1,
+    openCommand: "\\left",
+    closeCommand: "\\right",
+    kind: "automatic"
+  },
+  {
+    name: "big",
+    rank: 1,
+    openCommand: "\\bigl",
+    closeCommand: "\\bigr",
+    kind: "manual"
+  },
+  {
+    name: "Big",
+    rank: 2,
+    openCommand: "\\Bigl",
+    closeCommand: "\\Bigr",
+    kind: "manual"
+  },
+  {
+    name: "bigg",
+    rank: 3,
+    openCommand: "\\biggl",
+    closeCommand: "\\biggr",
+    kind: "manual"
+  },
+  {
+    name: "Bigg",
+    rank: 4,
+    openCommand: "\\Biggl",
+    closeCommand: "\\Biggr",
+    kind: "manual"
+  }
+];
+const COMMAND_SPECS = SIZE_SPECS.flatMap((spec) => [
+  { ...spec, command: spec.openCommand, tokenKind: "open" },
+  { ...spec, command: spec.closeCommand, tokenKind: "close" }
+]).sort((left, right) => right.command.length - left.command.length);
+function delimiterAt(latex, offset, kind) {
+  const candidates = kind === "open" ? ["\\{", "(", "["] : ["\\}", ")", "]"];
+  for (const delimiter of candidates) {
+    if (latex.startsWith(delimiter, offset)) {
+      return { delimiter, end: offset + delimiter.length };
+    }
+  }
+  return void 0;
+}
+function tokenAt(latex, offset) {
+  if (latex[offset] !== "\\") return void 0;
+  for (const spec of COMMAND_SPECS) {
+    if (!latex.startsWith(spec.command, offset)) continue;
+    const afterCommand = offset + spec.command.length;
+    if (/[A-Za-z]/.test(latex[afterCommand] ?? "")) continue;
+    let delimiterOffset = afterCommand;
+    while (/\s/.test(latex[delimiterOffset] ?? "")) delimiterOffset += 1;
+    const delimiter = delimiterAt(latex, delimiterOffset, spec.tokenKind);
+    if (!delimiter) continue;
+    return {
+      kind: spec.tokenKind,
+      pairKind: spec.kind,
+      rank: spec.rank,
+      size: spec.name,
+      delimiter: delimiter.delimiter,
+      offset,
+      end: delimiter.end
+    };
+  }
+  return void 0;
+}
+function pairMatches(open, close) {
+  return open.kind === "open" && close.kind === "close" && open.pairKind === close.pairKind && open.rank === close.rank;
+}
+function isEscaped(latex, offset) {
+  let slashes = 0;
+  for (let index = offset - 1; index >= 0 && latex[index] === "\\"; index -= 1) {
+    slashes += 1;
+  }
+  return slashes % 2 === 1;
+}
+function parseDelimiterPairs(latex) {
+  const roots = [];
+  const stack = [];
+  for (let offset = 0; offset < latex.length; offset += 1) {
+    if (latex[offset] === "%" && !isEscaped(latex, offset)) {
+      const newline = latex.indexOf("\n", offset + 1);
+      if (newline === -1) break;
+      offset = newline;
+      continue;
+    }
+    const token = isEscaped(latex, offset) ? void 0 : tokenAt(latex, offset);
+    if (!token) continue;
+    offset = token.end - 1;
+    if (token.kind === "open") {
+      const pair2 = { open: token, children: [] };
+      const parent = stack[stack.length - 1];
+      if (parent) parent.children.push(pair2);
+      else roots.push(pair2);
+      stack.push(pair2);
+      continue;
+    }
+    const pair = stack[stack.length - 1];
+    if (!pair || !pairMatches(pair.open, token)) return void 0;
+    pair.close = token;
+    stack.pop();
+  }
+  return stack.length === 0 ? roots : void 0;
+}
+function lineAndColumn(source, offset) {
+  const before = source.slice(0, offset);
+  const lastNewline = before.lastIndexOf("\n");
+  return {
+    line: before.split("\n").length,
+    column: offset - lastNewline
+  };
+}
+const SPEC_BY_SIZE = new Map(SIZE_SPECS.map((spec) => [spec.name, spec]));
+function suggestionFor(pair) {
+  const open = `\\left${pair.open.delimiter}`;
+  const close = `\\right${pair.close?.delimiter ?? pair.open.delimiter}`;
+  return { open, close, latex: `${open} ... ${close}` };
+}
+function lintDelimiterSizes(latex) {
+  const roots = parseDelimiterPairs(latex);
+  if (!roots) return [];
+  const diagnostics = [];
+  const visit = (pair, nested) => {
+    const inNest = nested || pair.children.length > 0;
+    if (inNest && pair.open.pairKind === "manual") {
+      const location = lineAndColumn(latex, pair.open.offset);
+      const suggestion = suggestionFor(pair);
+      diagnostics.push({
+        code: DELIMITER_SIZE_DIAGNOSTIC_CODE,
+        severity: "warning",
+        offset: pair.open.offset,
+        ...location,
+        size: pair.open.size,
+        suggestion,
+        message: `A nested delimiter pair is sized by hand with ${SPEC_BY_SIZE.get(pair.open.size)?.openCommand ?? pair.open.size}${pair.open.delimiter}. Use ${suggestion.latex} and let the engine size the nest; preserve the original opening and closing delimiter shapes (rule N17).`
+      });
+    }
+    for (const child of pair.children) visit(child, true);
+  };
+  for (const root of roots) visit(root, false);
+  return diagnostics.sort((left, right) => left.offset - right.offset);
+}
+export {
+  DELIMITER_SIZE_DIAGNOSTIC_CODE,
+  lintDelimiterSizes
+};

package/dist/reference/diagrams-validate.d.ts

@@ -5,7 +5,7 @@ import { KeyedFloatLabelRecord, KeyedFloatLessonInput, KeyedFloatValidation } fr
 type DiagramDiagnosticCode = 'dia-invalid-key' | 'dia-duplicate-key' | 'dia-ref-resolves' | 'dia-key-unused';
 interface DiagramDiagnostic {
     readonly code: DiagramDiagnosticCode;
-    readonly severity: 'error' | 'warning';
+    readonly severity: 'error' | 'warning' | 'info';
     readonly message: string;
     readonly file?: string;
     readonly lessonId?: string;

package/dist/reference/equations-validate.d.ts

@@ -4,7 +4,7 @@
  * - `eq-duplicate-key` (Tier 1, error): an `eq:` key is unique per lesson.
  * - `eq-ref-resolves` (Tier 1, error): every `[[eq-key]]` / `[[slug#eq-key]]`
  *   points at a display equation that carries `\label{eq:key}`.
- * - `eq-key-unused` (Tier 3, warning): a labelled equation never referenced.
+ * - `eq-key-unused` (info): a labelled equation is never referenced.
  *
  * The remark pass enforces the same rules on the render path; this gives the
  * fast `pnpm validate:content` the same coverage and feeds the manifest.
@@ -26,7 +26,7 @@ interface EquationRefRecord {
 type EquationDiagnosticCode = 'eq-duplicate-key' | 'eq-ref-resolves' | 'eq-key-unused';
 interface EquationDiagnostic {
     readonly code: EquationDiagnosticCode;
-    readonly severity: 'error' | 'warning';
+    readonly severity: 'error' | 'warning' | 'info';
     readonly message: string;
     readonly file?: string;
     readonly lessonId?: string;

package/dist/reference/equations-validate.js

@@ -73,7 +73,7 @@ function validateEquations(lessons) {
     if (referenced.has(`${label.slug}#${label.key}`)) continue;
     diagnostics.push({
       code: "eq-key-unused",
-      severity: "warning",
+      severity: "info",
       message: `${label.lessonId} labels eq:${label.key} (${label.number}) but nothing references it with [[eq-${label.key}]]`,
       file: label.slug,
       lessonId: label.lessonId,

package/dist/reference/equations.d.mts

@@ -35,10 +35,16 @@ export function displayEquationNumber({ prefix, offset, section, indexInSection,
     indexInSection: any;
     indexInLesson: any;
 }): string;
-/** The positional anchor id for an unkeyed equation, e.g. `2.4` → `eq-2-4`. */
+/**
+ * A display equation's anchor id: `eq-<key>` when it carries a
+ * `\label{eq:…}`, else the positional form, e.g. `2.4` → `eq-2-4`.
+ *
+ * @param {{ key?: string, number?: string | number }} equation - `number` is
+ *   read only when there is no `key`, so a keyed caller may omit it.
+ */
 export function equationAnchorId({ key, number }: {
-    key: any;
-    number: any;
+    key?: string;
+    number?: string | number;
 }): string;
 export function stripFencedCode(markdown: any): string;
 /**

package/dist/reference/equations.mjs

@@ -106,7 +106,13 @@ export function displayEquationNumber({
     : `${prefix}.${offset + indexInLesson}`;
 }
 
-/** The positional anchor id for an unkeyed equation, e.g. `2.4` → `eq-2-4`. */
+/**
+ * A display equation's anchor id: `eq-<key>` when it carries a
+ * `\label{eq:…}`, else the positional form, e.g. `2.4` → `eq-2-4`.
+ *
+ * @param {{ key?: string, number?: string | number }} equation - `number` is
+ *   read only when there is no `key`, so a keyed caller may omit it.
+ */
 export function equationAnchorId({ key, number }) {
   return key ? `eq-${key}` : `eq-${String(number).replace(/\./g, '-')}`;
 }

package/dist/reference/figures-validate.d.ts

@@ -5,7 +5,7 @@ import { KeyedFloatLabelRecord, KeyedFloatLessonInput, KeyedFloatValidation } fr
 type FigureDiagnosticCode = 'fig-invalid-key' | 'fig-duplicate-key' | 'fig-ref-resolves' | 'fig-key-unused';
 interface FigureDiagnostic {
     readonly code: FigureDiagnosticCode;
-    readonly severity: 'error' | 'warning';
+    readonly severity: 'error' | 'warning' | 'info';
     readonly message: string;
     readonly file?: string;
     readonly lessonId?: string;

package/dist/reference/gate-abbreviations.js

@@ -1,7 +1,7 @@
 import { collectOperators, collectRomanLabels } from "./math-glyphs.mjs";
 import { isBaseAbbreviation } from "./base-abbreviations.mjs";
 import { pageScope } from "./gate-math.js";
-import { lineOf, proseOnly } from "./gate-prose-notation.js";
+import { lessonLine, proseOnly } from "./gate-prose-notation.js";
 const CAPS_RUN = /\b([A-Z]{2,})(?:'s|s)?\b/g;
 const DOTTED_ABBR = /\b(?:[A-Za-z]\.){2,}/g;
 function findAbbreviationLikeTokens(text) {
@@ -51,7 +51,7 @@ function gateAbbreviations(input) {
         context: "abbreviation",
         severity: "error",
         file: lesson.source.file,
-        line: lineOf(lesson.body, index),
+        line: lessonLine(lesson, index),
         token,
         message: `Unexplained abbreviation ${JSON.stringify(token)} outside math. ${FIX}`
       });

package/dist/reference/gate-heading-length.js

@@ -1,5 +1,5 @@
 import { stripFencedCode } from "./equations.mjs";
-import { lineOf } from "./gate-prose-notation.js";
+import { lessonLine } from "./gate-prose-notation.js";
 const HEADING_LENGTH_LIMIT = 65;
 const HEADING_LINE = /^[ \t]{0,3}(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/gm;
 const TITLE_ATTRIBUTE_BY_TAG = {
@@ -65,7 +65,7 @@ function gateHeadingLength(lessons) {
         context: "structure",
         severity: "error",
         file: lesson.source.file,
-        line: lineOf(lesson.body, finding.index),
+        line: lessonLine(lesson, finding.index),
         token: finding.token,
         message: finding.message
       });

package/dist/reference/gate-math.d.ts

@@ -1,5 +1,19 @@
 import { NotationRegistryInput, NotationLessonInput } from './types.js';
 
+/**
+ * The equation a finding sits in, when its math carries a `\label{eq:…}`.
+ *
+ * A location tells you where to edit; this tells you *what you are looking
+ * at*. A size-only N17 finding inside a six-line `aligned` block is otherwise
+ * anonymous — the message names delimiters, not the result they belong to —
+ * so the key and the rendered page's anchor both travel with the diagnostic.
+ */
+interface EquationLink {
+    /** The label's key, without the `eq:` prefix. */
+    readonly key: string;
+    /** Where the reader sees it, e.g. `/l1-ar/ar1-basics/#eq-ar1-variance`. */
+    readonly href: string;
+}
 interface MathGateDiagnostic {
     readonly context: 'body' | 'formula' | 'assessment' | 'prose' | 'abbreviation' | 'structure';
     /**
@@ -26,9 +40,13 @@ interface MathGateDiagnostic {
      * than adding a second array the CLI has to know about.
      */
     readonly severity: 'error' | 'warning';
+    readonly code?: string;
     readonly file: string;
     readonly line?: number;
+    readonly column?: number;
     readonly token?: string;
+    /** Present when the offending math carries a `\label{eq:…}`. */
+    readonly equation?: EquationLink;
     readonly message: string;
 }
 interface AssessmentItemLike {
@@ -56,6 +74,12 @@ type ScopeEntry = {
  * hand and risk drifting from what the completeness gate actually checks.
  */
 declare function pageScope(lesson: NotationLessonInput, sharedByKey: ReadonlyMap<string, ScopeEntry>): ScopeEntry[];
+/**
+ * The `\label{eq:…}` a math source carries, as a key plus the anchor the
+ * rendered page gives it. `EQ_LABEL_PATTERN` is global, so its `lastIndex` is
+ * reset before use — a stale one would skip the first label of the next span.
+ */
+declare function equationLinkFor(lessonId: string, latex: string): EquationLink | undefined;
 /**
  * Resolve every rendered-math context against the page glyph table. Returns one
  * diagnostic per unresolved token; an empty array means the gate passed.
@@ -66,4 +90,4 @@ declare function gateContentMath(input: {
     readonly lessonAssessments: readonly LessonAssessmentLink[];
 }): MathGateDiagnostic[];
 
-export { type MathGateDiagnostic, type ScopeEntry, gateContentMath, pageScope };
+export { type EquationLink, type MathGateDiagnostic, type ScopeEntry, equationLinkFor, gateContentMath, pageScope };

package/dist/reference/gate-math.js

@@ -1,5 +1,10 @@
 import { resolveMathGlyphs, GlyphResolutionError } from "./math-glyphs.mjs";
-import { stripEquationLabels } from "./equations.mjs";
+import {
+  EQ_LABEL_PATTERN,
+  equationAnchorId,
+  stripEquationLabels
+} from "./equations.mjs";
+import { lintDelimiterSizes } from "./delimiter-size.js";
 import { formulaGlyphScope, unknownFormulaScopeKeys } from "./gloss.js";
 const SEVERITY = {
   body: "error",
@@ -26,10 +31,14 @@ function mathSpans(body) {
     pattern.lastIndex = 0;
     let match;
     while (match = pattern.exec(searchable)) {
+      const latex = match[1] ?? "";
+      const latexOffset = match.index + match[0].indexOf(latex);
+      const before = body.slice(0, latexOffset);
+      const lastNewline = before.lastIndexOf("\n");
       spans.push({
-        // D7: `\label{eq:…}` is an identity marker, not math KaTeX parses.
-        latex: stripEquationLabels(match[1] ?? ""),
-        line: lineOf(body, match.index)
+        latex,
+        line: lineOf(body, latexOffset),
+        column: latexOffset - lastNewline
       });
     }
   }
@@ -53,10 +62,34 @@ function pageScope(lesson, sharedByKey) {
   }
   return scope;
 }
-function resolveInto(latex, scope, context, file, line, fix, out) {
+function equationLinkFor(lessonId, latex) {
+  EQ_LABEL_PATTERN.lastIndex = 0;
+  const match = EQ_LABEL_PATTERN.exec(latex);
+  EQ_LABEL_PATTERN.lastIndex = 0;
+  if (!match) return void 0;
+  const key = match[1];
+  const slug = lessonId.replace(/\./g, "/");
+  return { key, href: `/${slug}/#${equationAnchorId({ key })}` };
+}
+function resolveInto(latex, scope, context, file, line, column, fix, out, equation) {
+  const at = equation === void 0 ? {} : { equation };
+  for (const diagnostic of lintDelimiterSizes(latex)) {
+    const locatedLine = line === void 0 ? void 0 : line + diagnostic.line - 1;
+    const locatedColumn = column === void 0 ? void 0 : diagnostic.line === 1 ? column + diagnostic.column - 1 : diagnostic.column;
+    out.push({
+      context,
+      code: diagnostic.code,
+      severity: "warning",
+      file,
+      ...locatedLine === void 0 ? {} : { line: locatedLine },
+      ...locatedColumn === void 0 ? {} : { column: locatedColumn },
+      ...at,
+      message: diagnostic.message
+    });
+  }
   let result;
   try {
-    result = resolveMathGlyphs(latex, [...scope]);
+    result = resolveMathGlyphs(stripEquationLabels(latex), [...scope]);
   } catch (error) {
     out.push({
       context,
@@ -74,6 +107,7 @@ function resolveInto(latex, scope, context, file, line, fix, out) {
       file,
       line,
       token,
+      ...at,
       message: `Unresolved notation ${JSON.stringify(token)} in ${context} math. ${fix}`
     });
   }
@@ -138,15 +172,18 @@ function gateContentMath(input) {
   for (const lesson of notationInput.lessons) {
     const scope = pageScope(lesson, sharedByKey);
     const file = lesson.source.file;
+    const bodyOffset = (lesson.bodyLine ?? 1) - 1;
     for (const span of mathSpans(lesson.body)) {
       resolveInto(
         span.latex,
         scope,
         "body",
         file,
-        span.line,
+        span.line + bodyOffset,
+        span.column,
         BODY_FIX,
-        diagnostics
+        diagnostics,
+        equationLinkFor(lesson.lessonId, span.latex)
       );
     }
     for (const definition of lesson.localDefinitions) {
@@ -163,6 +200,7 @@ function gateContentMath(input) {
         "formula",
         file,
         void 0,
+        void 0,
         FORMULA_FIX,
         diagnostics
       );
@@ -183,6 +221,7 @@ function gateContentMath(input) {
       "formula",
       definition.source.file,
       void 0,
+      void 0,
       SHARED_FORMULA_FIX,
       diagnostics
     );
@@ -209,7 +248,8 @@ function gateContentMath(input) {
               scope,
               "assessment",
               `${assessmentId} (${item.id ?? "?"})`,
-              void 0,
+              span.line,
+              span.column,
               ASSESSMENT_FIX,
               diagnostics
             );
@@ -221,6 +261,7 @@ function gateContentMath(input) {
   return diagnostics;
 }
 export {
+  equationLinkFor,
   gateContentMath,
   pageScope
 };

package/dist/reference/gate-prose-notation.d.ts

@@ -39,6 +39,17 @@ interface AssessmentLike {
 declare function proseOnly(body: string): string;
 /** Exported for the same reason as {@link proseOnly}. */
 declare function lineOf(text: string, index: number): number;
+/**
+ * {@link lineOf} corrected to the file the lesson came from. A gate scans
+ * `lesson.body`, which starts *after* the frontmatter, so a raw body line is
+ * short by the frontmatter's height and points at the wrong source line —
+ * silently, because the number is still plausible. Every gate that reports a
+ * `line` against `lesson.source.file` must go through this.
+ */
+declare function lessonLine(lesson: {
+    readonly body: string;
+    readonly bodyLine?: number;
+}, index: number): number;
 /**
  * Scan every lesson body for plain-text math notation outside `$…$`. Returns
  * one `MathGateDiagnostic` (context `'prose'`, always an error — N9 has no
@@ -57,4 +68,4 @@ declare function gateProseNotation(lessons: readonly NotationLessonInput[]): Mat
  */
 declare function gateProseNotationInAssessments(assessments: readonly AssessmentLike[]): MathGateDiagnostic[];
 
-export { gateProseNotation, gateProseNotationInAssessments, lineOf, proseOnly };
+export { gateProseNotation, gateProseNotationInAssessments, lessonLine, lineOf, proseOnly };

package/dist/reference/gate-prose-notation.js

@@ -12,6 +12,9 @@ function proseOnly(body) {
 function lineOf(text, index) {
   return text.slice(0, index).split("\n").length;
 }
+function lessonLine(lesson, index) {
+  return lineOf(lesson.body, index) + (lesson.bodyLine ?? 1) - 1;
+}
 const UNIT = String.raw`m/s²|m/s|km/h|rad/s|m²/s²|J/kg|m²|s⁻¹|kg|N|J|W|Hz|deg|°|rad|m|s`;
 const NUMERAL_UNIT = new RegExp(
   String.raw`(?<![\w.])-?\d+(?:\.\d+)?\s?(?:${UNIT})(?![A-Za-z])`,
@@ -89,7 +92,7 @@ function gateProseNotation(lessons) {
         context: "prose",
         severity: "error",
         file: lesson.source.file,
-        line: lineOf(lesson.body, finding.index),
+        line: lessonLine(lesson, finding.index),
         token: finding.token,
         message: finding.message
       });
@@ -120,6 +123,7 @@ function gateProseNotationInAssessments(assessments) {
 export {
   gateProseNotation,
   gateProseNotationInAssessments,
+  lessonLine,
   lineOf,
   proseOnly
 };

package/dist/reference/katex-delimiters.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Exported for the test that pins both failure messages — a KaTeX upgrade that
+ * moves the constant, and a leftover `patches/` file, are the two ways this
+ * stops being able to install itself.
+ */
+export function rewriteBundle(source: any): any;
+/**
+ * Render a known nest and confirm the outer pair really is larger than the
+ * inner one. Cheap, and it turns every way this could go wrong — an upstream
+ * refactor, a frozen export, an import that beat us to it — into one loud
+ * failure at the point of installation.
+ */
+export function assertDelimiterGrowth(instance?: typeof katex): void;
+export default katex;
+import katex from 'katex';