@pie-lib/math-input-mathlive 1.1.5-beta.8 → 2.0.1-next.20261107131445

package/src/keys/geometry.js

@@ -1,149 +0,0 @@
-const set = (o) => ({ ...o, category: 'geometry' });
-
-export const overline = set({
-  name: 'Line',
-  latex: '\\overline{}',
-  command: '\\overline',
-});
-
-export const overRightArrow = set({
-  name: 'Ray',
-  latex: '\\overrightarrow{}',
-  command: '\\overrightarrow',
-});
-
-export const overLeftRightArrow = set({
-  name: 'Segment',
-  // MathQuill needed a nested \overline{} to draw the empty box; MathLive
-  // renders that as a real line, so the label showed a spurious bar under the
-  // arrows. `withVisibleEmptySlots` supplies the box for `{}` instead.
-  latex: '\\overleftrightarrow{}',
-  symbol: 'AB',
-  command: '\\overleftrightarrow',
-});
-
-export const segment = set({
-  name: 'Segment',
-  latex: '\\overleftrightarrow{AB}',
-  write: '\\overleftrightarrow{AB}',
-  label: 'AB',
-});
-
-export const parallel = set({
-  name: 'Parallel',
-  latex: '\\parallel',
-  command: '\\parallel',
-});
-
-export const notParallel = set({
-  name: 'Not Parallel',
-  latex: '\\nparallel',
-  command: '\\nparallel',
-});
-
-export const perpindicular = set({
-  name: 'Perpendicular',
-  latex: '\\perp',
-  command: '\\perpendicular',
-});
-
-export const angle = set({
-  name: 'Angle',
-  latex: '\\angle',
-  command: '\\angle',
-});
-export const overArc = set({
-  name: 'Over arc',
-  // See the note on Segment above: the nested \overline{} drew a straight line
-  // instead of leaving the arc visible.
-  latex: '\\overarc{}',
-  command: '\\overarc',
-});
-export const measureOfAngle = set({
-  name: 'Measured Angle',
-  latex: '\\measuredangle',
-  command: ['m', '\\angle'],
-});
-
-export const triangle = set({
-  name: 'Triangle',
-  latex: '\\triangle',
-  command: '\\triangle',
-});
-
-export const square = set({
-  name: 'Square',
-  latex: '\\square',
-  command: '\\square',
-});
-
-export const parallelogram = set({
-  name: 'Parallelogram',
-  latex: '\\parallelogram',
-  command: '\\parallelogram',
-});
-
-export const circledDot = set({
-  name: 'Circled Dot',
-  latex: '\\odot',
-  command: '\\odot',
-});
-
-export const degree = set({
-  name: 'Degree',
-  latex: '\\degree',
-  command: '\\degree',
-});
-
-export const similarTo = set({
-  name: 'Similar',
-  command: '\\sim',
-  latex: '\\sim',
-});
-
-export const congruentTo = set({
-  name: 'Congruent To',
-  command: '\\cong',
-  latex: '\\cong',
-});
-
-export const notCongruentTo = set({
-  name: 'Not Congruent To',
-  command: '\\ncong',
-  latex: '\\ncong',
-});
-
-export const primeArcminute = set({
-  name: 'Prime',
-  label: 'pam',
-  // eslint-disable-next-line
-  latex: "'",
-  // eslint-disable-next-line
-  write: "'",
-});
-
-export const doublePrimeArcSecond = set({
-  name: 'Double Prime',
-  // eslint-disable-next-line
-  latex: "''",
-  // eslint-disable-next-line
-  write: "''",
-});
-
-export const leftArrow = set({
-  name: 'Left Arrow',
-  latex: '\\leftarrow',
-  command: '\\leftarrow',
-});
-
-export const rightArrow = set({
-  name: 'Right Arrow',
-  latex: '\\rightarrow',
-  command: '\\rightarrow',
-});
-
-export const leftrightArrow = set({
-  name: 'Left and Right Arrow',
-  latex: '\\leftrightarrow',
-  command: '\\leftrightarrow',
-});

package/src/keys/grades.js

