@minamorl/flashmath 0.0.0-stage → 0.1.0

package/dist/parser.d.ts

@@ -0,0 +1,149 @@
+import { K } from "./ast.js";
+import type { Node, ParseOptions, MathMLNode } from "./ast.js";
+import { Stream } from "./scanner.js";
+import type { Token, Macro, TokenSpan } from "./scanner.js";
+import type { Preamble } from "./preamble.js";
+import type { SessionState, Reference } from "./session-state.js";
+import type { ActivePackageConfiguration, RegisteredCommand } from "./packages/types.js";
+import type { Definition } from "./symbols.js";
+type Attrs = Record<string, string>;
+interface Frame {
+    argumentScope?: boolean;
+    tokenTransform?: (node: Node) => void;
+    missingMessage?: string;
+    nodes: Node[];
+    stop: number;
+    single: boolean;
+    done: (nodes: Node[]) => void;
+    font: string;
+    multi: boolean;
+    level: number;
+    display: boolean;
+    env: string;
+    table: Table | null;
+    fraction: {
+        num: Node[];
+        attrs: Attrs;
+        left: string;
+        right: string;
+    } | null;
+}
+interface Table {
+    rows: Node[][];
+    cells: Node[];
+    align: string;
+    spacing: string;
+    rowspacing: string;
+    rowspacingBase?: number;
+    display: boolean;
+    lines: string[];
+    rowlines: string[];
+    frame: string;
+    top: string;
+    bottom: string;
+    position: string;
+    latex: boolean;
+    plan: Preamble;
+    originalFont: string;
+    fill: string;
+    rowBreak: Record<number, string>;
+    cellBreak: Record<string, string>;
+    tableBreak: boolean;
+    labels: string[];
+    noNumbers: Set<number>;
+    rowspaces: string[];
+    numbered: boolean;
+    taggable: boolean;
+    tagCells: Map<number, Node>;
+    explicitTags?: Map<number, string>;
+    colors?: {
+        cell: string;
+        row: string;
+        columns: string[];
+        rowIndex: number;
+    };
+}
+export declare class Parser {
+    readonly tex: string;
+    readonly options: ParseOptions;
+    configuration: ActivePackageConfiguration;
+    readonly session: SessionState;
+    get characters(): ReadonlyMap<number, readonly RegisteredCommand[]>;
+    readonly stream: Stream;
+    readonly macros: Map<string, Macro>;
+    readonly environments: Map<string, {
+        begin: Macro;
+        end: Macro;
+    }>;
+    readonly localLabels: Map<string, Reference>;
+    readonly frames: Frame[];
+    nodes: number;
+    expansions: number;
+    position: number;
+    readonly columns: Map<string, {
+        count: number;
+        body: string;
+    }>;
+    label: string;
+    numbered: boolean;
+    hasTaggableEnvironment: boolean;
+    readonly envStack: string[];
+    hsize: string;
+    inline: boolean;
+    nonscript: boolean;
+    pendingBreak: string;
+    result: Node[];
+    currentCommand: string;
+    constructor(tex: string, options: ParseOptions, configuration?: ActivePackageConfiguration, session?: SessionState);
+    error(message: string): never;
+    node(kind: K, children?: Node[], text?: string, attributes?: Attrs, start?: number): Node;
+    row(nodes: Node[], force?: boolean): Node;
+    atom(nodes: Node[], texclass?: string): Node;
+    fixInitialMO(nodes: Node[]): void;
+    get f(): Frame;
+    frame(stop: number, single: boolean, done: (nodes: Node[]) => void, env?: string, table?: Table | null): void;
+    append(n: Node): void;
+    close(): void;
+    argument(done: (n: Node) => void, keepGroup?: boolean, name?: string): void;
+    args(count: number, done: (nodes: Node[]) => void, name?: string): void;
+    tokensArgument(name?: string): Token[];
+    argumentSpan(name?: string): TokenSpan;
+    optional(): Token[] | null;
+    parseTokens(tokens: readonly Token[], done: (n: Node) => void): void;
+    parseSpan(span: TokenSpan, done: (n: Node) => void): void;
+    substitute(m: Macro, args: readonly Token[][]): Token[];
+    expand(m: Macro): void;
+    delimiter(): string;
+    delimiterNode(text: string, big?: string, texclass?: string): Node;
+    symbol(t: Token, id: number, d?: Definition): Node;
+    character(t: Token): Node;
+    number(t: Token): Node;
+    script(sup: boolean, prime?: boolean): void;
+    dimension(): string;
+    text(tokens: Token[], font?: string): Node;
+    /** Tags use the same text/math grammar as text boxes, in a fresh math scope. */
+    tagText(text: string): Node[];
+    renderText(input: Token[] | TokenSpan, font?: string, style?: boolean): void;
+    tableStart(name: string, align: string, stop: number, done?: (n: Node) => void): void;
+    startCell(t: Table): void;
+    finishCell(t: Table, nodes: Node[]): void;
+    completeTable(t: Table, name: string, done: (n: Node) => void): void;
+    tagTable(): Table | undefined;
+    setLabel(label: string): void;
+    reference(label: string, formatted?: boolean): void;
+    tagRow(table: Table): void;
+    labelCell(label: string, explicit?: string, starred?: boolean): Node;
+    tableNode(t: Table, name: string): Node;
+    run(): MathMLNode;
+    linebreak(): void;
+    decorationBase(n: Node): Node;
+    clean(n: Node, index: number, length: number): void;
+    functionArgument(node: Node): boolean;
+    finish(nodes: Node[]): void;
+}
+export interface MathMLParserSession {
+    parse(tex: string, options?: Pick<ParseOptions, 'display' | 'output'>): MathMLNode;
+}
+export declare function createMathMLParser(input?: ParseOptions): MathMLParserSession;
+export declare function parseToMathMLAst(tex: string, options?: ParseOptions): MathMLNode;
+export {};

