@cnblogs/markdown-it-presets 1.9.3 → 1.9.5

package/dist/commonjs/math/index.cjs

@@ -1,8 +1,235 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathEngine = exports.createMathJaxRenderer = void 0;
-var factory_1 = require("./factory");
-Object.defineProperty(exports, "createMathJaxRenderer", { enumerable: true, get: function () { return factory_1.createMathJaxRenderer; } });
-var model_1 = require("./model");
-Object.defineProperty(exports, "MathEngine", { enumerable: true, get: function () { return model_1.MathEngine; } });
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  MathEngine: () => MathEngine,
+  createMathJaxRenderer: () => createMathJaxRenderer
+});
+module.exports = __toCommonJS(math_exports);
+
+// src/math/model.ts
+var MathEngine = /* @__PURE__ */ ((MathEngine2) => {
+  MathEngine2[MathEngine2["MathJax2"] = 0] = "MathJax2";
+  MathEngine2[MathEngine2["MathJax3"] = 1] = "MathJax3";
+  return MathEngine2;
+})(MathEngine || {});
+var defaultConfig = {
+  [0 /* MathJax2 */]: {
+    entryScript: "https://mathjax.cnblogs.com/2_7_5/MathJax.js?config=TeX-AMS-MML_HTMLorMML&delayStartupUntil=configured&v=20200504",
+    document: window.document,
+    engine: 0 /* MathJax2 */,
+    isEnabled: true
+  },
+  [1 /* MathJax3 */]: {
+    entryScript: "https://mathjax.cnblogs.com/3_2_1/es5/tex-mml-chtml.js",
+    document: window.document,
+    engine: 1 /* MathJax3 */,
+    isEnabled: true
+  }
+};
+
+// src/math/impl.ts
+var import_lodash_es = require("lodash-es");
+var import_load_script_css = require("@cnblogs/load-script-css");
+var Mathjax2Renderer = class {
+  constructor() {
+    this._defaultConfig = defaultConfig[0 /* MathJax2 */];
+    this._defaultMathJaxConfig = {
+      tex2jax: {
+        inlineMath: [
+          ["$", "$"],
+          ["\\(", "\\)"]
+        ],
+        processClass: "math",
+        processEscapes: true
+      },
+      TeX: {
+        equationNumbers: {
+          autoNumber: "AMS",
+          useLabelIds: true
+        },
+        extensions: ["extpfeil.js", "mediawiki-texvc.js"],
+        Macros: { bm: "\\boldsymbol" }
+      },
+      "HTML-CSS": { linebreaks: { automatic: true } },
+      SVG: { linebreaks: { automatic: true } },
+      skipStartupTypeset: true
+    };
+    this._config = this._defaultConfig;
+  }
+  get _global() {
+    var _a;
+    return (_a = this._config.document.defaultView) != null ? _a : window;
+  }
+  render(container, callback) {
+    if (!this._config.isEnabled)
+      return Promise.resolve();
+    return this.init().then((mathjax) => {
+      if (!mathjax)
+        return;
+      const { onRendered } = this._config;
+      mathjax.Hub.Queue(["Typeset", mathjax.Hub, container]);
+      if (onRendered != null) {
+        mathjax.Hub.Queue(() => onRendered(mathjax));
+      }
+      if (callback) {
+        mathjax.Hub.Queue(callback);
+      }
+    }).catch(console.warn);
+  }
+  config(value) {
+    this._config = (0, import_lodash_es.merge)({}, this._defaultConfig, value);
+    return this;
+  }
+  init() {
+    if (this._initTask)
+      return this._initTask;
+    const { entryScript, tapMathJaxConfig, document } = this._config;
+    return this._initTask = (0, import_load_script_css.loadScript)({
+      src: entryScript,
+      id: "mathjax",
+      timeoutSeconds: 10,
+      appendTo: document.head
+    }).then(() => {
+      var _a;
+      const { MathJax } = this._global;
+      if (MathJax) {
+        MathJax.Hub.Config(
+          (_a = tapMathJaxConfig == null ? void 0 : tapMathJaxConfig.call(
+            void 0,
+            Object.assign({}, this._defaultMathJaxConfig)
+          )) != null ? _a : __spreadValues({}, this._defaultMathJaxConfig)
+        );
+        MathJax.Hub.Configured();
+        return MathJax;
+      }
+    }).catch(() => this._initTask = void 0);
+  }
+};
+var MathJax3Renderer = class {
+  constructor() {
+    this._defaultConfig = defaultConfig[1 /* MathJax3 */];
+    this._defaultMathJaxConfig = {
+      tex: {
+        inlineMath: [
+          ["$", "$"],
+          ["\\(", "\\)"]
+        ],
+        processEscapes: true,
+        tags: "ams",
+        useLabelIds: true,
+        macros: {
+          bm: "\\boldsymbol"
+        },
+        packages: { "[+]": ["noerrors", "extpfeil"] }
+      },
+      options: {
+        processHtmlClass: "math",
+        ignoreHtmlClass: "tex2jax_ignore"
+      },
+      loader: {
+        load: ["[tex]/noerrors", "[tex]/extpfeil"]
+      },
+      startup: {
+        typeset: false
+      }
+    };
+    this._config = this._defaultConfig;
+  }
+  config(value) {
+    this._config = (0, import_lodash_es.merge)({}, this._defaultConfig, value);
+    return this;
+  }
+  render(container, callback) {
+    if (!this._config.isEnabled)
+      return Promise.resolve();
+    return this.init().then((mathjax) => {
+      mathjax ? mathjax.startup.promise = mathjax.startup.promise.then(
+        () => mathjax.typesetPromise([container]).then(() => {
+          var _a;
+          try {
+            (_a = this._config.onRendered) == null ? void 0 : _a.call(void 0, mathjax);
+          } catch (e) {
+            console.error(e);
+          }
+          try {
+            callback == null ? void 0 : callback.call(void 0);
+          } catch (e) {
+            console.error(e);
+          }
+        })
+      ) : void 0;
+    }).catch(console.warn);
+  }
+  init() {
+    var _a;
+    return ((_a = this._initTask) != null ? _a : this._initTask = new Promise((resolve, reject) => {
+      var _a2, _b;
+      const { entryScript, tapMathJaxConfig, document: _document } = this._config;
+      const _window = (_a2 = _document.defaultView) != null ? _a2 : window;
+      _window.MathJax = (_b = tapMathJaxConfig == null ? void 0 : tapMathJaxConfig.call(void 0, __spreadValues({}, this._defaultMathJaxConfig))) != null ? _b : __spreadValues({}, this._defaultMathJaxConfig);
+      if (!_window.MathJax.startup) {
+        _window.MathJax.startup = {};
+      }
+      _window.MathJax.startup.ready = () => {
+        var _a3, _b2;
+        (_b2 = (_a3 = _window.MathJax) == null ? void 0 : _a3.startup) == null ? void 0 : _b2.defaultReady();
+        resolve(_window.MathJax);
+      };
+      (0, import_load_script_css.loadScript)({
+        src: entryScript,
+        id: "mathjax",
+        executionStrategy: "defer",
+        appendTo: _window.document.head
+      }).catch(reject);
+    })).catch(() => this._initTask = void 0);
+  }
+};
+
+// src/math/factory.ts
+var createMathJaxRenderer = (rendererConfig) => {
+  switch (rendererConfig.engine) {
+    case 0 /* MathJax2 */:
+      return new Mathjax2Renderer().config(rendererConfig);
+    case 1 /* MathJax3 */:
+      return new MathJax3Renderer().config(rendererConfig);
+    default:
+      throw Error("Renderer unavailable");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MathEngine,
+  createMathJaxRenderer
+});