@minamorl/flashmath 0.0.0-stage → 0.1.0

package/dist/packages/mhchem-grammar.d.ts

@@ -0,0 +1,179 @@
+export declare const enum Pattern {
+    Empty = 0,
+    Any = 1,
+    Any2 = 2,
+    Space = 3,
+    SpaceA = 4,
+    SpaceEnd = 5,
+    Lower = 6,
+    X = 7,
+    XEnd = 8,
+    IEnd = 9,
+    Letters = 10,
+    Greek = 11,
+    LatinEnd = 12,
+    MathLatinEnd = 13,
+    GreekEnd = 14,
+    Digits = 15,
+    Number = 16,
+    NumberFull = 17,
+    Scientific = 18,
+    PowerNumber = 19,
+    StateEnd = 20,
+    StateSub = 21,
+    Open = 22,
+    Close = 23,
+    CommaSpace = 24,
+    Comma = 25,
+    Dot = 26,
+    Hydrate = 27,
+    Ellipsis = 28,
+    TopGroup = 29,
+    TopMath = 30,
+    TopChar = 31,
+    TopCommandTwo = 32,
+    TopCommandOne = 33,
+    TopCommand = 34,
+    TopInteger = 35,
+    Prime = 36,
+    SubGroup = 37,
+    SubMath = 38,
+    SubChar = 39,
+    SubCommandTwo = 40,
+    SubCommandOne = 41,
+    SubCommand = 42,
+    EmptyScript = 43,
+    EmptyTop = 44,
+    EmptyGroup = 45,
+    GroupRaw = 46,
+    Group = 47,
+    MathRaw = 48,
+    Math = 49,
+    Bond = 50,
+    TripleBond = 51,
+    Plus = 52,
+    ChargeMinus = 53,
+    Negative = 54,
+    OrbitalMinus = 55,
+    Minus = 56,
+    PlusMinus = 57,
+    Operator = 58,
+    Phase = 59,
+    ExplicitBond = 60,
+    Arrow = 61,
+    LabelMode = 62,
+    Label = 63,
+    Escape = 64,
+    Spacer = 65,
+    CommandTwo = 66,
+    CommandOne = 67,
+    Circa = 68,
+    Command = 69,
+    Orbital = 70,
+    Other = 71,
+    Fraction = 72,
+    Overset = 73,
+    Underset = 74,
+    Underbrace = 75,
+    Color = 76,
+    ColorBody = 77,
+    Ce = 78,
+    Pu = 79,
+    SignedOxidation = 80,
+    Oxidation = 81,
+    FractionEnd = 82,
+    Amount = 83,
+    Amount2 = 84,
+    DefectLetters = 85,
+    FormulaEnd = 86,
+    Upright = 87,
+    Slash = 88,
+    DoubleSlash = 89,
+    Product = 90
+}
+export declare const enum Action {
+    Copy = 0,
+    Write = 1,
+    Ce = 2,
+    Pu = 3,
+    Output = 4,
+    NotBond = 5,
+    OxidationOutput = 6,
+    NoSpace = 7,
+    Operator = 8,
+    SetO = 9,
+    SetR = 10,
+    SetA = 11,
+    BeginsBond = 12,
+    Bond = 13,
+    SpaceBefore = 14,
+    InsertValue = 15,
+    Insert = 16,
+    State = 17,
+    Open = 18,
+    Close = 19,
+    Comma = 20,
+    SetB = 21,
+    SetP = 22,
+    Fraction = 23,
+    Overset = 24,
+    Underset = 25,
+    Underbrace = 26,
+    Color = 27,
+    Color0 = 28,
+    SetDefect = 29,
+    SetQ = 30,
+    TopMode = 31,
+    Top = 32,
+    BottomMode = 33,
+    Bottom = 34,
+    AmountToBody = 35,
+    ChargeOrBond = 36,
+    MinusAfter = 37,
+    SetD = 38,
+    BodyAfter = 39,
+    AmountFraction = 40,
+    MathTight = 41,
+    Roman = 42,
+    Math = 43,
+    Text = 44,
+    SetText = 45,
+    Decimal = 46,
+    RomanNumeral = 47,
+    AppendO = 48,
+    TightOperator = 49,
+    Space = 50,
+    NumberPower = 51,
+    Scientific = 52,
+    Dot = 53,
+    SetRoman = 54,
+    UnitPower = 55,
+    IntegerOutput = 56,
+    DecimalOutput = 57
+}
+export declare const enum Machine {
+    TeX = 0,
+    Ce = 1,
+    Amount = 2,
+    Body = 3,
+    Text = 4,
+    Sub = 5,
+    Sup = 6,
+    Oxidation = 7,
+    Math = 8,
+    MathTight = 9,
+    Decimal = 10,
+    Pu = 11,
+    Unit = 12,
+    UnitNumber = 13
+}
+export type Option = string | number | boolean | null;
+export type Rule = readonly [Pattern, readonly (readonly [Action, Option])[], number, number];
+export interface Grammar {
+    name: string;
+    names: readonly string[];
+    states: readonly (readonly number[])[];
+    rules: readonly Rule[];
+    start: number;
+}
+export declare function chemistryGrammar(): readonly Grammar[];