package/dist/preamble.d.ts

@@ -0,0 +1,23 @@
+import type { Token } from './scanner.js';
+export interface Column {
+    align: string;
+    width: string;
+    before: Token[];
+    after: Token[];
+    insert: Token[] | null;
+    separator: string;
+    gap: string;
+    vertical: string;
+}
+export interface Preamble {
+    columns: Column[];
+    left: string;
+    right: string;
+    padding: string;
+    spacing: string;
+}
+/** The array preamble is a separate, cold grammar; its expansion is bounded. */
+export declare function preamble(source: string, max: number, custom: Map<string, {
+    count: number;
+    body: string;
+}>): Preamble;

package/dist/react.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { MathMLNode, ParseOptions, OutputOptions } from './ast.js';
+/** Real React MathML elements, with no HTML injection. */
+export declare function parseToReact(tex: string, options?: ParseOptions): ReactElement;
+export declare function mathMLAstToReact(ast: MathMLNode, options?: OutputOptions): ReactElement;

package/dist/react.js

@@ -0,0 +1 @@
+import{b as g}from"./chunk-BCYDUHHK.js";import{a as d}from"./chunk-2BLNXHV2.js";import"./chunk-TXV67IQS.js";import"./chunk-X6BR56FI.js";import"./chunk-IHTB7IDO.js";import"./chunk-KDAOMSCC.js";import"./chunk-WZSFAGJH.js";import{createElement as u}from"react";function x(n){let s={},a=0,i=-1,t=0,c=0;for(let r=0;r<=n.length;r++){let o=n.charCodeAt(r);if(c?o===92?r++:o===c&&(c=0):o===34||o===39?c=o:o===40?t++:o===41?t--:o===58&&i<0&&(i=r),r===n.length||o===59&&!t&&!c){if(i>=a){let f=n.slice(a,i).trim(),e=f.startsWith("--")?f:f.toLowerCase(),l="";if(e.startsWith("--"))l=e;else for(let p=0;p<e.length;p++)if(e.charCodeAt(p)===45&&p+1<e.length){let h=e.charCodeAt(++p);l+=String.fromCharCode(p===1&&h===109&&e.charCodeAt(2)===115?h:h>=97&&h<=122?h-32:h)}else l+=e[p];l&&(s[l]=n.slice(i+1,r).trim())}a=r+1,i=-1}}return s}var m={class:"className",for:"htmlFor","http-equiv":"httpEquiv","accept-charset":"acceptCharset"};for(let n of"accessKey allowFullScreen autoCapitalize autoComplete autoFocus cellPadding cellSpacing charSet classID colSpan contentEditable contextMenu crossOrigin dateTime encType enterKeyHint fetchPriority formAction formEncType formMethod formNoValidate formTarget frameBorder hrefLang inputMode itemID itemProp itemRef itemScope itemType marginHeight marginWidth maxLength minLength noModule noValidate playsInline readOnly referrerPolicy rowSpan spellCheck srcDoc srcLang srcSet tabIndex useMap fontFamily fontSize fontSizeAdjust fontStretch fontStyle fontVariant fontWeight strokeWidth strokeLinecap strokeLinejoin strokeMiterlimit strokeDasharray strokeDashoffset strokeOpacity fillOpacity fillRule clipPath clipRule xmlLang xmlSpace xlinkHref xmlnsXlink".split(" "))m[n.toLowerCase()]=n,m[n.replace(/[A-Z]/g,s=>"-"+s.toLowerCase())]=n;Object.assign(m,{"xml:lang":"xmlLang","xml:space":"xmlSpace","xlink:href":"xlinkHref","xmlns:xlink":"xmlnsXlink"});function S(n,s={}){return y(g(n,s),s)}function y(n,s={}){let a=[{node:d(n,s),visited:!1,key:0}],i=[];for(;a.length;){let{node:t,visited:c,key:r}=a.pop();if(!c){a.push({node:t,visited:!0,key:r});for(let e=t.children.length-1;e>=0;e--)a.push({node:t.children[e],visited:!1,key:t.children[e].start*(t.children.length+1)+e});continue}if(t.kind==="#text"){i.push(t.text);continue}let o=i.splice(i.length-t.children.length,t.children.length),f={key:r};for(let[e,l]of Object.entries(t.attributes))e==="href"&&l===""||(f[m[e]??e]=e==="style"?x(l):l);i.push(u(t.kind,f,t.text?[t.text,...o]:o))}return i[0]}export{y as mathMLAstToReact,S as parseToReact};

