katex 0.16.47 → 0.18.0

package/src/styles/katex.scss

@@ -58,13 +58,13 @@ $display-margin: 1em 0 !default;
     }
 
     .katex-html {
-        /* \newline is an empty block at top level, between .base elements */
-        > .newline {
+        /* \newline is an empty block at top level, between .katex-base elements */
+        > .katex-newline {
             display: block;
         }
     }
 
-    .base {
+    .katex-base {
         position: relative;
         display: inline-block;
         white-space: nowrap;
@@ -73,7 +73,7 @@ $display-margin: 1em 0 !default;
         width: min-content;
     }
 
-    .strut {
+    .katex-strut {
         display: inline-block;
     }
 
@@ -242,19 +242,13 @@ $display-margin: 1em 0 !default;
         min-width: 2px;
     }
 
-    .vbox {
+    .katex-vbox {
         display: inline-flex;
         flex-direction: column;
         align-items: baseline;
     }
 
-    .hbox {
-        display: inline-flex;
-        flex-direction: row;
-        width: 100%;
-    }
-
-    .thinbox {
+    .katex-thinbox {
         display: inline-flex;
         flex-direction: row;
         width: 0;
@@ -279,11 +273,11 @@ $display-margin: 1em 0 !default;
 
     // Prevent Chrome from disappearing frac-lines, rules, etc.
     .mfrac .frac-line,
-    .overline .overline-line,
-    .underline .underline-line,
-    .hline,
-    .hdashline,
-    .rule {
+    .katex-overline .overline-line,
+    .katex-underline .underline-line,
+    .katex-hline,
+    .katex-hdashline,
+    .katex-rule {
         min-height: 1px;
     }
 
@@ -291,7 +285,7 @@ $display-margin: 1em 0 !default;
         display: inline-block;
     }
 
-    .smash {
+    .katex-smash {
         display: inline;
         line-height: 0;
     }
@@ -302,51 +296,51 @@ $display-margin: 1em 0 !default;
         width: 0;
         position: relative;
 
-        > .inner {
+        > .katex-inner {
             position: absolute;
         }
 
-        > .fix {
+        > .katex-fix {
             display: inline-block;
         }
     }
 
-    .llap > .inner {
+    .llap > .katex-inner {
         right: 0;
     }
 
-    .rlap > .inner,
-    .clap > .inner {
+    .rlap > .katex-inner,
+    .clap > .katex-inner {
         left: 0;
     }
 
-    .clap > .inner > span {
+    .clap > .katex-inner > span {
         margin-left: -50%;
         margin-right: 50%;
     }
 
-    .rule {
+    .katex-rule {
         display: inline-block;
         border: solid 0;
         position: relative;
     }
 
-    .overline .overline-line,
-    .underline .underline-line,
-    .hline {
+    .katex-overline .overline-line,
+    .katex-underline .underline-line,
+    .katex-hline {
         display: inline-block;
         width: 100%;
         border-bottom-style: solid;
     }
 
-    .hdashline {
+    .katex-hdashline {
         display: inline-block;
         width: 100%;
         border-bottom-style: dashed;
     }
 
     .sqrt {
-        > .root {
+        > .katex-root {
             /* These values are taken from the definition of `\r@@t`,
              `\mkern 5mu` and `\mkern -10mu`. */
             /* stylelint-disable-next-line declaration-property-value-no-unknown */
@@ -356,7 +350,7 @@ $display-margin: 1em 0 !default;
         }
     }
 
-    .sizing,
+    .katex-sizing,
     .fontsize-ensurer {
         $sizes: 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2, 1.44, 1.728, 2.074, 2.488;
 
@@ -414,7 +408,7 @@ $display-margin: 1em 0 !default;
         }
     }
 
-    .accent {
+    .katex-accent {
         > .vlist-t {
             text-align: center;
         }
@@ -430,7 +424,7 @@ $display-margin: 1em 0 !default;
         }
     }
 
-    .overlay {
+    .katex-overlay {
         display: block;
     }
 
@@ -503,7 +497,7 @@ $display-margin: 1em 0 !default;
     }
 
     // Define CSS for image whose width will match its span width.
-    .stretchy {
+    .katex-stretchy {
         width: 100%;
         display: block;
         position: relative;
@@ -591,7 +585,7 @@ $display-margin: 1em 0 !default;
         margin-right: -0.2em;   // Apply negative margin to correct for 0.2em padding
     }                           // inside the \cancel group.
 
-    .sout {
+    .katex-sout {
         border-bottom-style: solid;
         border-bottom-width: 0.08em;
     }
@@ -656,7 +650,7 @@ $display-margin: 1em 0 !default;
             display: block;
             position: relative;
 
-            > .tag {
+            > .katex-tag {
                 position: absolute;
                 right: 0;
             }
@@ -665,7 +659,7 @@ $display-margin: 1em 0 !default;
 }
 
 // Left-justified tags (default is right-justified)
-.katex-display.leqno > .katex > .katex-html > .tag {
+.katex-display.leqno > .katex > .katex-html > .katex-tag {
     left: 0;
     right: auto;
 }

package/src/types/index.ts

@@ -27,3 +27,15 @@ export type DelimiterSize = 1 | 2 | 3 | 4;
 
 export type Slice1<S extends string> =
     S extends `${string}${infer Rest}` ? Rest : "";
+
+export type Slice4<S extends string> =
+    S extends `${string}${string}${string}${string}${infer Rest}` ? Rest : "";
+
+export type Slice5<S extends string> =
+    S extends `${string}${string}${string}${string}${string}${infer Rest}` ? Rest : "";
+
+export type Measurement = {number: number, unit: string};
+
+export type MathClass = "mord" | "mop" | "mbin" | "mrel" | "mopen" | "mclose" | "mpunct" | "minner";
+
+export type Side = "left" | "right";

package/src/types/nodes.ts

@@ -0,0 +1,456 @@
+import type SourceLocation from "../SourceLocation";
+import type {DelimiterSize, MathClass, Measurement, Mode, Side, StyleStr} from "./index";
+import type {AlignSpec, ColSeparationType} from "../environments/array";
+import type {Atom} from "../atoms";
+import type {MathFont} from "./fonts";
+import type {Token} from "../Token";
+
+// ParseNode from `Parser.formatUnsupportedCmd`
+export type UnsupportedCmdParseNode = ColorNode;
+
+export type NodeType = AnyParseNode["type"];
+
+export type ParseNode<T extends NodeType> = ParseNodeMap[T];
+
+export type AnyParseNode =
+    | ArrayNode
+    | CommutativeDiagramLabelNode
+    | CommutativeDiagramLabelParentNode
+    | ColorNode
+    | ColorTokenNode
+    | OperatorNode
+    | OrdinaryGroupNode
+    | RawNode
+    | SizeNode
+    | StylingNode
+    | SupSubNode
+    | TagNode
+    | TextNode
+    | UrlNode
+    | VerbatimNode
+    | AtomNode
+    | MathOrdinaryNode
+    | TextOrdinaryNode
+    | SpacingNode
+    | AccentTokenNode
+    | OperatorTokenNode
+    | AccentNode
+    | AccentUnderNode
+    | CarriageReturnNode
+    | DelimiterSizingNode
+    | EncloseNode
+    | EnvironmentNode
+    | FontNode
+    | GeneralizedFractionNode
+    | HorizontalBoxNode
+    | HorizontalBraceNode
+    | HrefNode
+    | HtmlNode
+    | HtmlMathmlNode
+    | IncludeGraphicsNode
+    | InfixNode
+    | InternalNode
+    | KernNode
+    | LapNode
+    | LeftRightNode
+    | ClosingDelimiterNode
+    | MathChoiceNode
+    | MiddleNode
+    | MathClassNode
+    | OperatorNameNode
+    | OverlineNode
+    | UnderlineNode
+    | PhantomNode
+    | VerticalPhantomNode
+    | PoorMansBoldNode
+    | RaiseBoxNode
+    | RuleNode
+    | SizingNode
+    | SmashNode
+    | SqrtNode
+    | VerticalCenterNode
+    | ExtensibleArrowNode;
+
+// ParseNode's corresponding to Symbol `Group`s in symbols.js.
+export type SymbolParseNode =
+    ParseNode<"atom"> |
+    ParseNode<"accent-token"> |
+    ParseNode<"mathord"> |
+    ParseNode<"op-token"> |
+    ParseNode<"spacing"> |
+    ParseNode<"textord">;
+
+type ParseNodeMap = {
+    [K in NodeType]: Extract<AnyParseNode, {type: K}>;
+};
+
+type BaseNode = {
+    mode: Mode;
+    loc?: SourceLocation | null;
+};
+
+type ArrayNode = BaseNode & {
+    type: "array";
+    colSeparationType?: ColSeparationType;
+    hskipBeforeAndAfter?: boolean;
+    addJot?: boolean;
+    cols?: AlignSpec[];
+    arraystretch: number;
+    body: AnyParseNode[][];
+    // List of rows in the (2D) array.
+    rowGaps: (Measurement | null)[];
+    hLinesBeforeRow: boolean[][];
+    // Whether each row should be automatically numbered, or an explicit tag
+    tags?: (boolean | AnyParseNode[])[];
+    leqno?: boolean;
+};
+
+type CommutativeDiagramLabelNode = BaseNode & {
+    type: "cdlabel";
+    side: Side;
+    label: AnyParseNode;
+};
+
+type CommutativeDiagramLabelParentNode = BaseNode & {
+    type: "cdlabelparent";
+    fragment: AnyParseNode;
+}
+
+type ColorNode = BaseNode & {
+    type: "color";
+    color: string;
+    body: AnyParseNode[];
+}
+
+type ColorTokenNode = BaseNode & {
+    type: "color-token";
+    color: string;
+}
+
+type OperatorNodeBase = BaseNode & {
+    type: "op";
+    limits: boolean;
+    alwaysHandleSupSub?: boolean;
+    suppressBaseShift?: boolean;
+    parentIsSupSub: boolean;
+}
+
+type OperatorNode =
+    | OperatorNodeBase & {symbol: true; name: string; body?: never;}
+    | OperatorNodeBase & {symbol: false; body: AnyParseNode[]; name?: never;}
+    | OperatorNodeBase & {symbol: false; name: string; body?: never;};
+
+type OrdinaryGroupNode = BaseNode & {
+    type: "ordgroup";
+    body: AnyParseNode[];
+    semisimple?: boolean;
+}
+
+type RawNode = BaseNode & {
+    type: "raw";
+    string: string;
+}
+
+type SizeNode = BaseNode & {
+    type: "size";
+    value: Measurement;
+    isBlank: boolean;
+}
+
+type StylingNode = BaseNode & {
+    type: "styling";
+    style: StyleStr;
+    resetFont?: boolean;
+    body: AnyParseNode[];
+}
+
+type SupSubNode = BaseNode & {
+    type: "supsub";
+    base: AnyParseNode | null;
+} & (
+    | {sup: AnyParseNode; sub?: AnyParseNode;}
+    | {sup?: AnyParseNode; sub: AnyParseNode;}
+    );
+
+type TagNode = BaseNode & {
+    type: "tag";
+    body: AnyParseNode[];
+    tag: AnyParseNode[];
+}
+
+type TextNode = BaseNode & {
+    type: "text";
+    body: AnyParseNode[];
+    font?: string;
+}
+
+type UrlNode = BaseNode & {
+    type: "url";
+    url: string;
+}
+
+type VerbatimNode = BaseNode & {
+    type: "verb";
+    body: string;
+    star: boolean;
+}
+
+type SymbolNode = BaseNode & {
+    text: string;
+}
+
+type AtomNode = SymbolNode & {
+    type: "atom";
+    family: Atom;
+}
+
+type MathOrdinaryNode = SymbolNode & {
+    type: "mathord";
+}
+
+type TextOrdinaryNode = SymbolNode & {
+    type: "textord";
+}
+
+type SpacingNode = SymbolNode & {
+    type: "spacing";
+}
+
+type AccentTokenNode = SymbolNode & {
+    type: "accent-token";
+}
+
+type OperatorTokenNode = SymbolNode & {
+    type: "op-token";
+}
+
+type AccentBaseNode = BaseNode & {
+    label: string;
+    isStretchy?: boolean;
+    isShifty?: boolean;
+    base: AnyParseNode;
+}
+
+type AccentNode = AccentBaseNode & {
+    type: "accent";
+}
+
+type AccentUnderNode = AccentBaseNode & {
+    type: "accentUnder";
+}
+
+type CarriageReturnNode = BaseNode & {
+    type: "cr";
+    newLine: boolean;
+    size: Measurement | null;
+}
+
+type DelimiterSizingNode = BaseNode & {
+    type: "delimsizing";
+    size: DelimiterSize;
+    mclass: "mopen" | "mclose" | "mrel" | "mord";
+    delim: string;
+}
+
+type EncloseNode = BaseNode & {
+    type: "enclose";
+    body: AnyParseNode;
+    label: string;
+    backgroundColor?: string;
+    borderColor?: string;
+}
+
+type EnvironmentNode = BaseNode & {
+    type: "environment";
+    name: string;
+    nameGroup: AnyParseNode;
+}
+
+type FontNode = BaseNode & {
+    type: "font";
+    font: Exclude<MathFont, "">;
+    body: AnyParseNode;
+}
+
+type GeneralizedFractionNode = BaseNode & {
+    type: "genfrac";
+    continued: boolean;
+    numer: AnyParseNode;
+    denom: AnyParseNode;
+    hasBarLine: boolean;
+    leftDelim: string | null;
+    rightDelim: string | null;
+    barSize: Measurement | null;
+}
+
+type HorizontalBoxNode = BaseNode & {
+    type: "hbox";
+    body: AnyParseNode[];
+}
+
+type HorizontalBraceNode = BaseNode & {
+    type: "horizBrace";
+    label: string;
+    isOver: boolean;
+    base: AnyParseNode;
+}
+
+type HrefNode = BaseNode & {
+    type: "href";
+    href: string;
+    body: AnyParseNode[];
+}
+
+type HtmlNode = BaseNode & {
+    type: "html";
+    attributes: Record<string, string>;
+    body: AnyParseNode[];
+}
+
+type HtmlMathmlNode = BaseNode & {
+    type: "htmlmathml";
+    html: AnyParseNode[];
+    mathml: AnyParseNode[];
+}
+
+type IncludeGraphicsNode = BaseNode & {
+    type: "includegraphics";
+    alt: string;
+    width: Measurement;
+    height: Measurement;
+    totalheight: Measurement;
+    src: string;
+}
+
+type InfixNode = BaseNode & {
+    type: "infix";
+    replaceWith: string;
+    size?: Measurement;
+    token?: Token;
+}
+
+type InternalNode = BaseNode & {
+    type: "internal";
+}
+
+type KernNode = BaseNode & {
+    type: "kern";
+    dimension: Measurement;
+}
+
+type LapNode = BaseNode & {
+    type: "lap";
+    alignment: string;
+    body: AnyParseNode;
+}
+type LeftRightNode = BaseNode & {
+    type: "leftright";
+    body: AnyParseNode[];
+    left: string;
+    right: string;
+    rightColor?: string;
+}
+
+type ClosingDelimiterNode = BaseNode & {
+    type: "leftright-right";
+    delim: string;
+    color?: string;
+}
+
+type MathChoiceNode = BaseNode & {
+    type: "mathchoice";
+    display: AnyParseNode[];
+    text: AnyParseNode[];
+    script: AnyParseNode[];
+    scriptscript: AnyParseNode[];
+}
+
+type MiddleNode = BaseNode & {
+    type: "middle";
+    delim: string;
+}
+
+type MathClassNode = BaseNode & {
+    type: "mclass";
+    mclass: MathClass;
+    body: AnyParseNode[];
+    isCharacterBox: boolean;
+}
+
+type OperatorNameNode = BaseNode & {
+    type: "operatorname";
+    body: AnyParseNode[];
+    alwaysHandleSupSub: boolean;
+    limits: boolean;
+    parentIsSupSub: boolean;
+}
+
+type OverlineNode = BaseNode & {
+    type: "overline";
+    body: AnyParseNode;
+}
+
+type UnderlineNode = BaseNode & {
+    type: "underline";
+    body: AnyParseNode;
+}
+
+type PhantomNode = BaseNode & {
+    type: "phantom";
+    body: AnyParseNode[];
+}
+
+type VerticalPhantomNode = BaseNode & {
+    type: "vphantom";
+    body: AnyParseNode;
+}
+
+type PoorMansBoldNode = BaseNode & {
+    type: "pmb";
+    mclass: MathClass;
+    body: AnyParseNode[];
+}
+
+type RaiseBoxNode = BaseNode & {
+    type: "raisebox";
+    dy: Measurement;
+    body: AnyParseNode;
+}
+
+type RuleNode = BaseNode & {
+    type: "rule";
+    shift: Measurement | null | undefined;
+    width: Measurement;
+    height: Measurement;
+}
+
+type SizingNode = BaseNode & {
+    type: "sizing";
+    size: number;
+    body: AnyParseNode[];
+}
+
+type SmashNode = BaseNode & {
+    type: "smash";
+    body: AnyParseNode;
+    smashHeight: boolean;
+    smashDepth: boolean;
+}
+
+type SqrtNode = BaseNode & {
+    type: "sqrt";
+    body: AnyParseNode;
+    index: AnyParseNode | null;
+}
+
+type VerticalCenterNode = BaseNode & {
+    type: "vcenter";
+    body: AnyParseNode;
+}
+
+type ExtensibleArrowNode = BaseNode & {
+    type: "xArrow";
+    label: string;
+    body: AnyParseNode;
+    below: AnyParseNode | null;
+}

package/src/units.ts

@@ -5,6 +5,7 @@
 
 import ParseError from "./ParseError";
 import Options from "./Options";
+import type {Measurement} from "./types";
 
 // This table gives the number of TeX pts in one of each *absolute* TeX unit.
 // Thus, multiplying a length by this number converts the length from units
@@ -35,8 +36,6 @@ const relativeUnit = {
     "mu": true,
 };
 
-export type Measurement = { number: number, unit: string };
-
 /**
  * Determine whether the specified unit (either a string defining the unit
  * or a "size" parse node containing a unit field) is valid.

package/src/utils.ts

@@ -3,7 +3,7 @@
  * files.
  */
 
-import type {AnyParseNode} from "./parseNode";
+import type {AnyParseNode} from "./types/nodes";
 
 // hyphenate and escape adapted from Facebook's React under Apache 2 license
 const uppercase = /([A-Z])/g;

package/src/wide-character.ts

@@ -110,7 +110,7 @@ const wideLatinLetterData = [
     italicSansSerif, italicSansSerif, // A-Z, a-z
     noFont, noFont,           // A-Z bold italic sans, a-z bold italic sans - no font
     monospace, monospace,     // A-Z, a-z
-] as const;
+] as const satisfies readonly WideChar[];
 
 const wideNumeralData = [
     boldUpright,      // 0-9
@@ -118,7 +118,7 @@ const wideNumeralData = [
     sansSerif,        // 0-9
     boldSansSerif,   // 0-9
     monospace,       // 0-9
-] as const;
+] as const satisfies readonly WideChar[];
 
 export const wideCharacterFont = (
     wideChar: string,