@@ -1,367 +0,0 @@
-import * as comparison from './comparison';
-import * as vars from './vars';
-import * as fractions from './fractions';
-import * as exponent from './exponent';
-import * as misc from './misc';
-import * as constants from './constants';
-import * as trigonometry from './trigonometry';
-import * as geometry from './geometry';
-import * as operators from './operators';
-import * as log from './log';
-import * as subSup from './sub-sup';
-import * as statistics from './statistics';
-import * as basicOperators from './basic-operators';
-import * as matrices from './matrices';
-import digits from './digits';
-import * as logic from './logic';
-import * as nav from './navigation';
-import * as edit from './edit';
-
-const hs = [
-  [fractions.blankOverBlank, misc.percentage, vars.x, exponent.squared, exponent.squareRoot],
-  [operators.circleDot, vars.y, subSup.subscript, exponent.xToPowerOfN, exponent.nthRoot],
-  [misc.plusMinus, comparison.lessThan, comparison.greaterThan, comparison.lessThanEqual, comparison.greaterThanEqual],
-  [constants.pi, vars.theta, misc.parenthesis, misc.brackets, misc.absValue],
-  [misc.notEqual, trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree],
-];
-
-const advancedAlgebra = (() => {
-  const out = [...hs.map((arr) => [...arr])];
-
-  out[0].push({ name: 'i', latex: 'i', write: 'i' });
-  out[1].push(log.log);
-  out[2].push(log.logSubscript);
-  out[3].push(log.ln);
-  out[4].push(constants.eulers);
-  return out;
-})();
-
-const statisticsSet = (() => {
-  const out = [...hs.map((arr) => [...arr])];
-  out[0].push(statistics.mu);
-  out[1].push(statistics.xBar);
-  out[2].push(statistics.yBar);
-  out[3].push(statistics.sigma);
-  out[4].push(statistics.smallSigma);
-  return out;
-})();
-
-export const gradeSets = [
-  {
-    predicate: (n) => n >= 3 && n <= 5,
-    set: [
-      [comparison.lessThan, comparison.greaterThan],
-      [fractions.xOverBlank, fractions.xBlankBlank],
-      [vars.x, logic.longDivision],
-      [exponent.squared, exponent.xToPowerOfN],
-    ],
-  },
-  {
-    predicate: (n) => n >= 6 && n <= 7,
-    set: [
-      [geometry.degree, comparison.lessThan, comparison.greaterThan],
-      [operators.circleDot, comparison.lessThanEqual, comparison.greaterThanEqual],
-      [vars.x, vars.y, exponent.squared, exponent.xToPowerOfN],
-      [misc.plusMinus, fractions.xOverBlank, fractions.xBlankBlank, exponent.squareRoot],
-      [constants.pi, misc.parenthesis, misc.absValue, exponent.nthRoot],
-    ],
-  },
-  {
-    predicate: (n) => n >= 8 || n === 'HS',
-    set: hs,
-  },
-  {
-    predicate: 'non-negative-integers',
-    set: [
-      [digits.seven, digits.eight, digits.nine],
-      [digits.four, digits.five, digits.six],
-      [digits.one, digits.two, digits.three],
-      [digits.zero, { name: '', latex: '', write: '' }, { name: '', latex: '', write: '' }],
-      [nav.left, nav.right, edit.del],
-    ],
-  },
-  {
-    predicate: 'integers',
-    set: [
-      [digits.seven, digits.eight, digits.nine],
-      [digits.four, digits.five, digits.six],
-      [digits.one, digits.two, digits.three],
-      [digits.zero, { name: '', latex: '', write: '' }, basicOperators.minus],
-      [nav.left, nav.right, edit.del],
-    ],
-  },
-  {
-    predicate: 'decimals',
-    set: [
-      [digits.seven, digits.eight, digits.nine],
-      [digits.four, digits.five, digits.six],
-      [digits.one, digits.two, digits.three],
-      [digits.zero, digits.decimalPoint, basicOperators.minus],
-      [nav.left, nav.right, edit.del],
-    ],
-  },
-  {
-    predicate: 'fractions',
-    set: [
-      [digits.seven, digits.eight, digits.nine],
-      [digits.four, digits.five, digits.six],
-      [digits.one, digits.two, digits.three],
-      [digits.zero, fractions.blankOverBlank, basicOperators.minus],
-      [nav.left, nav.right, edit.del],
-    ],
-  },
-  {
-    predicate: 'geometry',
-    set: [
-      [
-        fractions.blankOverBlank,
-        geometry.degree,
-        geometry.primeArcminute,
-        geometry.doublePrimeArcSecond,
-        geometry.congruentTo,
-        geometry.similarTo,
-      ],
-      [
-        operators.circleDot,
-        geometry.angle,
-        geometry.measureOfAngle,
-        geometry.triangle,
-        geometry.notCongruentTo,
-        misc.notSimilar,
-      ],
-      [trigonometry.sin, trigonometry.cos, trigonometry.tan, constants.pi, exponent.squareRoot, exponent.nthRoot],
-      [trigonometry.csc, trigonometry.sec, trigonometry.cot, vars.theta, subSup.subscript, exponent.xToPowerOfN],
-      [
-        geometry.overline,
-        geometry.overRightArrow,
-        geometry.overLeftRightArrow,
-        geometry.overArc,
-        geometry.perpindicular,
-        geometry.parallel,
-      ],
-    ],
-  },
-  // {
-  //   predicate: 'miscellaneous',
-  //   set: [
-  //     [
-  //       subSup.superscript,
-  //       subSup.subscript,
-  //       fractions.blankOverBlank,
-  //       misc.percentage,
-  //       geometry.segment,
-  //       geometry.parallel
-  //     ],
-  //     [
-  //       exponent.squareRoot,
-  //       exponent.nthRoot,
-  //       misc.absValue,
-  //       misc.parenthesis,
-  //       geometry.perpindicular,
-  //       geometry.angle
-  //     ],
-  //     [
-  //       comparison.lessThan,
-  //       comparison.greaterThan,
-  //       geometry.degree,
-  //       misc.approx,
-  //       geometry.measureOfAngle,
-  //       geometry.triangle
-  //     ],
-  //     [
-  //       misc.nApprox,
-  //       misc.notEqual,
-  //       geometry.congruentTo,
-  //       geometry.notCongruentTo,
-  //       geometry.parallelogram,
-  //       geometry.circledDot
-  //     ],
-  //     [
-  //       misc.similar,
-  //       misc.notSimilar,
-  //       comparison.lessThanEqual,
-  //       comparison.greaterThanEqual,
-  //       vars.x,
-  //       vars.y
-  //     ]
-  //   ]
-  // },
-  // {
-  //   predicate: 'everything',
-  //   set: [
-  //     [
-  //       subSup.superscript,
-  //       subSup.subscript,
-  //       fractions.blankOverBlank,
-  //       misc.percentage,
-  //       geometry.segment,
-  //       geometry.parallel
-  //     ],
-  //     [
-  //       exponent.squareRoot,
-  //       exponent.nthRoot,
-  //       misc.absValue,
-  //       misc.parenthesis,
-  //       geometry.perpindicular,
-  //       geometry.angle
-  //     ],
-  //     [
-  //       comparison.lessThan,
-  //       comparison.greaterThan,
-  //       geometry.degree,
-  //       misc.approx,
-  //       geometry.measureOfAngle,
-  //       geometry.triangle
-  //     ],
-  //     [
-  //       misc.nApprox,
-  //       misc.notEqual,
-  //       geometry.congruentTo,
-  //       geometry.notCongruentTo,
-  //       geometry.parallelogram,
-  //       geometry.circledDot
-  //     ],
-  //     [
-  //       misc.similar,
-  //       misc.notSimilar,
-  //       comparison.lessThanEqual,
-  //       comparison.greaterThanEqual,
-  //       vars.x,
-  //       vars.y
-  //     ]
-  //   ]
-  // },
-  {
-    predicate: 'advanced-algebra',
-    set: advancedAlgebra,
-  },
-  {
-    predicate: 'statistics',
-    set: statisticsSet,
-  },
-  {
-    predicate: 'item-authoring',
-    set: [
-      [
-        basicOperators.divide,
-        fractions.blankOverBlank,
-        logic.longDivision,
-        constants.halfInfinity,
-        exponent.squared,
-        exponent.squareRoot,
-        geometry.overline,
-        geometry.overRightArrow,
-        geometry.overLeftRightArrow,
-        log.log,
-      ],
-      [
-        basicOperators.multiply,
-        operators.circleDot,
-        { name: '', latex: '', write: '' },
-        subSup.subscript,
-        exponent.xToPowerOfN,
-        exponent.nthRoot,
-        geometry.perpindicular,
-        geometry.parallel,
-        geometry.overArc,
-        log.logSubscript,
-      ],
-      [
-        misc.plusMinus,
-        constants.pi,
-        vars.theta,
-        geometry.degree,
-        geometry.angle,
-        geometry.leftArrow,
-        geometry.rightArrow,
-        geometry.triangle,
-        geometry.square,
-        log.ln,
-      ],
-      [
-        misc.notEqual,
-        misc.absValue,
-        statistics.smallSigma,
-        statistics.mu,
-        logic.therefore,
-        statistics.sigma,
-        geometry.leftrightArrow,
-        trigonometry.sin,
-        trigonometry.cos,
-        trigonometry.tan,
-      ],
-      [
-        comparison.lessThanEqual,
-        comparison.greaterThanEqual,
-        { name: '', latex: '', write: '' },
-        { name: '', latex: '', write: '' },
-        constants.infinity,
-        { name: '', latex: '', write: '' },
-        { name: '', latex: '', write: '' },
-        trigonometry.csc,
-        trigonometry.sec,
-        trigonometry.cot,
-      ],
-    ],
-  },
-  // for grade 1-2, we want to display the base set only
-  // we need it here because we don't want to display the default set (grade 8)
-  {
-    predicate: (n) => n >= 1 && n <= 2,
-    set: [],
-  },
-];
-
-export const keysForGrade = (n) => {
-  const number = parseInt(n, 10);
-  n = isNaN(number) ? n : number;
-  if (!n) {
-    return [];
-  }
-
-  const match = gradeSets.find((gs) => {
-    if (typeof gs.predicate === 'string') {
-      return gs.predicate === n;
-    } else {
-      return gs.predicate(n);
-    }
-  });
-
-  if (match) {
-    return match.set || [];
-  }
-
-  // if the grade is not found, return the default set which is grade 8 (as per PD-3549), for mode language it is not the default
-  if (n !== 'language') {
-    return gradeSets[2].set;
-  }
-};
-
-const ALL_KEYS = [
-  ...Object.values(basicOperators),
-  ...Object.values(comparison),
-  ...Object.values(constants),
-  ...Object.values(digits),
-  ...Object.values(exponent),
-  ...Object.values(fractions),
-  ...Object.values(geometry),
-  ...Object.values(log),
-  ...Object.values(matrices),
-  ...Object.values(misc),
-  ...Object.values(operators),
-  ...Object.values(statistics),
-  ...Object.values(subSup),
-  ...Object.values(trigonometry),
-  ...Object.values(vars),
-];
-
-export const normalizeAdditionalKeys = (additionalKeys) => {
-  return (additionalKeys || []).map((additionalkey) => {
-    const { latex } = additionalkey;
-    const predefinedKey = (ALL_KEYS || []).find(
-      (key) => latex === key.latex || latex === key.write || latex === key.command || latex === key.otherNotation,
-    );
-
-    return !latex ? additionalkey : predefinedKey || additionalkey;
-  });
-};

