@cobapen/markdown 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,79 +1,80 @@
 import markdownIt from "markdown-it";
-import { highlighterForMarkdownIt } from "./code/highlight.js";
+import advTable from "markdown-it-adv-table";
 import anchor from "markdown-it-anchor";
 // @ts-ignore
 import cjkbreaks from "markdown-it-cjk-breaks";
 // @ts-ignore
 import deflist from "markdown-it-deflist";
 // @ts-ignore
-import toc from "markdown-it-table-of-contents";
-// @ts-ignore
 import footnote from "markdown-it-footnote";
-import { MathjaxEngine } from "./math/mathjax.js";
-import { mdmath } from "./math/mdmath.js";
+// @ts-ignore
+import toc from "markdown-it-table-of-contents";
 import { fence_custom } from "./code/fence-custom.js";
+import { highlighterForMarkdownIt } from "./code/highlight.js";
 import { replacelink } from "./link/replacelink.js";
+import { MathjaxEngine } from "./math/mathjax.js";
+import { mdmath } from "./math/mdmath.js";
 const defaultOptions = {
-  showCodeTitleByDefault: false,
-  markdown: {
-    html: true,
-    linkify: true,
-    highlight: highlighterForMarkdownIt,
-  },
-  math: {
-    tex: {
-      macros: {
-        bm: ["\\boldsymbol{#1}", 1],
-      },
+    showCodeTitleByDefault: false,
+    markdown: {
+        html: true,
+        linkify: true,
+        highlight: highlighterForMarkdownIt,
     },
-  }
+    math: {
+        tex: {
+            macros: {
+                bm: ["\\boldsymbol{#1}", 1],
+            },
+        },
+    }
 };
 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);
-  }
-  /**
+    _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],
-      });
-  }
-  /**
+    setup(md) {
+        md.renderer.rules.fence = fence_custom;
+        md.use(anchor)
+            .use(cjkbreaks)
+            .use(footnote)
+            .use(deflist)
+            .use(replacelink)
+            .use(advTable)
+            .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);
-  }
-  /**
+    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();
-  }
+    mathcss() {
+        return this._mj.stylesheet();
+    }
 }
-//# sourceMappingURL=index.js.map

package/dist/link/replacelink.d.ts

@@ -2,7 +2,7 @@ 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;
+    replace: ReplaceHandler;
 }
 export declare const replacelink: PluginWithOptions<Options>;
 export default replacelink;

package/dist/link/replacelink.js

@@ -1,41 +1,39 @@
 function defaultHandler(link, _env, _token) {
-  console.log(link);
-  if (!link.startsWith("http") && link.endsWith(".md")) {
-    return link.replace(/\.md$/, ".html");
-  }
-  else {
-    return 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);
-    }
-  });
+    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);
-          }
+    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;
+    }
+    ;
+    return handler;
 }
 export const replacelink = (md, option) => {
-  const handler = getHandler(option);
-  md.core.ruler.after("linkify", "replace_link", handler);
+    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

@@ -1,16 +1,7 @@
-/**
- * mathjax.ts
- *
- * Server-Side Mathjax converter from TeX input to CommonHTML.
- *
- * see official examples for more information
- * https://github.com/mathjax/mathjax-v3
- * https://github.com/mathjax/MathJax-demos-node/blob/master/direct/tex2chtml
-*/
-import { type LiteAdaptor } from "mathjax-full/js/adaptors/liteAdaptor.js";
+import { type LiteDocument } from "mathjax-full/js/adaptors/lite/Document.js";
 import { LiteElement } from "mathjax-full/js/adaptors/lite/Element.js";
 import { type LiteText } from "mathjax-full/js/adaptors/lite/Text.js";
-import { type LiteDocument } from "mathjax-full/js/adaptors/lite/Document.js";
+import { type LiteAdaptor } from "mathjax-full/js/adaptors/liteAdaptor.js";
 import { type MathDocument } from "mathjax-full/js/core/MathDocument.js";
 import { TeX } from "mathjax-full/js/input/tex.js";
 import { CHTML } from "mathjax-full/js/output/chtml.js";
@@ -18,50 +9,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;
 }
 export interface Options {
-  inline: boolean;
-  em: number;
-  ex: number;
-  width: number;
-  tex?: Partial<TexConfig>;
-  chtml?: Partial<CHTMLConfig>;
+    inline: boolean;
+    em: number;
+    ex: number;
+    width: number;
+    tex?: Partial<TexConfig>;
+    chtml?: Partial<CHTMLConfig>;
 }
 /**
  * Initialize and encapsulates mathjax instances to generate
@@ -72,26 +63,26 @@ export 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

@@ -7,29 +7,29 @@
  * https://github.com/mathjax/mathjax-v3
  * https://github.com/mathjax/MathJax-demos-node/blob/master/direct/tex2chtml
 */
-import { liteAdaptor } from "mathjax-full/js/adaptors/liteAdaptor.js";
+import { merge } from "lodash-es";
 import { LiteElement } from "mathjax-full/js/adaptors/lite/Element.js"; /* N */
+import { liteAdaptor } from "mathjax-full/js/adaptors/liteAdaptor.js";
 import { RegisterHTMLHandler } from "mathjax-full/js/handlers/html.js";
+import { AllPackages } from "mathjax-full/js/input/tex/AllPackages.js";
 import { TeX } from "mathjax-full/js/input/tex.js";
 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";
 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,
-  },
+    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
@@ -40,71 +40,70 @@ const defaultOption = {
  * in your HTML document to render the equation properly.
  */
 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);
+    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
      */
-  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);
+    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";
+        }
     }
-    else {
-      return "ERROR";
-    }
-  }
-  /**
+    /**
      * returns adaptive css (stylesheet for the processed equations only),
      * or the full mathjax css (if configured)
      *
      * @returns css content
      */
-  stylesheet() {
-    return this.adaptor.textContent(this.chtml.styleSheet(this.html));
-  }
+    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: (code, _msg, _token) => {
-        switch (code) {
-          case "unicodeTextInMathMode":
-            return "ignore";
-          default:
-            return "warn";
+    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>";
+        }
+        catch (err) {
+            console.error(err);
+            return tex;
         }
-      },
-    });
-  }
-  function renderBlockMath(tex) {
-    try {
-      const math = mathjax.convert(tex);
-      return "<p>" + math + "</p>";
     }
-    catch (err) {
-      console.error(err);
-      return tex;
+    function inlineRenderer(tokens, index) {
+        return renderInlineMath(tokens[index].content);
+    }
+    function blockRenderer(tokens, index) {
+        return renderBlockMath(tokens[index].content + "\n");
     }
-  }
-  function inlineRenderer(tokens, index) {
-    return renderInlineMath(tokens[index].content);
-  }
-  function blockRenderer(tokens, index) {
-    return renderBlockMath(tokens[index].content + "\n");
-  }
-  return {
-    inlineRenderer,
-    blockRenderer,
-  };
+    return {
+        inlineRenderer,
+        blockRenderer,
+    };
 }
 /**
  * returns a Markdown-It plugin
@@ -54,14 +54,13 @@ function getRenderers(mathjax) {
  * @returns
  */
 export function mdmath(math) {
-  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;
-  };
+    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