katex 0.16.47 → 0.17.0

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;