@pie-lib/math-input 6.8.4-next.0 → 6.8.5-next.0

package/src/keys/digits.js

@@ -10,7 +10,7 @@ const digitMap = {
   6: 'six',
   7: 'seven',
   8: 'eight',
-  9: 'nine'
+  9: 'nine',
 };
 
 const comma = { name: 'comma', label: ',', write: ',', category: 'digit' };
@@ -19,16 +19,16 @@ const decimalPoint = {
   name: 'decimal-point',
   label: '.',
   write: '.',
-  category: 'digit'
+  category: 'digit',
 };
 
 export default times(10, String)
-  .map(n => {
+  .map((n) => {
     return {
       name: digitMap[n],
       write: n,
       label: n,
-      category: 'digit'
+      category: 'digit',
     };
   })
   .reduce(
@@ -36,5 +36,5 @@ export default times(10, String)
       acc[o.name] = o;
       return acc;
     },
-    { comma, decimalPoint }
+    { comma, decimalPoint },
   );

package/src/keys/exponent.js

@@ -5,23 +5,23 @@ const set = mkSet('exponent');
 export const squared = set({
   name: 'Squared',
   latex: 'x^2',
-  write: '^2'
+  write: '^2',
 });
 
 export const xToPowerOfN = set({
   name: 'X to the power of n',
   latex: 'x^{}',
-  command: '^'
+  command: '^',
 });
 
 export const squareRoot = set({
   name: 'Square root',
   latex: '\\sqrt{}',
-  command: '\\sqrt'
+  command: '\\sqrt',
 });
 
 export const nthRoot = set({
   name: 'Nth root',
   latex: '\\sqrt[{}]{}',
-  command: '\\nthroot'
+  command: '\\nthroot',
 });

package/src/keys/fractions.js

@@ -5,19 +5,19 @@ const set = mkSet('fractions');
 export const blankOverBlank = set({
   name: 'blank/blank',
   latex: '\\frac{}{}',
-  command: '\\frac'
+  command: '\\frac',
 });
 
 export const xOverBlank = set({
   latex: '\\frac{x}{ }',
   name: 'X/blank',
   label: 'x/[]',
-  command: '/'
+  command: '/',
 });
 
 export const xBlankBlank = set({
   name: 'X (blank/blank)',
   latex: 'x\\frac{}{}',
   label: 'x([]/[])',
-  command: '\\frac'
+  command: '\\frac',
 });

package/src/keys/geometry.js

@@ -1,110 +1,110 @@
-const set = o => ({ ...o, category: 'geometry' });
+const set = (o) => ({ ...o, category: 'geometry' });
 
 export const overline = set({
   name: 'Overline',
   latex: '\\overline{}',
-  command: '\\overline'
+  command: '\\overline',
 });
 
 export const overRightArrow = set({
   name: 'Overline',
   latex: '\\overrightarrow{}',
-  command: '\\overrightarrow'
+  command: '\\overrightarrow',
 });
 
 export const overLeftRightArrow = set({
   name: 'Overline',
   latex: '\\overleftrightarrow{\\overline{}}', // used this notation to display the pink box
   symbol: 'AB',
-  command: '\\overleftrightarrow'
+  command: '\\overleftrightarrow',
 });
 
 export const segment = set({
   name: 'Segment',
   latex: '\\overleftrightarrow{AB}',
   write: '\\overleftrightarrow{AB}',
-  label: 'AB'
+  label: 'AB',
 });
 
 export const parallel = set({
   name: 'Parallel',
   latex: '\\parallel',
-  command: '\\parallel'
+  command: '\\parallel',
 });
 
 export const notParallel = set({
   name: 'Not Parallel',
   latex: '\\nparallel',
-  command: '\\nparallel'
+  command: '\\nparallel',
 });
 
 export const perpindicular = set({
   name: 'Perpendicular',
   latex: '\\perp',
-  command: '\\perpendicular'
+  command: '\\perpendicular',
 });
 
 export const angle = set({
   name: 'Angle',
   latex: '\\angle',
-  command: '\\angle'
+  command: '\\angle',
 });
 export const overArc = set({
   name: 'Over arc',
   latex: '\\overarc{\\overline{}}', // used this notation to display the pink box
-  command: '\\overarc'
+  command: '\\overarc',
 });
 export const measureOfAngle = set({
   name: 'Measure Of Angle',
   latex: '\\measuredangle',
-  command: ['m', '\\angle']
+  command: ['m', '\\angle'],
 });
 
 export const triangle = set({
   name: 'Triangle',
   latex: '\\triangle',
-  command: '\\triangle'
+  command: '\\triangle',
 });
 
 export const square = set({
   name: 'Square',
   latex: '\\square',
-  command: '\\square'
+  command: '\\square',
 });
 
 export const parallelogram = set({
   name: 'Parallelogram',
   latex: '\\parallelogram',
-  command: '\\parallelogram'
+  command: '\\parallelogram',
 });
 
 export const circledDot = set({
   name: 'Circled Dot',
   latex: '\\odot',
-  command: '\\odot'
+  command: '\\odot',
 });
 
 export const degree = set({
   name: 'Degree',
   latex: '\\degree',
-  command: '\\degree'
+  command: '\\degree',
 });
 
 export const similarTo = set({
   name: 'Similar To',
   command: '\\sim',
-  latex: '\\sim'
+  latex: '\\sim',
 });
 
 export const congruentTo = set({
   name: 'Congruent To',
   command: '\\cong',
-  latex: '\\cong'
+  latex: '\\cong',
 });
 export const notCongruentTo = set({
   name: 'Not Congruent To',
   command: '\\ncong',
-  latex: '\\ncong'
+  latex: '\\ncong',
 });
 
 export const primeArcminute = set({
@@ -113,28 +113,28 @@ export const primeArcminute = set({
   // eslint-disable-next-line
   latex: "'",
   // eslint-disable-next-line
-  write: "'"
+  write: "'",
 });
 export const doublePrimeArcSecond = set({
   name: 'Double Prime/Arcsecond',
   latex: '"',
-  write: '"'
+  write: '"',
 });
 
 export const leftArrow = set({
   name: 'Left Arrow',
   latex: '\\leftarrow',
-  command: '\\leftarrow'
+  command: '\\leftarrow',
 });
 
 export const rightArrow = set({
   name: 'Right Arrow',
   latex: '\\rightarrow',
-  command: '\\rightarrow'
+  command: '\\rightarrow',
 });
 
 export const leftrightArrow = set({
   name: 'Left Right Arrow',
   latex: '\\leftrightarrow',
-  command: '\\leftrightarrow'
+  command: '\\leftrightarrow',
 });

package/src/keys/grades.js

@@ -20,19 +20,13 @@ 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
-  ],
+  [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]
+  [misc.notEqual, trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree],
 ];
 
 const advancedAlgebra = (() => {
-  const out = [...hs.map(arr => [...arr])];
+  const out = [...hs.map((arr) => [...arr])];
 
   out[0].push({ name: 'i', latex: 'i', write: 'i' });
   out[1].push(log.log);
@@ -43,7 +37,7 @@ const advancedAlgebra = (() => {
 })();
 
 const statisticsSet = (() => {
-  const out = [...hs.map(arr => [...arr])];
+  const out = [...hs.map((arr) => [...arr])];
   out[0].push(statistics.mu);
   out[1].push(statistics.xBar);
   out[2].push(statistics.yBar);
@@ -54,26 +48,26 @@ const statisticsSet = (() => {
 
 export const gradeSets = [
   {
-    predicate: n => n >= 3 && n <= 5,
+    predicate: (n) => n >= 3 && n <= 5,
     set: [
       [comparison.lessThan, comparison.greaterThan],
       [fractions.xOverBlank, fractions.xBlankBlank],
-      [vars.x, logic.longDivision]
-    ]
+      [vars.x, logic.longDivision],
+    ],
   },
   {
-    predicate: n => n >= 6 && n <= 7,
+    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]
-    ]
+      [constants.pi, misc.parenthesis, misc.absValue, exponent.nthRoot],
+    ],
   },
   {
-    predicate: n => n >= 8 || n === 'HS',
-    set: hs
+    predicate: (n) => n >= 8 || n === 'HS',
+    set: hs,
   },
   {
     predicate: 'non-negative-integers',
@@ -82,8 +76,8 @@ export const gradeSets = [
       [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]
-    ]
+      [nav.left, nav.right, edit.del],
+    ],
   },
   {
     predicate: 'integers',
@@ -92,8 +86,8 @@ export const gradeSets = [
       [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]
-    ]
+      [nav.left, nav.right, edit.del],
+    ],
   },
   {
     predicate: 'decimals',
@@ -102,8 +96,8 @@ export const gradeSets = [
       [digits.four, digits.five, digits.six],
       [digits.one, digits.two, digits.three],
       [digits.zero, digits.decimalPoint, basicOperators.minus],
-      [nav.left, nav.right, edit.del]
-    ]
+      [nav.left, nav.right, edit.del],
+    ],
   },
   {
     predicate: 'fractions',
@@ -112,8 +106,8 @@ export const gradeSets = [
       [digits.four, digits.five, digits.six],
       [digits.one, digits.two, digits.three],
       [digits.zero, fractions.blankOverBlank, basicOperators.minus],
-      [nav.left, nav.right, edit.del]
-    ]
+      [nav.left, nav.right, edit.del],
+    ],
   },
   {
     predicate: 'geometry',
@@ -124,7 +118,7 @@ export const gradeSets = [
         geometry.primeArcminute,
         geometry.doublePrimeArcSecond,
         geometry.congruentTo,
-        geometry.similarTo
+        geometry.similarTo,
       ],
       [
         operators.circleDot,
@@ -132,33 +126,19 @@ export const gradeSets = [
         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
+        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
-      ]
-    ]
+        geometry.parallel,
+      ],
+    ],
   },
   // {
   //   predicate: 'miscellaneous',