package/dist/packages/mhchem-machine.d.ts

@@ -0,0 +1,50 @@
+import { Machine as M } from './mhchem-grammar.js';
+type SourceIndex = {
+    braces?: Map<number, number>;
+};
+type Piece = {
+    source: string;
+    start: number;
+    end: number;
+    index?: SourceIndex;
+};
+type Text = readonly Piece[];
+export declare class View {
+    readonly parts: Text;
+    readonly offsets: number[];
+    readonly length: number;
+    constructor(parts: Text);
+    c(i: number): number;
+    at(s: string, i?: number): boolean;
+    equal(s: string): boolean;
+    span(a: number, b?: number): Text;
+    emit(a?: number, b?: number): string;
+    skip(i: number): number;
+    command(i: number): number;
+    group(i: number, open?: number, close?: number): number;
+    number(i: number, sign?: boolean, missingZero?: boolean): number;
+    integer(i: number, sign?: boolean): number;
+    greek(i: number, onlyLower?: boolean): number;
+    letters(i: number): number;
+    boundary(i: number): boolean;
+    orbital(i: number): number;
+    state(i: number): number;
+    fraction(i: number): number;
+    formula(i: number): boolean;
+    amount(i: number): number;
+}
+interface Item {
+    tex: string;
+    escape?: boolean;
+    children?: Item[];
+    count?: number;
+}
+export declare class MhchemMachine {
+    readonly fail: (message: string) => never;
+    readonly maxDepth: number;
+    constructor(fail: (message: string) => never, maxDepth?: number);
+    run(text: Text, machine: M): Item[];
+    private steps;
+    toTex(source: string, unit?: boolean): string;
+}
+export {};

package/dist/packages/mhchem.d.ts

@@ -0,0 +1,8 @@
+import type { TexCommand } from './types.js';
+declare const _default: {
+    name: string;
+    commands: Record<string, TexCommand>;
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/newcommand.d.ts

@@ -0,0 +1,13 @@
+import type { Parser } from "../parser.js";
+import type { Token } from "../scanner.js";
+declare const _default: {
+    name: string;
+    commands: {
+        [k: string]: {
+            execute: (p: Parser, _t: Token, _d: unknown, id: number) => void;
+        };
+    };
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/noerrors.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    name: string;
+    commands: {};
+    environments: {};
+    configurationModules: string[];
+    formatError(message: string, tex: string): {
+        kind: "merror";
+        attributes: {
+            'data-mjx-error': string;
+            title: string;
+        };
+        text: string;
+        start: number;
+        children: {
+            kind: "mtext";
+            attributes: {};
+            children: never[];
+            text: string;
+            start: number;
+        }[];
+    };
+};
+export default _default;

package/dist/packages/noundefined.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    commands: {};
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+    undefinedCommand(p: import("../parser.js").Parser, name: string): void;
+};
+export default _default;

