katex 0.12.0 → 0.13.3

package/dist/contrib/auto-render.mjs

@@ -1,15 +1,15 @@
 import katex from '../katex.mjs';
 
 /* eslint no-constant-condition:0 */
-const findEndOfMath = function findEndOfMath(delimiter, text, startIndex) {
+var findEndOfMath = function findEndOfMath(delimiter, text, startIndex) {
   // Adapted from
   // https://github.com/Khan/perseus/blob/master/src/perseus-markdown.jsx
-  let index = startIndex;
-  let braceLevel = 0;
-  const delimLength = delimiter.length;
+  var index = startIndex;
+  var braceLevel = 0;
+  var delimLength = delimiter.length;
 
   while (index < text.length) {
-    const character = text[index];
+    var character = text[index];
 
     if (braceLevel <= 0 && text.slice(index, index + delimLength) === delimiter) {
       return index;
@@ -27,92 +27,68 @@ const findEndOfMath = function findEndOfMath(delimiter, text, startIndex) {
   return -1;
 };
 
-const splitAtDelimiters = function splitAtDelimiters(startData, leftDelim, rightDelim, display) {
-  const finalData = [];
-
-  for (let i = 0; i < startData.length; i++) {
-    if (startData[i].type === "text") {
-      const text = startData[i].data;
-      let lookingForLeft = true;
-      let currIndex = 0;
-      let nextIndex;
-      nextIndex = text.indexOf(leftDelim);
-
-      if (nextIndex !== -1) {
-        currIndex = nextIndex;
-        finalData.push({
-          type: "text",
-          data: text.slice(0, currIndex)
-        });
-        lookingForLeft = false;
-      }
+var escapeRegex = function escapeRegex(string) {
+  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+};
 
-      while (true) {
-        if (lookingForLeft) {
-          nextIndex = text.indexOf(leftDelim, currIndex);
-
-          if (nextIndex === -1) {
-            break;
-          }
-
-          finalData.push({
-            type: "text",
-            data: text.slice(currIndex, nextIndex)
-          });
-          currIndex = nextIndex;
-        } else {
-          nextIndex = findEndOfMath(rightDelim, text, currIndex + leftDelim.length);
-
-          if (nextIndex === -1) {
-            break;
-          }
-
-          finalData.push({
-            type: "math",
-            data: text.slice(currIndex + leftDelim.length, nextIndex),
-            rawData: text.slice(currIndex, nextIndex + rightDelim.length),
-            display: display
-          });
-          currIndex = nextIndex + rightDelim.length;
-        }
+var amsRegex = /^\\begin{/;
 
-        lookingForLeft = !lookingForLeft;
-      }
+var splitAtDelimiters = function splitAtDelimiters(text, delimiters) {
+  var index;
+  var data = [];
+  var regexLeft = new RegExp("(" + delimiters.map(x => escapeRegex(x.left)).join("|") + ")");
 
-      finalData.push({
+  while (true) {
+    index = text.search(regexLeft);
+
+    if (index === -1) {
+      break;
+    }
+
+    if (index > 0) {
+      data.push({
         type: "text",
-        data: text.slice(currIndex)
+        data: text.slice(0, index)
       });
-    } else {
-      finalData.push(startData[i]);
-    }
-  }
+      text = text.slice(index); // now text starts with delimiter
+    } // ... so this always succeeds:
 
-  return finalData;
-};
 
-/* eslint no-console:0 */
+    var i = delimiters.findIndex(delim => text.startsWith(delim.left));
+    index = findEndOfMath(delimiters[i].right, text, delimiters[i].left.length);
 
-const splitWithDelimiters = function splitWithDelimiters(text, delimiters) {
-  let data = [{
-    type: "text",
-    data: text
-  }];
+    if (index === -1) {
+      break;
+    }
+
+    var rawData = text.slice(0, index + delimiters[i].right.length);
+    var math = amsRegex.test(rawData) ? rawData : text.slice(delimiters[i].left.length, index);
+    data.push({
+      type: "math",
+      data: math,
+      rawData,
+      display: delimiters[i].display
+    });
+    text = text.slice(index + delimiters[i].right.length);
+  }
 
-  for (let i = 0; i < delimiters.length; i++) {
-    const delimiter = delimiters[i];
-    data = splitAtDelimiters(data, delimiter.left, delimiter.right, delimiter.display || false);
+  if (text !== "") {
+    data.push({
+      type: "text",
+      data: text
+    });
   }
 
   return data;
 };
+
+/* eslint no-console:0 */
 /* Note: optionsCopy is mutated by this method. If it is ever exposed in the
  * API, we should copy it before mutating.
  */
 
-
-const renderMathInText = function renderMathInText(text, optionsCopy) {
-  const data = splitWithDelimiters(text, optionsCopy.delimiters);
+var renderMathInText = function renderMathInText(text, optionsCopy) {
+  var data = splitAtDelimiters(text, optionsCopy.delimiters);
 
   if (data.length === 1 && data[0].type === 'text') {
     // There is no formula in the text.
@@ -121,14 +97,14 @@ const renderMathInText = function renderMathInText(text, optionsCopy) {
     return null;
   }
 
-  const fragment = document.createDocumentFragment();
+  var fragment = document.createDocumentFragment();
 
-  for (let i = 0; i < data.length; i++) {
+  for (var i = 0; i < data.length; i++) {
     if (data[i].type === "text") {
       fragment.appendChild(document.createTextNode(data[i].data));
     } else {
-      const span = document.createElement("span");
-      let math = data[i].data; // Override any display mode defined in the settings with that
+      var span = document.createElement("span");
+      var math = data[i].data; // Override any display mode defined in the settings with that
       // defined by the text itself
 
       optionsCopy.displayMode = data[i].display;
@@ -156,39 +132,41 @@ const renderMathInText = function renderMathInText(text, optionsCopy) {
   return fragment;
 };
 
-const renderElem = function renderElem(elem, optionsCopy) {
-  for (let i = 0; i < elem.childNodes.length; i++) {
-    const childNode = elem.childNodes[i];
+var renderElem = function renderElem(elem, optionsCopy) {
+  for (var i = 0; i < elem.childNodes.length; i++) {
+    var childNode = elem.childNodes[i];
 
     if (childNode.nodeType === 3) {
       // Text node
-      const frag = renderMathInText(childNode.textContent, optionsCopy);
+      var frag = renderMathInText(childNode.textContent, optionsCopy);
 
       if (frag) {
         i += frag.childNodes.length - 1;
         elem.replaceChild(frag, childNode);
       }
     } else if (childNode.nodeType === 1) {
-      // Element node
-      const className = ' ' + childNode.className + ' ';
-      const shouldRender = optionsCopy.ignoredTags.indexOf(childNode.nodeName.toLowerCase()) === -1 && optionsCopy.ignoredClasses.every(x => className.indexOf(' ' + x + ' ') === -1);
+      (function () {
+        // Element node
+        var className = ' ' + childNode.className + ' ';
+        var shouldRender = optionsCopy.ignoredTags.indexOf(childNode.nodeName.toLowerCase()) === -1 && optionsCopy.ignoredClasses.every(x => className.indexOf(' ' + x + ' ') === -1);
 
-      if (shouldRender) {
-        renderElem(childNode, optionsCopy);
-      }
+        if (shouldRender) {
+          renderElem(childNode, optionsCopy);
+        }
+      })();
     } // Otherwise, it's something else, and ignore it.
 
   }
 };
 
-const renderMathInElement = function renderMathInElement(elem, options) {
+var renderMathInElement = function renderMathInElement(elem, options) {
   if (!elem) {
     throw new Error("No element provided to render");
   }
 
-  const optionsCopy = {}; // Object.assign(optionsCopy, option)
+  var optionsCopy = {}; // Object.assign(optionsCopy, option)
 
-  for (const option in options) {
+  for (var option in options) {
     if (options.hasOwnProperty(option)) {
       optionsCopy[option] = options[option];
     }
@@ -205,11 +183,29 @@ const renderMathInElement = function renderMathInElement(elem, options) {
     display: false
   }, // LaTeX uses $…$, but it ruins the display of normal `$` in text:
   // {left: "$", right: "$", display: false},
-  //  \[…\] must come last in this array. Otherwise, renderMathInElement
-  //  will search for \[ before it searches for $$ or  \(
-  // That makes it susceptible to finding a \\[0.3em] row delimiter and
-  // treating it as if it were the start of a KaTeX math zone.
+  // $ must come after $$
+  // Render AMS environments even if outside $$…$$ delimiters.
   {
+    left: "\\begin{equation}",
+    right: "\\end{equation}",
+    display: true
+  }, {
+    left: "\\begin{align}",
+    right: "\\end{align}",
+    display: true
+  }, {
+    left: "\\begin{alignat}",
+    right: "\\end{alignat}",
+    display: true
+  }, {
+    left: "\\begin{gather}",
+    right: "\\end{gather}",
+    display: true
+  }, {
+    left: "\\begin{CD}",
+    right: "\\end{CD}",
+    display: true
+  }, {
     left: "\\[",
     right: "\\]",
     display: true

package/dist/contrib/copy-tex.css

@@ -6,9 +6,9 @@
  */
 .katex,
 .katex-display {
-    user-select: all;
-    -moz-user-select: all;
     -webkit-user-select: all;
-    -ms-user-select: all;
+       -moz-user-select: all;
+        -ms-user-select: all;
+            user-select: all;
 }
 

package/dist/contrib/copy-tex.js

@@ -8,109 +8,11 @@
 		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
 	}
 })((typeof self !== 'undefined' ? self : this), function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 1);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ (function(module, exports, __webpack_require__) {
-
-// extracted by mini-css-extract-plugin
-
-/***/ }),
-/* 1 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-
-// EXTERNAL MODULE: ./contrib/copy-tex/copy-tex.css
-var copy_tex = __webpack_require__(0);
-
-// CONCATENATED MODULE: ./contrib/copy-tex/katex2tex.js
+return /******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+
+;// CONCATENATED MODULE: ./contrib/copy-tex/katex2tex.js
 // Set these to how you want inline and display math to be delimited.
 var defaultCopyDelimiters = {
   inline: ['$', '$'],
@@ -171,7 +73,7 @@ var katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiters)
   return fragment;
 };
 /* harmony default export */ var katex2tex = (katexReplaceWithTex);
-// CONCATENATED MODULE: ./contrib/copy-tex/copy-tex.js
+;// CONCATENATED MODULE: ./contrib/copy-tex/copy-tex.js
  // Global copy handler to modify behavior on .katex elements.
 
 document.addEventListener('copy', function (event) {
@@ -200,14 +102,15 @@ document.addEventListener('copy', function (event) {
 
   event.preventDefault();
 });
-// CONCATENATED MODULE: ./contrib/copy-tex/copy-tex.webpack.js
+;// CONCATENATED MODULE: ./contrib/copy-tex/copy-tex.webpack.js
 /**
  * This is the webpack entry point for KaTeX. As ECMAScript doesn't support
  * CSS modules natively, a separate entry point is used.
  */
 
 
-
-/***/ })
-/******/ ])["default"];
+__webpack_exports__ = __webpack_exports__.default;
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
 });

package/dist/contrib/copy-tex.min.css

@@ -1 +1 @@
-.katex,.katex-display{user-select:all;-moz-user-select:all;-webkit-user-select:all;-ms-user-select:all}
+.katex,.katex-display{-webkit-user-select:all;-moz-user-select:all;-ms-user-select:all;user-select:all}

package/dist/contrib/copy-tex.min.js

@@ -1 +1 @@
-!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var n=t();for(var r in n)("object"==typeof exports?exports:e)[r]=n[r]}}("undefined"!=typeof self?self:this,function(){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)n.d(r,o,function(t){return e[t]}.bind(null,o));return r},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=1)}([function(e,t,n){},function(e,t,n){"use strict";n.r(t);n(0);var r={inline:["$","$"],display:["$$","$$"]},o=function(e,t){void 0===t&&(t=r);for(var n=e.querySelectorAll(".katex-mathml + .katex-html"),o=0;o<n.length;o++){var l=n[o];l.remove?l.remove(null):l.parentNode.removeChild(l)}for(var i=e.querySelectorAll(".katex-mathml"),a=0;a<i.length;a++){var u=i[a],f=u.querySelector("annotation");f&&(u.replaceWith?u.replaceWith(f):u.parentNode.replaceChild(f,u),f.innerHTML=t.inline[0]+f.innerHTML+t.inline[1])}for(var c=e.querySelectorAll(".katex-display annotation"),d=0;d<c.length;d++){var p=c[d];p.innerHTML=t.display[0]+p.innerHTML.substr(t.inline[0].length,p.innerHTML.length-t.inline[0].length-t.inline[1].length)+t.display[1]}return e};document.addEventListener("copy",function(e){var t=window.getSelection();if(!t.isCollapsed){var n=t.getRangeAt(0).cloneContents();if(n.querySelector(".katex-mathml")){for(var r=[],l=0;l<n.childNodes.length;l++)r.push(n.childNodes[l].outerHTML);e.clipboardData.setData("text/html",r.join("")),e.clipboardData.setData("text/plain",o(n).textContent),e.preventDefault()}}})}]).default});
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var n=t();for(var l in n)("object"==typeof exports?exports:e)[l]=n[l]}}("undefined"!=typeof self?self:this,(function(){return function(){"use strict";var e={},t={inline:["$","$"],display:["$$","$$"]},n=function(e,n){void 0===n&&(n=t);for(var l=e.querySelectorAll(".katex-mathml + .katex-html"),r=0;r<l.length;r++){var i=l[r];i.remove?i.remove(null):i.parentNode.removeChild(i)}for(var o=e.querySelectorAll(".katex-mathml"),a=0;a<o.length;a++){var d=o[a],f=d.querySelector("annotation");f&&(d.replaceWith?d.replaceWith(f):d.parentNode.replaceChild(f,d),f.innerHTML=n.inline[0]+f.innerHTML+n.inline[1])}for(var c=e.querySelectorAll(".katex-display annotation"),s=0;s<c.length;s++){var p=c[s];p.innerHTML=n.display[0]+p.innerHTML.substr(n.inline[0].length,p.innerHTML.length-n.inline[0].length-n.inline[1].length)+n.display[1]}return e};return document.addEventListener("copy",(function(e){var t=window.getSelection();if(!t.isCollapsed){var l=t.getRangeAt(0).cloneContents();if(l.querySelector(".katex-mathml")){for(var r=[],i=0;i<l.childNodes.length;i++)r.push(l.childNodes[i].outerHTML);e.clipboardData.setData("text/html",r.join("")),e.clipboardData.setData("text/plain",n(l).textContent),e.preventDefault()}}})),e=e.default}()}));

package/dist/contrib/copy-tex.mjs

@@ -1,5 +1,5 @@
 // Set these to how you want inline and display math to be delimited.
-const defaultCopyDelimiters = {
+var defaultCopyDelimiters = {
   inline: ['$', '$'],
   // alternative: ['\(', '\)']
   display: ['$$', '$$'] // alternative: ['\[', '\]']
@@ -8,17 +8,17 @@ const defaultCopyDelimiters = {
 // Modifies fragment in-place.  Useful for writing your own 'copy' handler,
 // as in copy-tex.js.
 
-const katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiters) {
+var katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiters) {
   if (copyDelimiters === void 0) {
     copyDelimiters = defaultCopyDelimiters;
   }
 
   // Remove .katex-html blocks that are preceded by .katex-mathml blocks
   // (which will get replaced below).
-  const katexHtml = fragment.querySelectorAll('.katex-mathml + .katex-html');
+  var katexHtml = fragment.querySelectorAll('.katex-mathml + .katex-html');
 
-  for (let i = 0; i < katexHtml.length; i++) {
-    const element = katexHtml[i];
+  for (var i = 0; i < katexHtml.length; i++) {
+    var element = katexHtml[i];
 
     if (element.remove) {
       element.remove(null);
@@ -29,17 +29,18 @@ const katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiter
   // descendant, with inline delimiters.
 
 
-  const katexMathml = fragment.querySelectorAll('.katex-mathml');
+  var katexMathml = fragment.querySelectorAll('.katex-mathml');
 
-  for (let i = 0; i < katexMathml.length; i++) {
-    const element = katexMathml[i];
-    const texSource = element.querySelector('annotation');
+  for (var _i = 0; _i < katexMathml.length; _i++) {
+    var _element = katexMathml[_i];
+
+    var texSource = _element.querySelector('annotation');
 
     if (texSource) {
-      if (element.replaceWith) {
-        element.replaceWith(texSource);
+      if (_element.replaceWith) {
+        _element.replaceWith(texSource);
       } else {
-        element.parentNode.replaceChild(texSource, element);
+        _element.parentNode.replaceChild(texSource, _element);
       }
 
       texSource.innerHTML = copyDelimiters.inline[0] + texSource.innerHTML + copyDelimiters.inline[1];
@@ -47,33 +48,33 @@ const katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiter
   } // Switch display math to display delimiters.
 
 
-  const displays = fragment.querySelectorAll('.katex-display annotation');
+  var displays = fragment.querySelectorAll('.katex-display annotation');
 
-  for (let i = 0; i < displays.length; i++) {
-    const element = displays[i];
-    element.innerHTML = copyDelimiters.display[0] + element.innerHTML.substr(copyDelimiters.inline[0].length, element.innerHTML.length - copyDelimiters.inline[0].length - copyDelimiters.inline[1].length) + copyDelimiters.display[1];
+  for (var _i2 = 0; _i2 < displays.length; _i2++) {
+    var _element2 = displays[_i2];
+    _element2.innerHTML = copyDelimiters.display[0] + _element2.innerHTML.substr(copyDelimiters.inline[0].length, _element2.innerHTML.length - copyDelimiters.inline[0].length - copyDelimiters.inline[1].length) + copyDelimiters.display[1];
   }
 
   return fragment;
 };
 
 document.addEventListener('copy', function (event) {
-  const selection = window.getSelection();
+  var selection = window.getSelection();
 
   if (selection.isCollapsed) {
     return; // default action OK if selection is empty
   }
 
-  const fragment = selection.getRangeAt(0).cloneContents();
+  var fragment = selection.getRangeAt(0).cloneContents();
 
   if (!fragment.querySelector('.katex-mathml')) {
     return; // default action OK if no .katex-mathml elements
   } // Preserve usual HTML copy/paste behavior.
 
 
-  const html = [];
+  var html = [];
 
-  for (let i = 0; i < fragment.childNodes.length; i++) {
+  for (var i = 0; i < fragment.childNodes.length; i++) {
     html.push(fragment.childNodes[i].outerHTML);
   }