package/dist/scanner.d.ts

@@ -0,0 +1,40 @@
+export type Token = readonly [code: number, start: number, end: number, source: string];
+export declare const letter: (c: number) => boolean;
+export declare const space: (c: number) => c is 9 | 10 | 13 | 32 | 160;
+export declare function scan(source: string, max?: number): Token[];
+export declare const spelling: (t: Token) => string;
+export declare const builtin: (t: Token | undefined) => number;
+export declare const raw: (tokens: readonly Token[]) => string;
+export interface Macro {
+    body: readonly Token[];
+    count: number;
+    optional: readonly Token[] | null;
+    prefix: readonly Token[];
+    delimiters: readonly (readonly Token[])[];
+}
+export interface TokenSpan {
+    tokens: readonly Token[];
+    start: number;
+    end: number;
+}
+/** Build once per source buffer; argument views share this index. */
+export declare function groupEnd(tokens: readonly Token[], start: number): number | undefined;
+export declare class Stream {
+    private max;
+    private streams;
+    private cached;
+    consumed: number;
+    constructor(tokens: readonly Token[], max: number);
+    push(tokens: readonly Token[]): void;
+    pushSpan(span: TokenSpan): void;
+    /** Called immediately after an opening brace was read. */
+    takeGroup(): TokenSpan | undefined;
+    /** Text math delimiters are matched at this brace level, skipping groups. */
+    takeMath(dollar: boolean): TokenSpan | undefined;
+    peek(): Token | undefined;
+    next(): Token | undefined;
+    skip(): void;
+    /** Consume raw source through a delimiter without dispatching each token. */
+    takeThrough(source: string, end: number): Token | undefined;
+    private read;
+}

package/dist/serialize.d.ts

@@ -0,0 +1,3 @@
+import type { MathMLNode, OutputOptions } from './ast.js';
+export declare function escapeXML(value: string): string;
+export declare function toMathMLString(ast: MathMLNode, options?: OutputOptions): string;

package/dist/session-state.d.ts

@@ -0,0 +1,18 @@
+import type { Macro } from "./scanner.js";
+export interface Reference {
+    tag: string;
+    id: string;
+}
+/** Owned by one document/session; never shared between independent parser calls. */
+export interface SessionState {
+    packageData: Map<string, unknown>;
+    macros: Map<string, Macro>;
+    environments: Map<string, {
+        begin: Macro;
+        end: Macro;
+    }>;
+    labels: Map<string, Reference>;
+    counter: number;
+    initialized: boolean;
+}
+export declare function sessionState(): SessionState;