@cobapen/markdown 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,14 +1,3 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import markdownIt from "markdown-it";
 import { highlighterForMarkdownIt } from "./code/highlight.js";
 import anchor from "markdown-it-anchor";
@@ -23,45 +12,68 @@ import footnote from "markdown-it-footnote";
 import { MathjaxEngine } from "./math/mathjax.js";
 import { mdmath } from "./math/mdmath.js";
 import { fence_custom } from "./code/fence-custom.js";
-var defaultOptions = {
-    showCodeTitleByDefault: false,
+import { replacelink } from "./link/replacelink.js";
+const defaultOptions = {
+  showCodeTitleByDefault: false,
+  markdown: {
+    html: true,
+    linkify: true,
+    highlight: highlighterForMarkdownIt,
+  },
+  math: {
+    tex: {
+      macros: {
+        bm: ["\\boldsymbol{#1}", 1],
+      },
+    },
+  }
 };
-var MarkdownConverter = /** @class */ (function () {
-    function MarkdownConverter(option) {
-        var config = __assign(__assign({}, defaultOptions), option);
-        var mj = new MathjaxEngine({
-            tex: {
-                macros: {
-                    bm: ["\\boldsymbol{#1}", 1],
-                },
-            },
-        });
-        var md = markdownIt({
-            html: true,
-            linkify: true,
-            highlight: highlighterForMarkdownIt,
-        });
-        md.renderer.rules.fence = fence_custom;
-        md.use(anchor)
-            .use(cjkbreaks)
-            .use(footnote)
-            .use(deflist)
-            .use(mdmath(mj))
-            .use(toc, {
-            includeLevel: [2, 3],
-        });
-        this._config = config;
-        this._mj = mj;
-        this._md = md;
-    }
-    MarkdownConverter.prototype.render = function (text) {
-        var env = __assign({}, this._config); // env object must s
-        return this._md.render(text, env);
-    };
-    MarkdownConverter.prototype.mathcss = function () {
-        return this._mj.stylesheet();
-    };
-    return MarkdownConverter;
-}());
-export { MarkdownConverter };
+export class CMarkdown {
+  _config;
+  _mj;
+  _md;
+  constructor(option) {
+    const config = { ...defaultOptions, ...option };
+    const mj = new MathjaxEngine(config.math);
+    const md = markdownIt(config.markdown);
+    this._config = config;
+    this._mj = mj;
+    this._md = md;
+    this.setup(md);
+  }
+  /**
+     * Install plugins and renderers to the markdown-it instance.
+     *
+     * @param md The instance
+     */
+  setup(md) {
+    md.renderer.rules.fence = fence_custom;
+    md.use(anchor)
+      .use(cjkbreaks)
+      .use(footnote)
+      .use(deflist)
+      .use(replacelink)
+      .use(mdmath(this._mj))
+      .use(toc, {
+        includeLevel: [2, 3],
+      });
+  }
+  /**
+     * Render html from markdown.
+     *
+     * @param text markdown text
+     * @returns html text
+     */
+  render(text) {
+    const env = { ...this._config }; // env object must s
+    return this._md.render(text, env);
+  }
+  /**
+     * Returns the MathJax CSS.
+     * @returns
+     */
+  mathcss() {
+    return this._mj.stylesheet();
+  }
+}
 //# sourceMappingURL=index.js.map

package/dist/link/replacelink.d.ts

@@ -0,0 +1,8 @@
+import { PluginWithOptions } from "markdown-it";
+import Token from "markdown-it/lib/token.mjs";
+type ReplaceHandler = (link: string, env: any, token: Token) => string;
+interface Options {
+  replace: ReplaceHandler;
+}
+export declare const replacelink: PluginWithOptions<Options>;
+export default replacelink;

package/dist/link/replacelink.js

@@ -0,0 +1,41 @@
+function defaultHandler(link, _env, _token) {
+  console.log(link);
+  if (!link.startsWith("http") && link.endsWith(".md")) {
+    return link.replace(/\.md$/, ".html");
+  }
+  else {
+    return link;
+  }
+}
+function replaceAttr(token, attrName, handler, env) {
+  token.attrs?.forEach(attr => {
+    if (attr[0] === attrName) {
+      attr[1] = handler(attr[1], env, token);
+    }
+  });
+}
+function getHandler(option) {
+  const replaceFn = option?.replace || defaultHandler;
+  function handler(state) {
+    state.tokens.forEach(token => {
+      if (token.type === "inline" && token.children !== null) {
+        token.children.forEach(childToken => {
+          if (childToken.type == "link_open") {
+            replaceAttr(childToken, "href", replaceFn, state.env);
+          }
+          else if (childToken.type == "image") {
+            replaceAttr(childToken, "src", replaceFn, state.env);
+          }
+        });
+      }
+    });
+  }
+  ;
+  return handler;
+}
+export const replacelink = (md, option) => {
+  const handler = getHandler(option);
+  md.core.ruler.after("linkify", "replace_link", handler);
+};
+export default replacelink;
+//# sourceMappingURL=replacelink.js.map

package/dist/math/mathjax.d.ts

@@ -18,50 +18,50 @@ type N = LiteElement;
 type T = LiteText;
 type D = LiteDocument;
 interface AnyObject {
-    [x: string]: any;
+  [x: string]: any;
 }
 interface TexConfig {
-    packages: string | [string] | AnyObject;
-    inlineMath: [[string, string]];
-    displayMath: [[string, string]];
-    processEscapes: boolean;
-    processEnvironments: boolean;
-    processRefs: boolean;
-    digits: RegExp;
-    tags: string;
-    tagSide: string;
-    tagIndent: string;
-    useLabelIds: boolean;
-    multlineWidth: string;
-    maxMacros: number;
-    maxBuffer: number;
-    baseURL: string;
-    formatError: (jax: object, err: Error) => void;
-    macros: AnyObject;
+  packages: string | [string] | AnyObject;
+  inlineMath: [[string, string]];
+  displayMath: [[string, string]];
+  processEscapes: boolean;
+  processEnvironments: boolean;
+  processRefs: boolean;
+  digits: RegExp;
+  tags: string;
+  tagSide: string;
+  tagIndent: string;
+  useLabelIds: boolean;
+  multlineWidth: string;
+  maxMacros: number;
+  maxBuffer: number;
+  baseURL: string;
+  formatError: (jax: object, err: Error) => void;
+  macros: AnyObject;
 }
 interface CHTMLConfig {
-    scale: number;
-    minScale: number;
-    matchFontHeight: boolean;
-    mtextInheritFont: boolean;
-    merrorInheritFont: boolean;
-    mtextFont: string;
-    merrorFont: string;
-    mathmlspacing: boolean;
-    skipAttributes: AnyObject;
-    exFactor: number;
-    displayAlign: string;
-    displayIndent: number | string;
-    fontURL: string;
-    adaptiveCSS: boolean;
+  scale: number;
+  minScale: number;
+  matchFontHeight: boolean;
+  mtextInheritFont: boolean;
+  merrorInheritFont: boolean;
+  mtextFont: string;
+  merrorFont: string;
+  mathmlspacing: boolean;
+  skipAttributes: AnyObject;
+  exFactor: number;
+  displayAlign: string;
+  displayIndent: number | string;
+  fontURL: string;
+  adaptiveCSS: boolean;
 }
-interface Options {
-    inline: boolean;
-    em: number;
-    ex: number;
-    width: number;
-    tex?: Partial<TexConfig>;
-    chtml?: Partial<CHTMLConfig>;
+export interface Options {
+  inline: boolean;
+  em: number;
+  ex: number;
+  width: number;
+  tex?: Partial<TexConfig>;
+  chtml?: Partial<CHTMLConfig>;
 }
 /**
  * Initialize and encapsulates mathjax instances to generate
@@ -72,26 +72,26 @@ interface Options {
  * in your HTML document to render the equation properly.
  */
 export declare class MathjaxEngine {
-    option: Options;
-    adaptor: LiteAdaptor;
-    tex: TeX<N, T, D>;
-    chtml: CHTML<N, T, D>;
-    html: MathDocument<N, T, D>;
-    constructor(option?: Partial<Options>);
-    /**
+  option: Options;
+  adaptor: LiteAdaptor;
+  tex: TeX<N, T, D>;
+  chtml: CHTML<N, T, D>;
+  html: MathDocument<N, T, D>;
+  constructor(option?: Partial<Options>);
+  /**
      * convert TeX input to CHTML.
      *
      * @param tex       input string
      * @param override  parameter to override the defaults, if you wish to
      * @returns
      */
-    convert(tex: string, override?: Partial<Options>): string;
-    /**
+  convert(tex: string, override?: Partial<Options>): string;
+  /**
      * returns adaptive css (stylesheet for the processed equations only),
      * or the full mathjax css (if configured)
      *
      * @returns css content
      */
-    stylesheet(): string;
+  stylesheet(): string;
 }
 export {};

package/dist/math/mathjax.js

@@ -15,21 +15,21 @@ import { mathjax } from "mathjax-full/js/mathjax.js";
 import { CHTML } from "mathjax-full/js/output/chtml.js";
 import { AllPackages } from "mathjax-full/js/input/tex/AllPackages.js";
 import { merge } from "lodash-es";
-var MATHJAX_DEFAULT_FONT_URL = "https://cdn.jsdelivr.net/npm/mathjax-full@3/es5/output/chtml/fonts/woff-v2";
-var defaultOption = {
-    inline: false,
-    em: 16,
-    ex: 8,
-    width: 80 * 16,
-    tex: {
-        packages: AllPackages,
-    },
-    chtml: {
-        scale: 1.21, // magic # chosen which look nice for me
-        fontURL: MATHJAX_DEFAULT_FONT_URL,
-        adaptiveCSS: true,
-        exFactor: 5,
-    },
+const MATHJAX_DEFAULT_FONT_URL = "https://cdn.jsdelivr.net/npm/mathjax-full@3/es5/output/chtml/fonts/woff-v2";
+const defaultOption = {
+  inline: false,
+  em: 16,
+  ex: 8,
+  width: 80 * 16,
+  tex: {
+    packages: AllPackages,
+  },
+  chtml: {
+    scale: 1.21, // magic # chosen which look nice for me
+    fontURL: MATHJAX_DEFAULT_FONT_URL,
+    adaptiveCSS: true,
+    exFactor: 5,
+  },
 };
 /**
  * Initialize and encapsulates mathjax instances to generate
@@ -39,70 +39,72 @@ var defaultOption = {
  * The other returns a stylesheet document. The stylesheet must be included
  * in your HTML document to render the equation properly.
  */
-var MathjaxEngine = /** @class */ (function () {
-    function MathjaxEngine(option) {
-        var _a;
-        this.option = merge({}, defaultOption, option);
-        if (typeof ((_a = this.option.tex) === null || _a === void 0 ? void 0 : _a.packages) === "string") {
-            this.option.tex.packages = this.option.tex.packages.split(/\s*,\s*/);
-        }
-        this.adaptor = liteAdaptor();
-        RegisterHTMLHandler(this.adaptor);
-        var tex = new TeX(this.option.tex);
-        var chtml = new CHTML(this.option.chtml);
-        var html = mathjax.document("", {
-            InputJax: tex,
-            OutputJax: chtml,
-        });
-        html.addRenderAction("typeset", 155, renderDoc, renderMath);
-        this.tex = tex;
-        this.chtml = chtml;
-        this.html = html;
-        function renderDoc(_doc) { }
-        function renderMath(math, doc) {
-            var adaptor = doc.adaptor;
-            var text = adaptor.node("mjx-copytext", { "aria-hidden": true }, [
-                adaptor.text(math.math),
-            ]);
-            adaptor.setStyle(text, "position", "absolute");
-            adaptor.setStyle(text, "visibility", "hidden");
-            adaptor.setStyle(math.typesetRoot, "position", "relative");
-            adaptor.append(math.typesetRoot, text);
-        }
+export class MathjaxEngine {
+  option;
+  adaptor;
+  tex;
+  chtml;
+  html;
+  constructor(option) {
+    this.option = merge({}, defaultOption, option);
+    if (typeof this.option.tex?.packages === "string") {
+      this.option.tex.packages = this.option.tex.packages.split(/\s*,\s*/);
     }
-    /**
+    this.adaptor = liteAdaptor();
+    RegisterHTMLHandler(this.adaptor);
+    const tex = new TeX(this.option.tex);
+    const chtml = new CHTML(this.option.chtml);
+    const html = mathjax.document("", {
+      InputJax: tex,
+      OutputJax: chtml,
+    });
+    html.addRenderAction("typeset", 155, renderDoc, renderMath);
+    this.tex = tex;
+    this.chtml = chtml;
+    this.html = html;
+    function renderDoc(_doc) { }
+    function renderMath(math, doc) {
+      const adaptor = doc.adaptor;
+      const text = adaptor.node("mjx-copytext", { "aria-hidden": true }, [
+        adaptor.text(math.math),
+      ]);
+      adaptor.setStyle(text, "position", "absolute");
+      adaptor.setStyle(text, "display", "none");
+      adaptor.setStyle(text, "width", "0");
+      adaptor.setStyle(math.typesetRoot, "position", "relative");
+      adaptor.append(math.typesetRoot, text);
+    }
+  }
+  /**
      * convert TeX input to CHTML.
      *
      * @param tex       input string
      * @param override  parameter to override the defaults, if you wish to
      * @returns
      */
-    MathjaxEngine.prototype.convert = function (tex, override) {
-        var _a, _b, _c, _d;
-        var node = this.html.convert(tex, {
-            display: !((_a = override === null || override === void 0 ? void 0 : override.inline) !== null && _a !== void 0 ? _a : this.option.inline),
-            em: (_b = override === null || override === void 0 ? void 0 : override.em) !== null && _b !== void 0 ? _b : this.option.em,
-            ex: (_c = override === null || override === void 0 ? void 0 : override.ex) !== null && _c !== void 0 ? _c : this.option.ex,
-            containerWidth: (_d = override === null || override === void 0 ? void 0 : override.width) !== null && _d !== void 0 ? _d : this.option.width,
-            scale: 1.0,
-        });
-        if (node instanceof LiteElement) {
-            return this.adaptor.outerHTML(node);
-        }
-        else {
-            return "ERROR";
-        }
-    };
-    /**
+  convert(tex, override) {
+    const node = this.html.convert(tex, {
+      display: !(override?.inline ?? this.option.inline),
+      em: override?.em ?? this.option.em,
+      ex: override?.ex ?? this.option.ex,
+      containerWidth: override?.width ?? this.option.width,
+      scale: 1.0,
+    });
+    if (node instanceof LiteElement) {
+      return this.adaptor.outerHTML(node);
+    }
+    else {
+      return "ERROR";
+    }
+  }
+  /**
      * returns adaptive css (stylesheet for the processed equations only),
      * or the full mathjax css (if configured)
      *
      * @returns css content
      */
-    MathjaxEngine.prototype.stylesheet = function () {
-        return this.adaptor.textContent(this.chtml.styleSheet(this.html));
-    };
-    return MathjaxEngine;
-}());
-export { MathjaxEngine };
+  stylesheet() {
+    return this.adaptor.textContent(this.chtml.styleSheet(this.html));
+  }
+}
 //# sourceMappingURL=mathjax.js.map

package/dist/math/mdmath.js

@@ -13,39 +13,39 @@ import { math_block, math_inline } from "./mdparser.js";
  * @returns
  */
 function getRenderers(mathjax) {
-    function renderInlineMath(tex) {
-        return katex.renderToString(tex, {
-            throwOnError: false,
-            strict: function (code, _msg, _token) {
-                switch (code) {
-                    case "unicodeTextInMathMode":
-                        return "ignore";
-                    default:
-                        return "warn";
-                }
-            },
-        });
-    }
-    function renderBlockMath(tex) {
-        try {
-            var math = mathjax.convert(tex);
-            return "<p>" + math + "</p>";
-        }
-        catch (err) {
-            console.error(err);
-            return tex;
+  function renderInlineMath(tex) {
+    return katex.renderToString(tex, {
+      throwOnError: false,
+      strict: (code, _msg, _token) => {
+        switch (code) {
+          case "unicodeTextInMathMode":
+            return "ignore";
+          default:
+            return "warn";
         }
+      },
+    });
+  }
+  function renderBlockMath(tex) {
+    try {
+      const math = mathjax.convert(tex);
+      return "<p>" + math + "</p>";
     }
-    function inlineRenderer(tokens, index) {
-        return renderInlineMath(tokens[index].content);
-    }
-    function blockRenderer(tokens, index) {
-        return renderBlockMath(tokens[index].content + "\n");
+    catch (err) {
+      console.error(err);
+      return tex;
     }
-    return {
-        inlineRenderer: inlineRenderer,
-        blockRenderer: blockRenderer,
-    };
+  }
+  function inlineRenderer(tokens, index) {
+    return renderInlineMath(tokens[index].content);
+  }
+  function blockRenderer(tokens, index) {
+    return renderBlockMath(tokens[index].content + "\n");
+  }
+  return {
+    inlineRenderer,
+    blockRenderer,
+  };
 }
 /**
  * returns a Markdown-It plugin
@@ -54,14 +54,14 @@ function getRenderers(mathjax) {
  * @returns
  */
 export function mdmath(math) {
-    var renderer = getRenderers(math);
-    return function (md) {
-        md.inline.ruler.after("escape", "math_inline", math_inline);
-        md.block.ruler.after("blockquote", "math_block", math_block, {
-            alt: ["paragraph", "reference", "blockquote", "list"],
-        });
-        md.renderer.rules.math_inline = renderer.inlineRenderer;
-        md.renderer.rules.math_block = renderer.blockRenderer;
-    };
+  const renderer = getRenderers(math);
+  return (md) => {
+    md.inline.ruler.after("escape", "math_inline", math_inline);
+    md.block.ruler.after("blockquote", "math_block", math_block, {
+      alt: ["paragraph", "reference", "blockquote", "list"],
+    });
+    md.renderer.rules.math_inline = renderer.inlineRenderer;
+    md.renderer.rules.math_block = renderer.blockRenderer;
+  };
 }
 //# sourceMappingURL=mdmath.js.map