package/src/keys/index.js

@@ -1,20 +0,0 @@
-import digits from './digits';
-import * as nav from './navigation';
-import * as edit from './edit';
-import { divide, equals, minus, multiply, plus } from './basic-operators';
-import * as comparison from './comparison';
-import * as fractions from './fractions';
-import * as exponent from './exponent';
-import * as misc from './misc';
-
-const { one, two, three, four, five, six, seven, eight, nine, zero, comma, decimalPoint } = digits;
-
-export const baseSet = [
-  [seven, eight, nine, divide],
-  [four, five, six, multiply],
-  [one, two, three, minus],
-  [zero, decimalPoint, comma, plus],
-  [nav.left, nav.right, edit.del, equals],
-];
-
-export { comparison, fractions, exponent, misc };

package/src/keys/log.js

@@ -1,22 +0,0 @@
-import { mkSet } from './utils';
-
-const set = mkSet('log');
-
-export const log = set({
-  name: 'Log',
-  label: 'log',
-  command: '\\log',
-  latex: '\\log',
-});
-export const logSubscript = set({
-  name: 'log base n',
-  label: 'log s',
-  latex: '\\log_{}',
-  command: ['\\log', '_'],
-});
-export const ln = set({
-  name: 'natural log',
-  label: 'ln',
-  command: '\\ln',
-  latex: '\\ln',
-});

