@incremark/core 0.3.0 → 0.3.1

package/dist/engines/micromark/index.d.ts

@@ -1,7 +1,7 @@
 import { Root, RootContent } from 'mdast';
-import { C as ContainerConfig, B as BlockStatus, P as ParsedBlock } from '../../index-mZ7yCqNH.js';
-import { I as IAstBuilder, E as EngineParserOptions } from '../../types-C_EW5vfp.js';
-export { b as IncremarkPlugin, c as MicromarkEngineExtension } from '../../types-C_EW5vfp.js';
+import { C as ContainerConfig, B as BlockStatus, P as ParsedBlock } from '../../index-CWuosVAK.js';
+import { I as IAstBuilder, E as EngineParserOptions } from '../../types-N1b99kYB.js';
+export { b as IncremarkPlugin, c as MicromarkEngineExtension } from '../../types-N1b99kYB.js';
 import 'micromark-util-types';
 import 'mdast-util-from-markdown';
 import 'marked';
@@ -83,6 +83,15 @@ declare class MicromarkAstBuilder implements IAstBuilder {
      * @returns ParsedBlock 列表
      */
     nodesToBlocks(nodes: RootContent[], startOffset: number, rawText: string, status: BlockStatus, generateBlockId: () => string): ParsedBlock[];
+    /**
+     * 更新配置选项
+     *
+     * 注意：由于 micromark 的扩展是在 constructor 中缓存的，
+     * 更新配置需要重新初始化扩展。
+     *
+     * @param options 部分配置选项
+     */
+    updateOptions(options: Partial<EngineParserOptions>): void;
 }
 
 /**

package/dist/engines/micromark/index.js

@@ -2,12 +2,12 @@ import { fromMarkdown } from 'mdast-util-from-markdown';
 import { gfmFromMarkdown } from 'mdast-util-gfm';
 import { gfm } from 'micromark-extension-gfm';
 import { gfmFootnoteFromMarkdown } from 'mdast-util-gfm-footnote';
-import { math } from 'micromark-extension-math';
 import { mathFromMarkdown } from 'mdast-util-math';
 import { directive } from 'micromark-extension-directive';
 import { directiveFromMarkdown } from 'mdast-util-directive';
-import { codes, constants, types } from 'micromark-util-symbol';
-import { markdownLineEndingOrSpace } from 'micromark-util-character';
+import { codes, types, constants } from 'micromark-util-symbol';
+import { factorySpace } from 'micromark-factory-space';
+import { markdownLineEnding, markdownLineEndingOrSpace } from 'micromark-util-character';
 import { factoryDestination } from 'micromark-factory-destination';
 import { factoryTitle } from 'micromark-factory-title';
 import { factoryLabel } from 'micromark-factory-label';
@@ -16,6 +16,488 @@ import { gfmFootnote } from 'micromark-extension-gfm-footnote';
 import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
 
 // src/parser/ast/MicromarkAstBuilder.ts
+function mathFlow(_options) {
+  return {
+    tokenize: tokenizeMathFenced,
+    concrete: true,
+    name: "mathFlow"
+  };
+}
+var nonLazyContinuation = {
+  tokenize: tokenizeNonLazyContinuation,
+  partial: true
+};
+function tokenizeMathFenced(effects, ok, nok) {
+  const self = this;
+  const tail = self.events[self.events.length - 1];
+  const initialSize = tail && tail[1].type === types.linePrefix ? tail[2].sliceSerialize(tail[1], true).length : 0;
+  let sizeOpen = 0;
+  return start;
+  function start(code) {
+    if (code !== codes.dollarSign) return nok(code);
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    return sequenceOpen(code);
+  }
+  function sequenceOpen(code) {
+    if (code === codes.dollarSign) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    if (sizeOpen < 2) {
+      return nok(code);
+    }
+    effects.exit("mathFlowFenceSequence");
+    return factorySpace(effects, metaBefore, types.whitespace)(code);
+  }
+  function metaBefore(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      return metaAfter(code);
+    }
+    effects.enter("mathFlowFenceMeta");
+    effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+    return meta(code);
+  }
+  function meta(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.chunkString);
+      effects.exit("mathFlowFenceMeta");
+      return metaAfter(code);
+    }
+    if (code === codes.dollarSign) {
+      return nok(code);
+    }
+    effects.consume(code);
+    return meta;
+  }
+  function metaAfter(code) {
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code);
+    }
+    return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+  }
+  function beforeNonLazyContinuation(code) {
+    return effects.attempt(
+      { tokenize: tokenizeClosingFence, partial: true },
+      after,
+      contentStart
+    )(code);
+  }
+  function contentStart(code) {
+    return (initialSize ? factorySpace(effects, beforeContentChunk, types.linePrefix, initialSize + 1) : beforeContentChunk)(code);
+  }
+  function beforeContentChunk(code) {
+    if (code === codes.eof) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function contentChunk(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit("mathFlowValue");
+      return beforeContentChunk(code);
+    }
+    effects.consume(code);
+    return contentChunk;
+  }
+  function after(code) {
+    effects.exit("mathFlow");
+    return ok(code);
+  }
+  function tokenizeClosingFence(effects2, ok2, nok2) {
+    let size = 0;
+    return factorySpace(
+      effects2,
+      beforeSequenceClose,
+      types.linePrefix,
+      self.parser.constructs.disable?.null?.includes("codeIndented") ? void 0 : constants.tabSize
+    );
+    function beforeSequenceClose(code) {
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      return sequenceClose(code);
+    }
+    function sequenceClose(code) {
+      if (code === codes.dollarSign) {
+        size++;
+        effects2.consume(code);
+        return sequenceClose;
+      }
+      if (size < sizeOpen) {
+        return nok2(code);
+      }
+      effects2.exit("mathFlowFenceSequence");
+      return factorySpace(effects2, afterSequenceClose, types.whitespace)(code);
+    }
+    function afterSequenceClose(code) {
+      if (code === codes.eof || markdownLineEnding(code)) {
+        effects2.exit("mathFlowFence");
+        return ok2(code);
+      }
+      return nok2(code);
+    }
+  }
+}
+function mathFlowTex(_options) {
+  return {
+    tokenize: tokenizeMathFencedTex,
+    concrete: true,
+    name: "mathFlowTex"
+  };
+}
+function tokenizeMathFencedTex(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code !== codes.backslash) return nok(code);
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    effects.consume(code);
+    return afterBackslash;
+  }
+  function afterBackslash(code) {
+    if (code !== codes.leftSquareBracket) {
+      return nok(code);
+    }
+    effects.consume(code);
+    effects.exit("mathFlowFenceSequence");
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code);
+    }
+    return contentStart;
+  }
+  function contentStart(code) {
+    if (code === codes.backslash) {
+      return effects.attempt(
+        { tokenize: tokenizeClosingFenceTex, partial: true },
+        afterClose,
+        beginContent
+      )(code);
+    }
+    return beginContent(code);
+  }
+  function beginContent(code) {
+    if (code === codes.eof) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(nonLazyContinuation, afterLineEnding, after)(code);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function afterLineEnding(code) {
+    return contentStart(code);
+  }
+  function contentChunk(code) {
+    if (code === codes.eof) {
+      effects.exit("mathFlowValue");
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      effects.exit("mathFlowValue");
+      return effects.attempt(nonLazyContinuation, afterLineEnding, after)(code);
+    }
+    if (code === codes.backslash) {
+      effects.exit("mathFlowValue");
+      return effects.attempt(
+        { tokenize: tokenizeClosingFenceTex, partial: true },
+        afterClose,
+        continueContent
+      )(code);
+    }
+    effects.consume(code);
+    return contentChunk;
+  }
+  function continueContent(code) {
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function afterClose(code) {
+    return after(code);
+  }
+  function after(code) {
+    effects.exit("mathFlow");
+    return ok(code);
+  }
+  function tokenizeClosingFenceTex(effects2, ok2, nok2) {
+    return beforeSequenceClose;
+    function beforeSequenceClose(code) {
+      if (code !== codes.backslash) {
+        return nok2(code);
+      }
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      effects2.consume(code);
+      return afterBackslashClose;
+    }
+    function afterBackslashClose(code) {
+      if (code !== codes.rightSquareBracket) {
+        return nok2(code);
+      }
+      effects2.consume(code);
+      effects2.exit("mathFlowFenceSequence");
+      effects2.exit("mathFlowFence");
+      return ok2(code);
+    }
+  }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code === null) {
+      return ok(code);
+    }
+    if (!markdownLineEnding(code)) {
+      return nok(code);
+    }
+    effects.enter(types.lineEnding);
+    effects.consume(code);
+    effects.exit(types.lineEnding);
+    return lineStart;
+  }
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}
+function mathText(options) {
+  return {
+    tokenize: tokenizeMathText,
+    resolve: resolveMathText,
+    previous: previousDollar,
+    name: "mathText"
+  };
+  function tokenizeMathText(effects, ok, nok) {
+    const self = this;
+    let sizeOpen = 0;
+    let size;
+    let token;
+    return start;
+    function start(code) {
+      if (code !== codes.dollarSign) return nok(code);
+      if (!previousDollar.call(self, self.previous)) return nok(code);
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      return sequenceOpen(code);
+    }
+    function sequenceOpen(code) {
+      if (code === codes.dollarSign) {
+        effects.consume(code);
+        sizeOpen++;
+        return sequenceOpen;
+      }
+      effects.exit("mathTextSequence");
+      return between(code);
+    }
+    function between(code) {
+      if (code === codes.eof) {
+        return nok(code);
+      }
+      if (code === codes.dollarSign) {
+        token = effects.enter("mathTextSequence");
+        size = 0;
+        return sequenceClose(code);
+      }
+      if (code === codes.space) {
+        effects.enter("space");
+        effects.consume(code);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function data(code) {
+      if (code === codes.eof || code === codes.space || code === codes.dollarSign || markdownLineEnding(code)) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      effects.consume(code);
+      return data;
+    }
+    function sequenceClose(code) {
+      if (code === codes.dollarSign) {
+        effects.consume(code);
+        size++;
+        return sequenceClose;
+      }
+      if (size === sizeOpen) {
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok(code);
+      }
+      token.type = "mathTextData";
+      return data(code);
+    }
+  }
+}
+function mathTextTex(options) {
+  return {
+    tokenize: tokenizeMathTextTex,
+    resolve: resolveMathText,
+    previous: previousBackslash,
+    name: "mathTextTex"
+  };
+  function tokenizeMathTextTex(effects, ok, nok) {
+    const self = this;
+    return start;
+    function start(code) {
+      if (code !== codes.backslash) return nok(code);
+      if (!previousBackslash.call(self, self.previous)) return nok(code);
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      effects.consume(code);
+      return afterBackslash;
+    }
+    function afterBackslash(code) {
+      if (code !== codes.leftParenthesis) {
+        return nok(code);
+      }
+      effects.consume(code);
+      effects.exit("mathTextSequence");
+      return between;
+    }
+    function between(code) {
+      if (code === codes.eof) {
+        return nok(code);
+      }
+      if (code === codes.backslash) {
+        effects.enter("mathTextSequence");
+        effects.consume(code);
+        return checkClose;
+      }
+      if (code === codes.space) {
+        effects.enter("space");
+        effects.consume(code);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function checkClose(code) {
+      if (code === codes.rightParenthesis) {
+        effects.consume(code);
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok;
+      }
+      effects.exit("mathTextSequence");
+      if (code === codes.backslash || code === codes.space || markdownLineEnding(code) || code === codes.eof) {
+        return between(code);
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function data(code) {
+      if (code === codes.eof) {
+        effects.exit("mathTextData");
+        return nok(code);
+      }
+      if (code === codes.backslash) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      if (code === codes.space || markdownLineEnding(code)) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      effects.consume(code);
+      return data;
+    }
+  }
+}
+var resolveMathText = (events) => {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  let index;
+  let enter;
+  if ((events[headEnterIndex][1].type === types.lineEnding || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === types.lineEnding || events[tailExitIndex][1].type === "space")) {
+    index = headEnterIndex;
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === "mathTextData") {
+        events[tailExitIndex][1].type = "mathTextPadding";
+        events[headEnterIndex][1].type = "mathTextPadding";
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break;
+      }
+    }
+  }
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === void 0) {
+      if (index !== tailExitIndex && events[index][1].type !== types.lineEnding) {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === types.lineEnding) {
+      events[enter][1].type = "mathTextData";
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+      enter = void 0;
+    }
+  }
+  return events;
+};
+function previousDollar(code) {
+  return code !== codes.dollarSign || this.events[this.events.length - 1][1].type === types.characterEscape;
+}
+function previousBackslash(code) {
+  return code !== codes.backslash || this.events[this.events.length - 1][1].type === types.characterEscape;
+}
+
+// src/extensions/micromark-extension-math/types.ts
+function resolveMathOptions(options) {
+  return {
+    singleDollarTextMath: options?.singleDollarTextMath,
+    tex: options?.tex ?? false
+  };
+}
+
+// src/extensions/micromark-extension-math/index.ts
+function math(options) {
+  const resolved = resolveMathOptions(options);
+  const extension = {
+    flow: {
+      [codes.dollarSign]: mathFlow()
+    },
+    text: {
+      [codes.dollarSign]: mathText()
+    }
+  };
+  if (resolved.tex) {
+    extension.flow[codes.backslash] = mathFlowTex();
+    extension.text[codes.backslash] = mathTextTex();
+  }
+  return extension;
+}
 
 // src/extensions/html-extension/index.ts
 var DEFAULT_TAG_BLACKLIST = [
@@ -945,7 +1427,11 @@ var MicromarkAstBuilder = class {
       this.cachedMdastExtensions.push(...gfmFromMarkdown(), gfmFootnoteFromMarkdown());
     }
     if (this.options.math) {
-      this.cachedExtensions.push(math());
+      const mathOptions = typeof this.options.math === "object" ? this.options.math : {};
+      this.cachedExtensions.push(math({
+        singleDollarTextMath: true,
+        tex: mathOptions.tex ?? false
+      }));
       this.cachedMdastExtensions.push(mathFromMarkdown());
     }
     if (this.containerConfig !== void 0) {
@@ -1105,6 +1591,26 @@ var MicromarkAstBuilder = class {
     }
     return blocks;
   }
+  /**
+   * 更新配置选项
+   *
+   * 注意：由于 micromark 的扩展是在 constructor 中缓存的，
+   * 更新配置需要重新初始化扩展。
+   *
+   * @param options 部分配置选项
+   */
+  updateOptions(options) {
+    Object.assign(this.options, options);
+    if ("containers" in options) {
+      this.containerConfig = this.computeContainerConfig(this.options);
+    }
+    if ("htmlTree" in options) {
+      this.htmlTreeConfig = this.computeHtmlTreeConfig(this.options);
+    }
+    this.cachedExtensions.length = 0;
+    this.cachedMdastExtensions.length = 0;
+    this.initExtensions();
+  }
 };
 
 // src/engines/micromark/index.ts