@@ -252,11 +232,11 @@ export const gradeSets = [
   // },
   {
     predicate: 'advanced-algebra',
-    set: advancedAlgebra
+    set: advancedAlgebra,
   },
   {
     predicate: 'statistics',
-    set: statisticsSet
+    set: statisticsSet,
   },
   {
     predicate: 'item-authoring',
@@ -271,7 +251,7 @@ export const gradeSets = [
         geometry.overline,
         geometry.overRightArrow,
         geometry.overLeftRightArrow,
-        log.log
+        log.log,
       ],
       [
         basicOperators.multiply,
@@ -283,7 +263,7 @@ export const gradeSets = [
         geometry.perpindicular,
         geometry.parallel,
         geometry.overArc,
-        log.logSubscript
+        log.logSubscript,
       ],
       [
         misc.plusMinus,
@@ -295,7 +275,7 @@ export const gradeSets = [
         geometry.rightArrow,
         geometry.triangle,
         geometry.square,
-        log.ln
+        log.ln,
       ],
       [
         misc.notEqual,
@@ -307,7 +287,7 @@ export const gradeSets = [
         geometry.leftrightArrow,
         trigonometry.sin,
         trigonometry.cos,
-        trigonometry.tan
+        trigonometry.tan,
       ],
       [
         comparison.lessThanEqual,
@@ -319,20 +299,20 @@ export const gradeSets = [
         { name: '', latex: '', write: '' },
         trigonometry.csc,
         trigonometry.sec,
-        trigonometry.cot
-      ]
-    ]
-  }
+        trigonometry.cot,
+      ],
+    ],
+  },
 ];
 