package/src/keys/logic.js

@@ -1,15 +0,0 @@
-import { mkSet } from './utils';
-
-const set = mkSet('logic');
-
-export const therefore = set({
-  name: 'Therefore',
-  label: '∴',
-  write: '∴',
-});
-
-export const longDivision = set({
-  name: 'Long division',
-  latex: '\\longdiv{}',
-  command: '\\longdiv',
-});

package/src/keys/matrices.js

@@ -1,15 +0,0 @@
-import { mkSet } from './utils';
-
-const set = mkSet('matrices');
-
-export const singleCellMatrix = set({
-  name: 'Single Cell Matrix',
-  label: '[ ]',
-  write: '\\begin{pmatrix}\\end{pmatrix}',
-});
-
-export const doubleCellMatrix = set({
-  name: 'Double Cell Matrix',
-  label: '[ ] [ ] \\\\newline [ ] [ ]',
-  write: '\\begin{bmatrix}&\\\\&\\end{bmatrix}',
-});

package/src/keys/misc.js

@@ -1,71 +0,0 @@
-import { mkSet } from './utils';
-
-const set = mkSet('misc');
-
-export const plusMinus = set({
-  name: 'Plus or Minus',
-  latex: '\\pm',
-  write: '\\pm',
-});
-
-export const absValue = set({
-  name: 'Absolute Value',
-  latex: '\\abs{}',
-  symbol: '| |',
-  command: '|',
-});
-
-export const parenthesis = set({
-  name: 'Parenthesis',
-  latex: '\\left(\\right)',
-  symbol: '( )',
-  command: '(',
-});
-
-export const brackets = set({
-  name: 'Brackets',
-  latex: '\\left[\\right]',
-  symbol: '[ ]',
-  command: '[',
-});
-
-// `%` must be escaped. MathQuill was not a real LaTeX parser: it defined
-// `LatexCmds['%']` as a symbol that *serialised* to `\%`, so a bare `%` worked
-// both as a label and as a command. MathLive parses LaTeX properly, where `%`
-// begins a comment - it rendered nothing (a blank button) and, once inserted,
-// silently swallowed the rest of the expression. `\%` is what MathQuill stored
-// all along, so this changes the key only, not the saved latex.
-export const percentage = set({
-  name: 'Percent',
-  latex: '\\%',
-  command: '\\%',
-});
-
-export const approx = set({
-  latex: '\\approx',
-  command: '\\approx',
-  ariaLabel: 'Approximately equal to',
-});
-
-export const nApprox = set({
-  latex: '\\napprox',
-  command: '\\napprox',
-  ariaLabel: 'Not pproximately equal to',
-});
-
-export const notEqual = set({
-  latex: '\\neq',
-  command: '\\neq',
-  ariaLabel: 'Not equals',
-});
-
-export const similar = set({
-  latex: '\\sim',
-  command: '\\sim',
-  ariaLabel: 'Similar',
-});
-export const notSimilar = set({
-  latex: '\\nsim',
-  command: '\\nsim',
-  ariaLabel: 'Not similar',
-});

package/src/keys/navigation.js

@@ -1,8 +0,0 @@
-import { LEFT_ARROW, RIGHT_ARROW } from './chars';
-import { mkSet } from './utils';
-
-const set = mkSet('navigation');
-
-export const left = set({ label: LEFT_ARROW, keystroke: 'Left', ariaLabel: 'Move cursor left' });
-
-export const right = set({ label: RIGHT_ARROW, keystroke: 'Right', ariaLabel: 'Move cursor right' });

package/src/keys/operators.js

@@ -1,10 +0,0 @@
-import { mkSet } from './utils';
-
-const set = mkSet('operators');
-
-export const circleDot = set({
-  name: 'CircleDot',
-  label: '⋅',
-  write: '\\cdot',
-  ariaLabel: 'Dot multiplier',
-});