@cobapen/markdown 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,42 +1,42 @@
 import markdownIt, { Options as MarkdownOptions } from "markdown-it";
 import { Options as MathOptions } from "./math/mathjax.js";
 export interface Config {
-    /**
+  /**
      * Set "true" to display the title (if specified) of the fenced code block.
      * The title is hidden by default, and user must explicitly override the style.
      */
-    showCodeTitleByDefault: boolean;
-    /**
+  showCodeTitleByDefault: boolean;
+  /**
      * MarkdownIt options
      */
-    markdown: Partial<MarkdownOptions>;
-    /**
+  markdown: Partial<MarkdownOptions>;
+  /**
      * MathJax options
      */
-    math: Partial<MathOptions>;
+  math: Partial<MathOptions>;
 }
 export type Options = Partial<Config>;
 export declare class CMarkdown {
-    private readonly _config;
-    private readonly _mj;
-    private readonly _md;
-    constructor(option?: Options);
-    /**
+  private readonly _config;
+  private readonly _mj;
+  private readonly _md;
+  constructor(option?: Options);
+  /**
      * Install plugins and renderers to the markdown-it instance.
      *
      * @param md The instance
      */
-    setup(md: markdownIt): void;
-    /**
+  setup(md: markdownIt): void;
+  /**
      * Render html from markdown.
      *
      * @param text markdown text
      * @returns html text
      */
-    render(text: string): string;
-    /**
+  render(text: string): string;
+  /**
      * Returns the MathJax CSS.
      * @returns
      */
-    mathcss(): string;
+  mathcss(): string;
 }

package/dist/index.js

@@ -12,66 +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";
+import { replacelink } from "./link/replacelink.js";
 const defaultOptions = {
-    showCodeTitleByDefault: false,
-    markdown: {
-        html: true,
-        linkify: true,
-        highlight: highlighterForMarkdownIt,
+  showCodeTitleByDefault: false,
+  markdown: {
+    html: true,
+    linkify: true,
+    highlight: highlighterForMarkdownIt,
+  },
+  math: {
+    tex: {
+      macros: {
+        bm: ["\\boldsymbol{#1}", 1],
+      },
     },
-    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(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(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

@@ -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,40 @@
+function defaultHandler(link, _env, _token) {
+  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;
 }
 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 +72,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

@@ -17,19 +17,19 @@ 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,71 @@ 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);
-        }
-        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
      */
-    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 renderBlockMath(tex) {
-        try {
-            const 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,
-        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) {
-    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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobapen/markdown",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "A markdown converter for cobapen website",
   "keywords": ["markdown"],
   "license": "MIT",