-export const keysForGrade = n => {
+export const keysForGrade = (n) => {
   const number = parseInt(n, 10);
   n = isNaN(number) ? n : number;
   if (!n) {
     return [];
   }
 
-  const match = gradeSets.find(gs => {
+  const match = gradeSets.find((gs) => {
     if (typeof gs.predicate === 'string') {
       return gs.predicate === n;
     } else {
@@ -360,18 +340,14 @@ const ALL_KEYS = [
   ...Object.values(statistics),
   ...Object.values(subSup),
   ...Object.values(trigonometry),
-  ...Object.values(vars)
+  ...Object.values(vars),
 ];
 
-export const normalizeAdditionalKeys = additionalKeys => {
-  return (additionalKeys || []).map(additionalkey => {
+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
+      (key) => latex === key.latex || latex === key.write || latex === key.command || latex === key.otherNotation,
     );
 
     return !latex ? additionalkey : predefinedKey || additionalkey;

package/src/keys/index.js

@@ -10,7 +10,7 @@ export const baseSet = [
   [four, five, six, multiply],
   [one, two, three, minus],
   [zero, decimalPoint, comma, plus],
-  [nav.left, nav.right, edit.del, equals]
+  [nav.left, nav.right, edit.del, equals],
 ];
 
 import * as comparison from './comparison';

package/src/keys/log.js

@@ -6,17 +6,17 @@ export const log = set({
   name: 'Log',
   label: 'log',
   command: '\\log',
-  latex: '\\log'
+  latex: '\\log',
 });
 export const logSubscript = set({
   name: 'Log with subscript',
   label: 'log s',
   latex: '\\log_{}',
-  command: ['\\log', '_', ' ']
+  command: ['\\log', '_', ' '],
 });
 export const ln = set({
   name: 'Ln',
   label: 'ln',
   command: '\\ln',
-  latex: '\\ln'
+  latex: '\\ln',
 });

package/src/keys/logic.js

@@ -5,11 +5,11 @@ const set = mkSet('logic');
 export const therefore = set({
   name: 'Therefore',
   label: '∴',
-  write: '∴'
+  write: '∴',
 });
 
 export const longDivision = set({
   name: 'Long division',
   latex: '\\longdiv{}',
-  command: '\\longdiv'
+  command: '\\longdiv',
 });

package/src/keys/matrices.js

@@ -5,11 +5,11 @@ const set = mkSet('matrices');
 export const singleCellMatrix = set({
   name: 'Single Cell Matrix',
   label: '[ ]',
-  write: '\\begin{pmatrix}\\end{pmatrix}'
+  write: '\\begin{pmatrix}\\end{pmatrix}',
 });
 
 export const doubleCellMatrix = set({
   name: 'Double Cell Matrix',
   label: '[ ] [ ] \\\\newline [ ] [ ]',
-  write: '\\begin{bmatrix}&\\\\&\\end{bmatrix}'
+  write: '\\begin{bmatrix}&\\\\&\\end{bmatrix}',
 });

package/src/keys/misc.js

@@ -5,56 +5,56 @@ const set = mkSet('misc');
 export const plusMinus = set({
   name: 'Plus/Minus',
   latex: '\\pm',
-  write: '\\pm'
+  write: '\\pm',
 });
 
 export const absValue = set({
   name: 'Absolute Value',
   latex: '\\abs{}',
   symbol: '| |',
-  command: '|'
+  command: '|',
 });
 
 export const parenthesis = set({
   name: 'Parenthesis',
   latex: '\\left(\\right)',
   symbol: '( )',
-  command: '('
+  command: '(',
 });
 
 export const brackets = set({
   name: 'Brackets',
   latex: '\\left[\\right]',
   symbol: '[ ]',
-  command: '['
+  command: '[',
 });
 
 export const percentage = set({
   name: 'Percentage',
   latex: '%',
-  command: '%'
+  command: '%',
 });
 
 export const approx = set({
   latex: '\\approx',
-  command: '\\approx'
+  command: '\\approx',
 });
 
 export const nApprox = set({
   latex: '\\napprox',
-  command: '\\napprox'
+  command: '\\napprox',
 });
 
 export const notEqual = set({
   latex: '\\neq',
-  command: '\\neq'
+  command: '\\neq',
 });
 
 export const similar = set({
   latex: '\\sim',
-  command: '\\sim'
+  command: '\\sim',
 });
 export const notSimilar = set({
   latex: '\\nsim',
-  command: '\\nsim'
+  command: '\\nsim',
 });

package/src/keys/operators.js

@@ -5,5 +5,5 @@ const set = mkSet('operators');
 export const circleDot = set({
   name: 'CircleDot',
   label: '⋅',
-  write: '\\cdot'
+  write: '\\cdot',
 });

package/src/keys/statistics.js

@@ -5,32 +5,32 @@ export const xBar = set({
   name: 'X Bar',
   label: 'x̄',
   latex: '\\overline{x}',
-  write: '\\overline{x}'
+  write: '\\overline{x}',
 });
 
 export const yBar = set({
   name: 'Y Bar',
   latex: '\\overline{y}',
-  write: '\\overline{y}'
+  write: '\\overline{y}',
 });
 
 export const mu = set({
   name: 'mu',
   label: 'mu',
   latex: '\\mu',
-  write: '\\mu'
+  write: '\\mu',
 });
 
 export const sigma = set({
   name: 'Sigma',
   label: '\\Sigma',
   latex: '\\Sigma',
-  write: '\\Sigma'
+  write: '\\Sigma',
 });
 
 export const smallSigma = set({
   name: 'sigma',
   label: '\\sigma',
   latex: '\\sigma',
-  write: '\\sigma'
+  write: '\\sigma',
 });