@pie-element/ebsr 9.12.1 → 9.12.2-next.18

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/mask-markup/with-mask.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withMask = exports.buildLayoutFromMarkup = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _mask = _interopRequireDefault(require("./mask"));
+
+var _componentize2 = _interopRequireDefault(require("./componentize"));
+
+var _serialization = require("./serialization");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var buildLayoutFromMarkup = function buildLayoutFromMarkup(markup, type) {
+  var _componentize = (0, _componentize2["default"])(markup, type),
+      processed = _componentize.markup;
+
+  var value = (0, _serialization.deserialize)(processed);
+  return value.document;
+};
+
+exports.buildLayoutFromMarkup = buildLayoutFromMarkup;
+
+var withMask = function withMask(type, renderChildren) {
+  var _class;
+
+  return _class = /*#__PURE__*/function (_React$Component) {
+    (0, _inherits2["default"])(WithMask, _React$Component);
+
+    var _super = _createSuper(WithMask);
+
+    function WithMask() {
+      (0, _classCallCheck2["default"])(this, WithMask);
+      return _super.apply(this, arguments);
+    }
+
+    (0, _createClass2["default"])(WithMask, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            markup = _this$props.markup,
+            layout = _this$props.layout,
+            value = _this$props.value,
+            onChange = _this$props.onChange;
+        var maskLayout = layout ? layout : buildLayoutFromMarkup(markup, type);
+        return /*#__PURE__*/_react["default"].createElement(_mask["default"], {
+          layout: maskLayout,
+          value: value,
+          onChange: onChange,
+          renderChildren: renderChildren(this.props)
+        });
+      }
+    }]);
+    return WithMask;
+  }(_react["default"].Component), (0, _defineProperty2["default"])(_class, "propTypes", {
+    /**
+     * At the start we'll probably work with markup
+     */
+    markup: _propTypes["default"].string,
+
+    /**
+     * Once we start authoring, it may make sense for use to us layout, which will be a simple js object that maps to `slate.Value`.
+     */
+    layout: _propTypes["default"].object,
+    value: _propTypes["default"].object,
+    onChange: _propTypes["default"].func
+  }), _class;
+};
+
+exports.withMask = withMask;
+//# sourceMappingURL=with-mask.js.map

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/mask-markup/with-mask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/code/mask-markup/with-mask.jsx"],"names":["buildLayoutFromMarkup","markup","type","processed","value","document","withMask","renderChildren","props","layout","onChange","maskLayout","React","Component","PropTypes","string","object","func"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEO,IAAMA,qBAAqB,GAAG,SAAxBA,qBAAwB,CAACC,MAAD,EAASC,IAAT,EAAkB;AACrD,sBAA8B,+BAAaD,MAAb,EAAqBC,IAArB,CAA9B;AAAA,MAAgBC,SAAhB,iBAAQF,MAAR;;AACA,MAAMG,KAAK,GAAG,gCAAYD,SAAZ,CAAd;AACA,SAAOC,KAAK,CAACC,QAAb;AACD,CAJM;;;;AAMA,IAAMC,QAAQ,GAAG,SAAXA,QAAW,CAACJ,IAAD,EAAOK,cAAP,EAA0B;AAAA;;AAChD;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAcE,kBAAS;AACP,0BAA4C,KAAKC,KAAjD;AAAA,YAAQP,MAAR,eAAQA,MAAR;AAAA,YAAgBQ,MAAhB,eAAgBA,MAAhB;AAAA,YAAwBL,KAAxB,eAAwBA,KAAxB;AAAA,YAA+BM,QAA/B,eAA+BA,QAA/B;AAEA,YAAMC,UAAU,GAAGF,MAAM,GAAGA,MAAH,GAAYT,qBAAqB,CAACC,MAAD,EAASC,IAAT,CAA1D;AACA,4BAAO,gCAAC,gBAAD;AAAM,UAAA,MAAM,EAAES,UAAd;AAA0B,UAAA,KAAK,EAAEP,KAAjC;AAAwC,UAAA,QAAQ,EAAEM,QAAlD;AAA4D,UAAA,cAAc,EAAEH,cAAc,CAAC,KAAKC,KAAN;AAA1F,UAAP;AACD;AAnBH;AAAA;AAAA,IAA8BI,kBAAMC,SAApC,yDACqB;AACjB;AACN;AACA;AACMZ,IAAAA,MAAM,EAAEa,sBAAUC,MAJD;;AAKjB;AACN;AACA;AACMN,IAAAA,MAAM,EAAEK,sBAAUE,MARD;AASjBZ,IAAAA,KAAK,EAAEU,sBAAUE,MATA;AAUjBN,IAAAA,QAAQ,EAAEI,sBAAUG;AAVH,GADrB;AAqBD,CAtBM","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport Mask from './mask';\nimport componentize from './componentize';\nimport { deserialize } from './serialization';\n\nexport const buildLayoutFromMarkup = (markup, type) => {\n  const { markup: processed } = componentize(markup, type);\n  const value = deserialize(processed);\n  return value.document;\n};\n\nexport const withMask = (type, renderChildren) => {\n  return class WithMask extends React.Component {\n    static propTypes = {\n      /**\n       * At the start we'll probably work with markup\n       */\n      markup: PropTypes.string,\n      /**\n       * Once we start authoring, it may make sense for use to us layout, which will be a simple js object that maps to `slate.Value`.\n       */\n      layout: PropTypes.object,\n      value: PropTypes.object,\n      onChange: PropTypes.func,\n    };\n\n    render() {\n      const { markup, layout, value, onChange } = this.props;\n\n      const maskLayout = layout ? layout : buildLayoutFromMarkup(markup, type);\n      return <Mask layout={maskLayout} value={value} onChange={onChange} renderChildren={renderChildren(this.props)} />;\n    }\n  };\n};\n"],"file":"with-mask.js"}

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-evaluator/index.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.textToMathText = exports.latexToText = exports["default"] = exports.ave = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var mathjs = _interopRequireWildcard(require("mathjs"));
+
+var _mathExpressions = _interopRequireDefault(require("@pie-framework/math-expressions"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var decimalCommaRegex = /,/g;
+var decimalRegex = /\.|,/g;
+var decimalWithThousandSeparatorNumberRegex = /^(?!0+\.00)(?=.{1,9}(\.|$))(?!0(?!\.))\d{1,3}(,\d{3})*(\.\d+)?$/;
+
+var rationalizeAllPossibleSubNodes = function rationalizeAllPossibleSubNodes(expression) {
+  return rationalize(mathjs.parse(expression));
+};
+
+var rationalize = function rationalize(tree) {
+  var transformedTree = tree.transform(function (node) {
+    try {
+      var rationalizedNode = mathjs.rationalize(node);
+      return rationalizedNode;
+    } catch (_unused) {
+      return node;
+    }
+  });
+  return transformedTree;
+};
+
+function prepareExpression(string, isLatex) {
+  var returnValue = string ? string.trim() : '';
+  returnValue = returnValue.replace(decimalCommaRegex, '.');
+  returnValue = isLatex ? latexToText("".concat(returnValue)) : textToMathText("".concat(returnValue), {
+    unknownCommands: 'passthrough'
+  }).toString();
+  returnValue = returnValue.replace('=', '==');
+  return rationalizeAllPossibleSubNodes(returnValue);
+}
+
+var latexToAstOpts = {
+  missingFactor: function missingFactor(token, e) {
+    console.warn('missing factor for: ', token.token_type);
+
+    if (token.token_type === 'NUMBER') {
+      throw e;
+    }
+
+    return 0;
+  },
+  unknownCommandBehavior: 'passthrough'
+};
+var astToTextOpts = {
+  unicode_operators: {
+    ne: function ne(operands) {
+      return operands.join(' != ');
+    },
+    '%': function _(operands) {
+      return "percent(".concat(operands[0], ")");
+    }
+  }
+};
+
+var latexToText = function latexToText(latex) {
+  var extraOtps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var la = new _mathExpressions["default"].converters.latexToAstObj(_objectSpread(_objectSpread({}, latexToAstOpts), extraOtps));
+  var at = new _mathExpressions["default"].converters.astToTextObj(_objectSpread(_objectSpread({}, astToTextOpts), extraOtps));
+  var ast = la.convert(latex);
+  return at.convert(ast);
+};
+
+exports.latexToText = latexToText;
+
+var textToMathText = function textToMathText(latex) {
+  var extraOtps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var la = new _mathExpressions["default"].converters.textToAstObj(_objectSpread(_objectSpread({}, latexToAstOpts), extraOtps));
+  var at = new _mathExpressions["default"].converters.astToTextObj(_objectSpread(_objectSpread({}, astToTextOpts), extraOtps));
+  var ast = la.convert(latex);
+  return at.convert(ast);
+};
+
+exports.textToMathText = textToMathText;
+
+function shouldRationalizeEntireTree(tree) {
+  var shouldDoIt = true; // we need to iterate the entire tree to check for some conditions that might make rationalization impossible
+
+  try {
+    tree.traverse(function (node) {
+      // if we have a variable as an exponent for power operation, we should not rationalize
+      // try to see if there are power operations with variable exponents
+      if (node.type === 'OperatorNode' && node.fn === 'pow') {
+        var exponent = node.args[1]; // try to see if it can be compiled and evaluated - if it's a non-numerical value, it'll throw an error
+
+        exponent.compile().eval();
+      } // we cannot have variables for unresolved function calls either
+
+
+      if (node.type === 'FunctionNode') {
+        //try to see if the argument that the function is called with can be resolved as non-variable
+        var functionParameter = node.args[0]; // if it holds variables, this will throw an error
+
+        functionParameter.compile().eval();
+      }
+    });
+    mathjs.rationalize(tree);
+  } catch (_unused2) {
+    shouldDoIt = false;
+  }
+
+  return shouldDoIt;
+}
+
+function containsDecimal() {
+  var expression = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return expression.match(decimalRegex);
+}
+
+var SIMPLIFY_RULES = [{
+  l: 'n1^(1/n2)',
+  r: 'nthRoot(n1, n2)'
+}, {
+  l: 'sqrt(n1)',
+  r: 'nthRoot(n1, 2)'
+}];
+
+var simplify = function simplify(v) {
+  return mathjs.simplify(v, SIMPLIFY_RULES.concat(mathjs.simplify.rules));
+}; //.concat(SIMPLIFY_RULES));
+
+
+var areValuesEqual = function areValuesEqual(valueOne, valueTwo) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var allowDecimals = options.allowDecimals,
+      isLatex = options.isLatex,
+      inverse = options.inverse;
+  var valueOneToUse = valueOne;
+  var valueTwoToUse = valueTwo;
+
+  if (allowDecimals === false) {
+    if (containsDecimal(valueOne) || containsDecimal(valueTwo)) {
+      return false;
+    }
+  } else if (allowDecimals === true) {
+    if (containsDecimal(valueOne) && decimalWithThousandSeparatorNumberRegex.test(valueOne)) {
+      valueOneToUse = valueOne.replace(decimalCommaRegex, '');
+    }
+
+    if (containsDecimal(valueTwo) && decimalWithThousandSeparatorNumberRegex.test(valueTwo)) {
+      valueTwoToUse = valueTwo.replace(decimalCommaRegex, '');
+    }
+  }
+
+  var preparedValueOne = prepareExpression(valueOneToUse, isLatex, allowDecimals);
+  var preparedValueTwo = prepareExpression(valueTwoToUse, isLatex, allowDecimals);
+  var one = shouldRationalizeEntireTree(preparedValueOne) ? mathjs.rationalize(preparedValueOne) : preparedValueOne;
+  var two = shouldRationalizeEntireTree(preparedValueTwo) ? mathjs.rationalize(preparedValueTwo) : preparedValueTwo;
+  one = simplify(one);
+  two = simplify(two);
+  var equals = one.equals(two);
+  return inverse ? !equals : equals;
+};
+
+var ave = function ave(a, b) {
+  var am = mathjs.parse(a);
+  var bm = mathjs.parse(b);
+  var arm = simplify(am);
+  var brm = simplify(bm);
+  return arm.equals(brm);
+};
+
+exports.ave = ave;
+var _default = areValuesEqual;
+exports["default"] = _default;
+//# sourceMappingURL=index.js.map

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-evaluator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/code/math-evaluator/index.js"],"names":["decimalCommaRegex","decimalRegex","decimalWithThousandSeparatorNumberRegex","rationalizeAllPossibleSubNodes","expression","rationalize","mathjs","parse","tree","transformedTree","transform","node","rationalizedNode","prepareExpression","string","isLatex","returnValue","trim","replace","latexToText","textToMathText","unknownCommands","toString","latexToAstOpts","missingFactor","token","e","console","warn","token_type","unknownCommandBehavior","astToTextOpts","unicode_operators","ne","operands","join","latex","extraOtps","la","me","converters","latexToAstObj","at","astToTextObj","ast","convert","textToAstObj","shouldRationalizeEntireTree","shouldDoIt","traverse","type","fn","exponent","args","compile","eval","functionParameter","containsDecimal","match","SIMPLIFY_RULES","l","r","simplify","v","concat","rules","areValuesEqual","valueOne","valueTwo","options","allowDecimals","inverse","valueOneToUse","valueTwoToUse","test","preparedValueOne","preparedValueTwo","one","two","equals","ave","a","b","am","bm","arm","brm"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;;;;;;;;;AAEA,IAAMA,iBAAiB,GAAG,IAA1B;AACA,IAAMC,YAAY,GAAG,OAArB;AACA,IAAMC,uCAAuC,GAAG,iEAAhD;;AAEA,IAAMC,8BAA8B,GAAG,SAAjCA,8BAAiC,CAACC,UAAD;AAAA,SAAgBC,WAAW,CAACC,MAAM,CAACC,KAAP,CAAaH,UAAb,CAAD,CAA3B;AAAA,CAAvC;;AACA,IAAMC,WAAW,GAAG,SAAdA,WAAc,CAACG,IAAD,EAAU;AAC5B,MAAMC,eAAe,GAAGD,IAAI,CAACE,SAAL,CAAe,UAACC,IAAD,EAAU;AAC/C,QAAI;AACF,UAAMC,gBAAgB,GAAGN,MAAM,CAACD,WAAP,CAAmBM,IAAnB,CAAzB;AACA,aAAOC,gBAAP;AACD,KAHD,CAGE,gBAAM;AACN,aAAOD,IAAP;AACD;AACF,GAPuB,CAAxB;AAQA,SAAOF,eAAP;AACD,CAVD;;AAYA,SAASI,iBAAT,CAA2BC,MAA3B,EAAmCC,OAAnC,EAA4C;AAC1C,MAAIC,WAAW,GAAGF,MAAM,GAAGA,MAAM,CAACG,IAAP,EAAH,GAAmB,EAA3C;AAEAD,EAAAA,WAAW,GAAGA,WAAW,CAACE,OAAZ,CAAoBlB,iBAApB,EAAuC,GAAvC,CAAd;AAEAgB,EAAAA,WAAW,GAAGD,OAAO,GACjBI,WAAW,WAAIH,WAAJ,EADM,GAEjBI,cAAc,WAAIJ,WAAJ,GAAmB;AAAEK,IAAAA,eAAe,EAAE;AAAnB,GAAnB,CAAd,CAAqEC,QAArE,EAFJ;AAIAN,EAAAA,WAAW,GAAGA,WAAW,CAACE,OAAZ,CAAoB,GAApB,EAAyB,IAAzB,CAAd;AACA,SAAOf,8BAA8B,CAACa,WAAD,CAArC;AACD;;AAED,IAAMO,cAAc,GAAG;AACrBC,EAAAA,aAAa,EAAE,uBAACC,KAAD,EAAQC,CAAR,EAAc;AAC3BC,IAAAA,OAAO,CAACC,IAAR,CAAa,sBAAb,EAAqCH,KAAK,CAACI,UAA3C;;AACA,QAAIJ,KAAK,CAACI,UAAN,KAAqB,QAAzB,EAAmC;AACjC,YAAMH,CAAN;AACD;;AACD,WAAO,CAAP;AACD,GAPoB;AAQrBI,EAAAA,sBAAsB,EAAE;AARH,CAAvB;AAWA,IAAMC,aAAa,GAAG;AACpBC,EAAAA,iBAAiB,EAAE;AACjBC,IAAAA,EAAE,EAAE,YAASC,QAAT,EAAmB;AACrB,aAAOA,QAAQ,CAACC,IAAT,CAAc,MAAd,CAAP;AACD,KAHgB;AAIjB,SAAK,WAASD,QAAT,EAAmB;AACtB,+BAAkBA,QAAQ,CAAC,CAAD,CAA1B;AACD;AANgB;AADC,CAAtB;;AAWO,IAAMf,WAAW,GAAG,SAAdA,WAAc,CAACiB,KAAD,EAA2B;AAAA,MAAnBC,SAAmB,uEAAP,EAAO;AACpD,MAAMC,EAAE,GAAG,IAAIC,4BAAGC,UAAH,CAAcC,aAAlB,iCAAqClB,cAArC,GAAwDc,SAAxD,EAAX;AAEA,MAAMK,EAAE,GAAG,IAAIH,4BAAGC,UAAH,CAAcG,YAAlB,iCAAoCZ,aAApC,GAAsDM,SAAtD,EAAX;AAEA,MAAMO,GAAG,GAAGN,EAAE,CAACO,OAAH,CAAWT,KAAX,CAAZ;AAEA,SAAOM,EAAE,CAACG,OAAH,CAAWD,GAAX,CAAP;AACD,CARM;;;;AAUA,IAAMxB,cAAc,GAAG,SAAjBA,cAAiB,CAACgB,KAAD,EAA2B;AAAA,MAAnBC,SAAmB,uEAAP,EAAO;AACvD,MAAMC,EAAE,GAAG,IAAIC,4BAAGC,UAAH,CAAcM,YAAlB,iCAAoCvB,cAApC,GAAuDc,SAAvD,EAAX;AAEA,MAAMK,EAAE,GAAG,IAAIH,4BAAGC,UAAH,CAAcG,YAAlB,iCAAoCZ,aAApC,GAAsDM,SAAtD,EAAX;AAEA,MAAMO,GAAG,GAAGN,EAAE,CAACO,OAAH,CAAWT,KAAX,CAAZ;AAEA,SAAOM,EAAE,CAACG,OAAH,CAAWD,GAAX,CAAP;AACD,CARM;;;;AAUP,SAASG,2BAAT,CAAqCvC,IAArC,EAA2C;AACzC,MAAIwC,UAAU,GAAG,IAAjB,CADyC,CAGzC;;AACA,MAAI;AACFxC,IAAAA,IAAI,CAACyC,QAAL,CAAc,UAACtC,IAAD,EAAU;AACtB;AACA;AACA,UAAIA,IAAI,CAACuC,IAAL,KAAc,cAAd,IAAgCvC,IAAI,CAACwC,EAAL,KAAY,KAAhD,EAAuD;AACrD,YAAMC,QAAQ,GAAGzC,IAAI,CAAC0C,IAAL,CAAU,CAAV,CAAjB,CADqD,CAGrD;;AACAD,QAAAA,QAAQ,CAACE,OAAT,GAAmBC,IAAnB;AACD,OARqB,CAUtB;;;AACA,UAAI5C,IAAI,CAACuC,IAAL,KAAc,cAAlB,EAAkC;AAChC;AACA,YAAMM,iBAAiB,GAAG7C,IAAI,CAAC0C,IAAL,CAAU,CAAV,CAA1B,CAFgC,CAIhC;;AACAG,QAAAA,iBAAiB,CAACF,OAAlB,GAA4BC,IAA5B;AACD;AACF,KAlBD;AAoBAjD,IAAAA,MAAM,CAACD,WAAP,CAAmBG,IAAnB;AACD,GAtBD,CAsBE,iBAAM;AACNwC,IAAAA,UAAU,GAAG,KAAb;AACD;;AAED,SAAOA,UAAP;AACD;;AAED,SAASS,eAAT,GAA0C;AAAA,MAAjBrD,UAAiB,uEAAJ,EAAI;AACxC,SAAOA,UAAU,CAACsD,KAAX,CAAiBzD,YAAjB,CAAP;AACD;;AACD,IAAM0D,cAAc,GAAG,CACrB;AAAEC,EAAAA,CAAC,EAAE,WAAL;AAAkBC,EAAAA,CAAC,EAAE;AAArB,CADqB,EAErB;AAAED,EAAAA,CAAC,EAAE,UAAL;AAAiBC,EAAAA,CAAC,EAAE;AAApB,CAFqB,CAAvB;;AAKA,IAAMC,QAAQ,GAAG,SAAXA,QAAW,CAACC,CAAD;AAAA,SAAOzD,MAAM,CAACwD,QAAP,CAAgBC,CAAhB,EAAmBJ,cAAc,CAACK,MAAf,CAAsB1D,MAAM,CAACwD,QAAP,CAAgBG,KAAtC,CAAnB,CAAP;AAAA,CAAjB,C,CAA0F;;;AAE1F,IAAMC,cAAc,GAAG,SAAjBA,cAAiB,CAACC,QAAD,EAAWC,QAAX,EAAsC;AAAA,MAAjBC,OAAiB,uEAAP,EAAO;AAC3D,MAGEC,aAHF,GAMID,OANJ,CAGEC,aAHF;AAAA,MAIEvD,OAJF,GAMIsD,OANJ,CAIEtD,OAJF;AAAA,MAKEwD,OALF,GAMIF,OANJ,CAKEE,OALF;AAQA,MAAIC,aAAa,GAAGL,QAApB;AACA,MAAIM,aAAa,GAAGL,QAApB;;AAEA,MAAIE,aAAa,KAAK,KAAtB,EAA6B;AAC3B,QAAIb,eAAe,CAACU,QAAD,CAAf,IAA6BV,eAAe,CAACW,QAAD,CAAhD,EAA4D;AAC1D,aAAO,KAAP;AACD;AACF,GAJD,MAIO,IAAIE,aAAa,KAAK,IAAtB,EAA4B;AACjC,QAAIb,eAAe,CAACU,QAAD,CAAf,IAA6BjE,uCAAuC,CAACwE,IAAxC,CAA6CP,QAA7C,CAAjC,EAAyF;AACvFK,MAAAA,aAAa,GAAGL,QAAQ,CAACjD,OAAT,CAAiBlB,iBAAjB,EAAoC,EAApC,CAAhB;AACD;;AAED,QAAIyD,eAAe,CAACW,QAAD,CAAf,IAA6BlE,uCAAuC,CAACwE,IAAxC,CAA6CN,QAA7C,CAAjC,EAAyF;AACvFK,MAAAA,aAAa,GAAGL,QAAQ,CAAClD,OAAT,CAAiBlB,iBAAjB,EAAoC,EAApC,CAAhB;AACD;AACF;;AAED,MAAM2E,gBAAgB,GAAG9D,iBAAiB,CAAC2D,aAAD,EAAgBzD,OAAhB,EAAyBuD,aAAzB,CAA1C;AACA,MAAMM,gBAAgB,GAAG/D,iBAAiB,CAAC4D,aAAD,EAAgB1D,OAAhB,EAAyBuD,aAAzB,CAA1C;AAEA,MAAIO,GAAG,GAAG9B,2BAA2B,CAAC4B,gBAAD,CAA3B,GAAgDrE,MAAM,CAACD,WAAP,CAAmBsE,gBAAnB,CAAhD,GAAuFA,gBAAjG;AACA,MAAIG,GAAG,GAAG/B,2BAA2B,CAAC6B,gBAAD,CAA3B,GAAgDtE,MAAM,CAACD,WAAP,CAAmBuE,gBAAnB,CAAhD,GAAuFA,gBAAjG;AAEAC,EAAAA,GAAG,GAAGf,QAAQ,CAACe,GAAD,CAAd;AACAC,EAAAA,GAAG,GAAGhB,QAAQ,CAACgB,GAAD,CAAd;AAEA,MAAMC,MAAM,GAAGF,GAAG,CAACE,MAAJ,CAAWD,GAAX,CAAf;AAEA,SAAOP,OAAO,GAAG,CAACQ,MAAJ,GAAaA,MAA3B;AACD,CAtCD;;AAwCO,IAAMC,GAAG,GAAG,SAANA,GAAM,CAACC,CAAD,EAAIC,CAAJ,EAAU;AAC3B,MAAMC,EAAE,GAAG7E,MAAM,CAACC,KAAP,CAAa0E,CAAb,CAAX;AACA,MAAMG,EAAE,GAAG9E,MAAM,CAACC,KAAP,CAAa2E,CAAb,CAAX;AAEA,MAAMG,GAAG,GAAGvB,QAAQ,CAACqB,EAAD,CAApB;AACA,MAAMG,GAAG,GAAGxB,QAAQ,CAACsB,EAAD,CAApB;AACA,SAAOC,GAAG,CAACN,MAAJ,CAAWO,GAAX,CAAP;AACD,CAPM;;;eASQpB,c","sourcesContent":["/* eslint-disable no-console */\nimport * as mathjs from 'mathjs';\nimport me from '@pie-framework/math-expressions';\n\nconst decimalCommaRegex = /,/g;\nconst decimalRegex = /\\.|,/g;\nconst decimalWithThousandSeparatorNumberRegex = /^(?!0+\\.00)(?=.{1,9}(\\.|$))(?!0(?!\\.))\\d{1,3}(,\\d{3})*(\\.\\d+)?$/;\n\nconst rationalizeAllPossibleSubNodes = (expression) => rationalize(mathjs.parse(expression));\nconst rationalize = (tree) => {\n  const transformedTree = tree.transform((node) => {\n    try {\n      const rationalizedNode = mathjs.rationalize(node);\n      return rationalizedNode;\n    } catch {\n      return node;\n    }\n  });\n  return transformedTree;\n};\n\nfunction prepareExpression(string, isLatex) {\n  let returnValue = string ? string.trim() : '';\n\n  returnValue = returnValue.replace(decimalCommaRegex, '.');\n\n  returnValue = isLatex\n    ? latexToText(`${returnValue}`)\n    : textToMathText(`${returnValue}`, { unknownCommands: 'passthrough' }).toString();\n\n  returnValue = returnValue.replace('=', '==');\n  return rationalizeAllPossibleSubNodes(returnValue);\n}\n\nconst latexToAstOpts = {\n  missingFactor: (token, e) => {\n    console.warn('missing factor for: ', token.token_type);\n    if (token.token_type === 'NUMBER') {\n      throw e;\n    }\n    return 0;\n  },\n  unknownCommandBehavior: 'passthrough',\n};\n\nconst astToTextOpts = {\n  unicode_operators: {\n    ne: function(operands) {\n      return operands.join(' != ');\n    },\n    '%': function(operands) {\n      return `percent(${operands[0]})`;\n    },\n  },\n};\n\nexport const latexToText = (latex, extraOtps = {}) => {\n  const la = new me.converters.latexToAstObj({ ...latexToAstOpts, ...extraOtps });\n\n  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });\n\n  const ast = la.convert(latex);\n\n  return at.convert(ast);\n};\n\nexport const textToMathText = (latex, extraOtps = {}) => {\n  const la = new me.converters.textToAstObj({ ...latexToAstOpts, ...extraOtps });\n\n  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });\n\n  const ast = la.convert(latex);\n\n  return at.convert(ast);\n};\n\nfunction shouldRationalizeEntireTree(tree) {\n  let shouldDoIt = true;\n\n  // we need to iterate the entire tree to check for some conditions that might make rationalization impossible\n  try {\n    tree.traverse((node) => {\n      // if we have a variable as an exponent for power operation, we should not rationalize\n      // try to see if there are power operations with variable exponents\n      if (node.type === 'OperatorNode' && node.fn === 'pow') {\n        const exponent = node.args[1];\n\n        // try to see if it can be compiled and evaluated - if it's a non-numerical value, it'll throw an error\n        exponent.compile().eval();\n      }\n\n      // we cannot have variables for unresolved function calls either\n      if (node.type === 'FunctionNode') {\n        //try to see if the argument that the function is called with can be resolved as non-variable\n        const functionParameter = node.args[0];\n\n        // if it holds variables, this will throw an error\n        functionParameter.compile().eval();\n      }\n    });\n\n    mathjs.rationalize(tree);\n  } catch {\n    shouldDoIt = false;\n  }\n\n  return shouldDoIt;\n}\n\nfunction containsDecimal(expression = '') {\n  return expression.match(decimalRegex);\n}\nconst SIMPLIFY_RULES = [\n  { l: 'n1^(1/n2)', r: 'nthRoot(n1, n2)' },\n  { l: 'sqrt(n1)', r: 'nthRoot(n1, 2)' },\n];\n\nconst simplify = (v) => mathjs.simplify(v, SIMPLIFY_RULES.concat(mathjs.simplify.rules)); //.concat(SIMPLIFY_RULES));\n\nconst areValuesEqual = (valueOne, valueTwo, options = {}) => {\n  const {\n    // if explicitly set to false, having a decimal value in either side will result in a false equality\n    // regardless of mathematical correctness\n    allowDecimals,\n    isLatex, // if the passed in values are latex, they need to be escaped\n    inverse, // returns inverse for the comparison result\n  } = options;\n\n  let valueOneToUse = valueOne;\n  let valueTwoToUse = valueTwo;\n\n  if (allowDecimals === false) {\n    if (containsDecimal(valueOne) || containsDecimal(valueTwo)) {\n      return false;\n    }\n  } else if (allowDecimals === true) {\n    if (containsDecimal(valueOne) && decimalWithThousandSeparatorNumberRegex.test(valueOne)) {\n      valueOneToUse = valueOne.replace(decimalCommaRegex, '');\n    }\n\n    if (containsDecimal(valueTwo) && decimalWithThousandSeparatorNumberRegex.test(valueTwo)) {\n      valueTwoToUse = valueTwo.replace(decimalCommaRegex, '');\n    }\n  }\n\n  const preparedValueOne = prepareExpression(valueOneToUse, isLatex, allowDecimals);\n  const preparedValueTwo = prepareExpression(valueTwoToUse, isLatex, allowDecimals);\n\n  let one = shouldRationalizeEntireTree(preparedValueOne) ? mathjs.rationalize(preparedValueOne) : preparedValueOne;\n  let two = shouldRationalizeEntireTree(preparedValueTwo) ? mathjs.rationalize(preparedValueTwo) : preparedValueTwo;\n\n  one = simplify(one);\n  two = simplify(two);\n\n  const equals = one.equals(two);\n\n  return inverse ? !equals : equals;\n};\n\nexport const ave = (a, b) => {\n  const am = mathjs.parse(a);\n  const bm = mathjs.parse(b);\n\n  const arm = simplify(am);\n  const brm = simplify(bm);\n  return arm.equals(brm);\n};\n\nexport default areValuesEqual;\n"],"file":"index.js"}

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-input/horizontal-keypad.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _grades = require("./keys/grades");
+
+var _utils = require("./keys/utils");
+
+var _keypad = _interopRequireDefault(require("./keypad"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var toOldModel = function toOldModel(d) {
+  if (d.command) {
+    return {
+      value: d.command,
+      type: 'command'
+    };
+  } else if (d.write) {
+    return {
+      value: d.write
+    };
+  } else if (d.keystroke) {
+    return {
+      type: 'cursor',
+      value: d.keystroke
+    };
+  }
+};
+
+var HorizontalKeypad = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(HorizontalKeypad, _React$Component);
+
+  var _super = _createSuper(HorizontalKeypad);
+
+  function HorizontalKeypad() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, HorizontalKeypad);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "keypadPress", function (data) {
+      var onClick = _this.props.onClick;
+      onClick(toOldModel(data));
+    });
+    return _this;
+  }
+
+  (0, _createClass2["default"])(HorizontalKeypad, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          mode = _this$props.mode,
+          onFocus = _this$props.onFocus,
+          noDecimal = _this$props.noDecimal,
+          className = _this$props.className,
+          additionalKeys = _this$props.additionalKeys,
+          layoutForKeyPad = _this$props.layoutForKeyPad;
+      var normalizedKeys = (0, _grades.normalizeAdditionalKeys)(additionalKeys);
+      return /*#__PURE__*/_react["default"].createElement(_keypad["default"], {
+        className: className,
+        onFocus: onFocus,
+        noDecimal: noDecimal,
+        layoutForKeyPad: layoutForKeyPad,
+        additionalKeys: (0, _utils.extendKeySet)((0, _grades.keysForGrade)(mode), normalizedKeys),
+        onPress: this.keypadPress,
+        mode: mode
+      });
+    }
+  }]);
+  return HorizontalKeypad;
+}(_react["default"].Component);
+
+exports["default"] = HorizontalKeypad;
+(0, _defineProperty2["default"])(HorizontalKeypad, "propTypes", {
+  className: _propTypes["default"].string,
+  mode: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
+  layoutForKeyPad: _propTypes["default"].object,
+  onClick: _propTypes["default"].func.isRequired,
+  onFocus: _propTypes["default"].func,
+  noDecimal: _propTypes["default"].bool,
+  additionalKeys: _propTypes["default"].array
+});
+(0, _defineProperty2["default"])(HorizontalKeypad, "defaultProps", {
+  mode: 'scientific',
+  noDecimal: false,
+  additionalKeys: []
+});
+//# sourceMappingURL=horizontal-keypad.js.map

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-input/horizontal-keypad.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/code/math-input/horizontal-keypad.jsx"],"names":["toOldModel","d","command","value","type","write","keystroke","HorizontalKeypad","data","onClick","props","mode","onFocus","noDecimal","className","additionalKeys","layoutForKeyPad","normalizedKeys","keypadPress","React","Component","PropTypes","string","oneOfType","number","object","func","isRequired","bool","array"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEA,IAAMA,UAAU,GAAG,SAAbA,UAAa,CAACC,CAAD,EAAO;AACxB,MAAIA,CAAC,CAACC,OAAN,EAAe;AACb,WAAO;AAAEC,MAAAA,KAAK,EAAEF,CAAC,CAACC,OAAX;AAAoBE,MAAAA,IAAI,EAAE;AAA1B,KAAP;AACD,GAFD,MAEO,IAAIH,CAAC,CAACI,KAAN,EAAa;AAClB,WAAO;AAAEF,MAAAA,KAAK,EAAEF,CAAC,CAACI;AAAX,KAAP;AACD,GAFM,MAEA,IAAIJ,CAAC,CAACK,SAAN,EAAiB;AACtB,WAAO;AAAEF,MAAAA,IAAI,EAAE,QAAR;AAAkBD,MAAAA,KAAK,EAAEF,CAAC,CAACK;AAA3B,KAAP;AACD;AACF,CARD;;IAUqBC,gB;;;;;;;;;;;;;;;oGAiBL,UAACC,IAAD,EAAU;AACtB,UAAQC,OAAR,GAAoB,MAAKC,KAAzB,CAAQD,OAAR;AAEAA,MAAAA,OAAO,CAACT,UAAU,CAACQ,IAAD,CAAX,CAAP;AACD,K;;;;;;WAED,kBAAS;AACP,wBAAiF,KAAKE,KAAtF;AAAA,UAAQC,IAAR,eAAQA,IAAR;AAAA,UAAcC,OAAd,eAAcA,OAAd;AAAA,UAAuBC,SAAvB,eAAuBA,SAAvB;AAAA,UAAkCC,SAAlC,eAAkCA,SAAlC;AAAA,UAA6CC,cAA7C,eAA6CA,cAA7C;AAAA,UAA6DC,eAA7D,eAA6DA,eAA7D;AACA,UAAMC,cAAc,GAAG,qCAAwBF,cAAxB,CAAvB;AAEA,0BACE,gCAAC,kBAAD;AACE,QAAA,SAAS,EAAED,SADb;AAEE,QAAA,OAAO,EAAEF,OAFX;AAGE,QAAA,SAAS,EAAEC,SAHb;AAIE,QAAA,eAAe,EAAEG,eAJnB;AAKE,QAAA,cAAc,EAAE,yBAAa,0BAAaL,IAAb,CAAb,EAAiCM,cAAjC,CALlB;AAME,QAAA,OAAO,EAAE,KAAKC,WANhB;AAOE,QAAA,IAAI,EAAEP;AAPR,QADF;AAWD;;;EAtC2CQ,kBAAMC,S;;;iCAA/Bb,gB,eACA;AACjBO,EAAAA,SAAS,EAAEO,sBAAUC,MADJ;AAEjBX,EAAAA,IAAI,EAAEU,sBAAUE,SAAV,CAAoB,CAACF,sBAAUC,MAAX,EAAmBD,sBAAUG,MAA7B,CAApB,CAFW;AAGjBR,EAAAA,eAAe,EAAEK,sBAAUI,MAHV;AAIjBhB,EAAAA,OAAO,EAAEY,sBAAUK,IAAV,CAAeC,UAJP;AAKjBf,EAAAA,OAAO,EAAES,sBAAUK,IALF;AAMjBb,EAAAA,SAAS,EAAEQ,sBAAUO,IANJ;AAOjBb,EAAAA,cAAc,EAAEM,sBAAUQ;AAPT,C;iCADAtB,gB,kBAWG;AACpBI,EAAAA,IAAI,EAAE,YADc;AAEpBE,EAAAA,SAAS,EAAE,KAFS;AAGpBE,EAAAA,cAAc,EAAE;AAHI,C","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport { keysForGrade, normalizeAdditionalKeys } from './keys/grades';\nimport { extendKeySet } from './keys/utils';\nimport Keypad from './keypad';\n\nconst toOldModel = (d) => {\n  if (d.command) {\n    return { value: d.command, type: 'command' };\n  } else if (d.write) {\n    return { value: d.write };\n  } else if (d.keystroke) {\n    return { type: 'cursor', value: d.keystroke };\n  }\n};\n\nexport default class HorizontalKeypad extends React.Component {\n  static propTypes = {\n    className: PropTypes.string,\n    mode: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),\n    layoutForKeyPad: PropTypes.object,\n    onClick: PropTypes.func.isRequired,\n    onFocus: PropTypes.func,\n    noDecimal: PropTypes.bool,\n    additionalKeys: PropTypes.array,\n  };\n\n  static defaultProps = {\n    mode: 'scientific',\n    noDecimal: false,\n    additionalKeys: [],\n  };\n\n  keypadPress = (data) => {\n    const { onClick } = this.props;\n\n    onClick(toOldModel(data));\n  };\n\n  render() {\n    const { mode, onFocus, noDecimal, className, additionalKeys, layoutForKeyPad } = this.props;\n    const normalizedKeys = normalizeAdditionalKeys(additionalKeys);\n\n    return (\n      <Keypad\n        className={className}\n        onFocus={onFocus}\n        noDecimal={noDecimal}\n        layoutForKeyPad={layoutForKeyPad}\n        additionalKeys={extendKeySet(keysForGrade(mode), normalizedKeys)}\n        onPress={this.keypadPress}\n        mode={mode}\n      />\n    );\n  }\n}\n"],"file":"horizontal-keypad.js"}

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-input/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "HorizontalKeypad", {
+  enumerable: true,
+  get: function get() {
+    return _horizontalKeypad["default"];
+  }
+});
+exports.keys = exports.addBrackets = void 0;
+Object.defineProperty(exports, "keysForGrade", {
+  enumerable: true,
+  get: function get() {
+    return _grades.keysForGrade;
+  }
+});
+exports.removeBrackets = exports.mq = void 0;
+Object.defineProperty(exports, "updateSpans", {
+  enumerable: true,
+  get: function get() {
+    return _updateSpans.updateSpans;
+  }
+});
+
+var _grades = require("./keys/grades");
+
+var _updateSpans = require("./updateSpans");
+
+var keys = _interopRequireWildcard(require("./keys"));
+
+exports.keys = keys;
+
+var _horizontalKeypad = _interopRequireDefault(require("./horizontal-keypad"));
+
+var mq = _interopRequireWildcard(require("./mq"));
+
+exports.mq = mq;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var addLeftBracket = function addLeftBracket(s) {
+  return s.indexOf('\\(') === 0 ? s : "\\(".concat(s);
+};
+
+var addRightBracket = function addRightBracket(s) {
+  return s.indexOf('\\)') === s.length - 2 ? s : "".concat(s, "\\)");
+};
+
+var rmLeftBracket = function rmLeftBracket(s) {
+  return s.indexOf('\\(') === 0 ? s.substring(2) : s;
+};
+
+var rmRightBracket = function rmRightBracket(s) {
+  return s.indexOf('\\)') === s.length - 2 ? s.substring(0, s.length - 2) : s;
+};
+
+var addBrackets = function addBrackets(s) {
+  return addRightBracket(addLeftBracket(s));
+};
+
+exports.addBrackets = addBrackets;
+
+var removeBrackets = function removeBrackets(s) {
+  return rmRightBracket(rmLeftBracket(s));
+};
+
+exports.removeBrackets = removeBrackets;
+//# sourceMappingURL=index.js.map

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/code/math-input/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/code/math-input/index.jsx"],"names":["addLeftBracket","s","indexOf","addRightBracket","length","rmLeftBracket","substring","rmRightBracket","addBrackets","removeBrackets"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AAUA;;;;AAEA;;AAEA;;;;;;;;AAZA,IAAMA,cAAc,GAAG,SAAjBA,cAAiB,CAACC,CAAD;AAAA,SAAQA,CAAC,CAACC,OAAF,CAAU,KAAV,MAAqB,CAArB,GAAyBD,CAAzB,gBAAmCA,CAAnC,CAAR;AAAA,CAAvB;;AACA,IAAME,eAAe,GAAG,SAAlBA,eAAkB,CAACF,CAAD;AAAA,SAAQA,CAAC,CAACC,OAAF,CAAU,KAAV,MAAqBD,CAAC,CAACG,MAAF,GAAW,CAAhC,GAAoCH,CAApC,aAA2CA,CAA3C,QAAR;AAAA,CAAxB;;AACA,IAAMI,aAAa,GAAG,SAAhBA,aAAgB,CAACJ,CAAD;AAAA,SAAQA,CAAC,CAACC,OAAF,CAAU,KAAV,MAAqB,CAArB,GAAyBD,CAAC,CAACK,SAAF,CAAY,CAAZ,CAAzB,GAA0CL,CAAlD;AAAA,CAAtB;;AACA,IAAMM,cAAc,GAAG,SAAjBA,cAAiB,CAACN,CAAD;AAAA,SAAQA,CAAC,CAACC,OAAF,CAAU,KAAV,MAAqBD,CAAC,CAACG,MAAF,GAAW,CAAhC,GAAoCH,CAAC,CAACK,SAAF,CAAY,CAAZ,EAAeL,CAAC,CAACG,MAAF,GAAW,CAA1B,CAApC,GAAmEH,CAA3E;AAAA,CAAvB;;AAEA,IAAMO,WAAW,GAAG,SAAdA,WAAc,CAACP,CAAD;AAAA,SAAOE,eAAe,CAACH,cAAc,CAACC,CAAD,CAAf,CAAtB;AAAA,CAApB;;;;AACA,IAAMQ,cAAc,GAAG,SAAjBA,cAAiB,CAACR,CAAD;AAAA,SAAOM,cAAc,CAACF,aAAa,CAACJ,CAAD,CAAd,CAArB;AAAA,CAAvB","sourcesContent":["import { keysForGrade } from './keys/grades';\nimport { updateSpans} from \"./updateSpans\";\n\nconst addLeftBracket = (s) => (s.indexOf('\\\\(') === 0 ? s : `\\\\(${s}`);\nconst addRightBracket = (s) => (s.indexOf('\\\\)') === s.length - 2 ? s : `${s}\\\\)`);\nconst rmLeftBracket = (s) => (s.indexOf('\\\\(') === 0 ? s.substring(2) : s);\nconst rmRightBracket = (s) => (s.indexOf('\\\\)') === s.length - 2 ? s.substring(0, s.length - 2) : s);\n\nconst addBrackets = (s) => addRightBracket(addLeftBracket(s));\nconst removeBrackets = (s) => rmRightBracket(rmLeftBracket(s));\n\nimport * as keys from './keys';\n\nimport HorizontalKeypad from './horizontal-keypad';\n\nimport * as mq from './mq';\n\nexport { keysForGrade, addBrackets, removeBrackets, keys, HorizontalKeypad, mq, updateSpans };\n"],"file":"index.js"}