package/dist/packages/physics.d.ts

@@ -0,0 +1,14 @@
+import type { Parser } from '../parser.js';
+import type { TexCommand } from './types.js';
+declare const _default: {
+    name: string;
+    commands: Record<string, TexCommand>;
+    environments: {
+        smallmatrix: {
+            begin(p: Parser, name: string): void;
+        };
+    };
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/registry.d.ts

@@ -0,0 +1,4 @@
+import type { PackageEntry, TexPackage, PackageConfiguration } from './types.js';
+export declare const registeredPackages: readonly TexPackage[];
+export declare function resolvePackages(entries?: readonly PackageEntry[]): PackageConfiguration;
+export declare function validateConfigurationModules(names?: readonly string[]): void;

package/dist/packages/registry.js

@@ -0,0 +1 @@
+import{H as a,I as b,J as c,K as d}from"../chunk-X6BR56FI.js";import"../chunk-IHTB7IDO.js";import"../chunk-KDAOMSCC.js";import"../chunk-WZSFAGJH.js";d();export{a as registeredPackages,b as resolvePackages,c as validateConfigurationModules};

package/dist/packages/require.d.ts

@@ -0,0 +1,17 @@
+import type { Parser } from '../parser.js';
+export declare function loadPackage(p: Parser, name: string): void;
+export declare function requirePackage(p: Parser): void;
+export declare function initializeRequire(p: Parser): void;
+declare const _default: {
+    name: string;
+    commands: {
+        require: {
+            execute: typeof requirePackage;
+        };
+    };
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+    initialize: typeof initializeRequire;
+};
+export default _default;

package/dist/packages/retry.d.ts

@@ -0,0 +1,11 @@
+/** Harness compatibility: a synchronous parse never needs the upstream loader retry. */
+declare const _default: {
+    name: string;
+    commands: {
+        retry: {
+            execute(): void;
+        };
+    };
+    environments: {};
+};
+export default _default;

package/dist/packages/setoptions.d.ts

@@ -0,0 +1,20 @@
+import type { Parser } from '../parser.js';
+import { requirePackage } from './require.js';
+export declare function setOptions(p: Parser): void;
+declare const _default: {
+    name: string;
+    priority: number;
+    commands: {
+        setOptions: {
+            execute: typeof setOptions;
+        };
+        Require: {
+            execute: typeof requirePackage;
+        };
+    };
+    initialize(p: Parser): void;
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/tagformat.d.ts

@@ -0,0 +1,19 @@
+import type { Parser } from '../parser.js';
+type Result = string | string[];
+type Key = 'number' | 'tag' | 'ref' | 'id' | 'url';
+export declare function format(p: Parser, key: Key, ...args: (string | number)[]): Result;
+export declare function tagNodes(p: Parser, tag: string, starred?: boolean, ref?: boolean): import("../ast.js").Node[];
+declare const _default: {
+    name: string;
+    priority: number;
+    commands: {
+        tag: import("./types.js").TexCommand;
+        eqref: {
+            execute(p: Parser): void;
+        };
+    };
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/texhtml.d.ts

@@ -0,0 +1,14 @@
+import type { Parser } from '../parser.js';
+declare const _default: {
+    name: string;
+    commands: {
+        '<': {
+            type: string;
+            execute(p: Parser, t: import("../scanner.js").Token): void;
+        };
+    };
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/textcomp.d.ts

@@ -0,0 +1,13 @@
+export declare const textcompSymbols: Record<string, [string, string]>;
+declare const _default: {
+    name: string;
+    commands: {
+        [k: string]: {
+            type: string;
+            execute(p: import("../parser.js").Parser): void;
+        };
+    };
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/textmacros.d.ts

@@ -0,0 +1,16 @@
+import type { Node } from '../ast.js';
+import type { Parser } from '../parser.js';
+import type { Token, TokenSpan } from '../scanner.js';
+import type { TexCommand } from './types.js';
+/** Text has its own token grammar and scope stack; mathematical subexpressions
+ * return to the existing explicit math stack rather than reparsing the suffix. */
+export declare function renderTextMacros(p: Parser, tokens: readonly Token[] | TokenSpan, font?: string, style?: boolean, done?: (n: Node) => void): void;
+declare const _default: {
+    name: string;
+    priority: number;
+    commands: Record<string, TexCommand>;
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/types.d.ts

@@ -0,0 +1,47 @@
+import type { MathMLNode } from "../ast.js";
+import type { Parser } from "../parser.js";
+import type { Token } from "../scanner.js";
+import type { Definition } from "../symbols.js";
+export type PackageEntry = string | readonly [name: string, priority: number];
+export type CommandHandler = (parser: Parser, token: Token, definition: Definition, id: number) => void | boolean;
+export interface TexCommand {
+    type?: string;
+    char?: string;
+    attrs?: Record<string, unknown>;
+    args?: unknown[];
+    execute: CommandHandler;
+}
+export interface TexEnvironment {
+    begin: (parser: Parser, name: string) => void;
+    end?: (parser: Parser, name: string) => void;
+}
+export interface TexPackage {
+    name: string;
+    initialize?: (parser: Parser) => void;
+    undefinedCommand?: (parser: Parser, name: string) => void;
+    formatError?: (message: string, tex: string) => MathMLNode;
+    priority?: number;
+    commands: Readonly<Record<string, TexCommand>>;
+    characters?: Readonly<Record<string, TexCommand>>;
+    environments: Readonly<Record<string, TexEnvironment>>;
+    configurationModules?: readonly string[];
+    options?: readonly string[];
+}
+export interface RegisteredCommand {
+    definition: Definition;
+    execute: CommandHandler;
+    id: number;
+}
+export interface ActivePackageConfiguration extends PackageConfiguration {
+    entries: readonly PackageEntry[];
+    packages: readonly TexPackage[];
+}
+export interface PackageConfiguration {
+    characterHandlers: ReadonlyMap<number, readonly RegisteredCommand[]>;
+    initializers: readonly ((parser: Parser) => void)[];
+    characters: ReadonlyMap<string, RegisteredCommand>;
+    commands: readonly (RegisteredCommand | undefined)[];
+    extensions: ReadonlyMap<string, RegisteredCommand>;
+    environments: ReadonlyMap<string, TexEnvironment>;
+    options: ReadonlySet<string>;
+}

package/dist/packages/unicode.d.ts

@@ -0,0 +1,18 @@
+import type { Parser } from '../parser.js';
+declare const _default: {
+    name: string;
+    commands: {
+        unicode: {
+            execute(p: Parser): void;
+        };
+        U: {
+            execute(p: Parser): void;
+        };
+        char: {
+            execute(p: Parser): void;
+        };
+    };
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/units.d.ts

@@ -0,0 +1,19 @@
+import type { Parser } from '../parser.js';
+declare const _default: {
+    name: string;
+    commands: {
+        units: {
+            execute(p: Parser): void;
+        };
+        unitfrac: {
+            execute(p: Parser): void;
+        };
+        nicefrac: {
+            execute(p: Parser): void;
+        };
+    };
+    environments: {};
+    options: string[];
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/upgreek.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    name: string;
+    commands: {
+        [k: string]: {
+            execute(p: import("../parser.js").Parser): void;
+        };
+    };
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;

package/dist/packages/verb.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    name: string;
+    commands: {
+        verb: {
+            execute(p: import("../parser.js").Parser): void;
+        };
+    };
+    environments: {};
+    configurationModules: string[];
+};
+export default _default;