@ziloen/micromark-extension-math 3.1.0-patch.0

package/lib/math-text.js

@@ -0,0 +1,339 @@
+/**
+ * @import {Options} from '@ziloen/micromark-extension-math'
+ * @import {Construct, Previous, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+ */
+
+// To do: next major: clean spaces in HTML compiler.
+// This has to be coordinated together with `mdast-util-math`.
+
+import { asciiDigit, markdownLineEnding, markdownSpace } from 'micromark-util-character';
+/**
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {Construct}
+ *   Construct.
+ */
+export function mathText(options) {
+  const options_ = options || {};
+  let single = options_.singleDollarTextMath;
+  if (single === null || single === undefined) {
+    single = true;
+  }
+  return {
+    tokenize: tokenizeMathText,
+    resolve: resolveMathText,
+    previous: previousCode,
+    name: 'mathText'
+  };
+
+  /**
+   * @this {TokenizeContext}
+   * @type {Tokenizer}
+   */
+  function tokenizeMathText(effects, ok, nok) {
+    const self = this;
+    /** @type {number} */
+    let codeOpen = 36;
+    /** @type {number} */
+    let codeClose = 36;
+    /** @type {'mathText' | 'mathTextDisplay'} */
+    let type = 'mathText';
+    let sizeOpen = 0;
+    /** @type {number} */
+    let size;
+    /** @type {number | null | undefined} */
+    let previous;
+    /** @type {Token} */
+    let tokenType;
+    /** @type {Token} */
+    let token;
+    let dataSeen = false;
+    return start;
+
+    /**
+     * Start of math (text).
+     *
+     * ```markdown
+     * > | $a$
+     *     ^
+     * > | \$a$
+     *      ^
+     * ```
+     *
+     * @type {State}
+     */
+    function start(code) {
+      if (code === 92) {
+        codeOpen = 40;
+        codeClose = 41;
+      }
+      tokenType = effects.enter(type);
+      effects.enter('mathTextSequence');
+      effects.consume(code);
+      sizeOpen++;
+      return code === 92 ? sequenceOpenBackslash : sequenceOpen;
+    }
+
+    /**
+     * In opening sequence.
+     *
+     * ```markdown
+     * > | $a$
+     *     ^
+     * ```
+     *
+     * @type {State}
+     */
+
+    function sequenceOpen(code) {
+      if (code === 36) {
+        effects.consume(code);
+        sizeOpen++;
+        return sequenceOpen;
+      }
+
+      // Not enough markers in the sequence.
+      if (sizeOpen < 2 && !single || sizeOpen === 1 && !validSingleDollarOpen(code)) {
+        return nok(code);
+      }
+      effects.exit('mathTextSequence');
+      return between(code);
+    }
+
+    /**
+     * After the backslash in an opening sequence.
+     *
+     * ```markdown
+     * > | \(a\)
+     *      ^
+     * > | \[a\]
+     *      ^
+     * ```
+     *
+     * @type {State}
+     */
+    function sequenceOpenBackslash(code) {
+      if (code !== 40 && code !== 91) {
+        return nok(code);
+      }
+      codeOpen = code;
+      codeClose = code === 40 ? 41 : 93;
+      type = code === 40 ? 'mathText' : 'mathTextDisplay';
+      tokenType.type = type;
+      effects.consume(code);
+      effects.exit('mathTextSequence');
+      return between;
+    }
+
+    /**
+     * Between something and something else.
+     *
+     * ```markdown
+     * > | $a$
+     *      ^^
+     * ```
+     *
+     * @type {State}
+     */
+    function between(code) {
+      if (code === null) {
+        return nok(code);
+      }
+      if (code === 36 && codeOpen === 36) {
+        token = effects.enter('mathTextSequence');
+        size = 0;
+        return sequenceClose(code);
+      }
+      if (code === 92 && codeOpen !== 36) {
+        token = effects.enter('mathTextSequence');
+        return sequenceCloseBackslash(code);
+      }
+
+      // Tabs don’t work, and virtual spaces don’t make sense.
+      if (code === 32) {
+        effects.enter('space');
+        effects.consume(code);
+        effects.exit('space');
+        previous = code;
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter("lineEnding");
+        effects.consume(code);
+        effects.exit("lineEnding");
+        previous = code;
+        return between;
+      }
+
+      // Data.
+      effects.enter('mathTextData');
+      return data(code);
+    }
+
+    /**
+     * In data.
+     *
+     * ```markdown
+     * > | $a$
+     *      ^
+     * ```
+     *
+     * @type {State}
+     */
+    function data(code) {
+      if (code === null || code === 32 || code === 36 && codeOpen === 36 || code === 92 && codeOpen !== 36 || markdownLineEnding(code)) {
+        effects.exit('mathTextData');
+        return between(code);
+      }
+      effects.consume(code);
+      previous = code;
+      dataSeen = true;
+      return data;
+    }
+
+    /**
+     * In closing sequence.
+     *
+     * ```markdown
+     * > | `a`
+     *       ^
+     * ```
+     *
+     * @type {State}
+     */
+
+    function sequenceClose(code) {
+      // More.
+      if (code === 36) {
+        effects.consume(code);
+        size++;
+        return sequenceClose;
+      }
+
+      // Done!
+      if (size === sizeOpen && (sizeOpen !== 1 || validSingleDollarClose(previous, code))) {
+        effects.exit('mathTextSequence');
+        effects.exit(type);
+        return ok(code);
+      }
+
+      // More or less accents: mark as data.
+      token.type = 'mathTextData';
+      return data(code);
+    }
+
+    /**
+     * In a closing backslash sequence.
+     *
+     * ```markdown
+     * > | \(a\)
+     *        ^
+     * ```
+     *
+     * @type {State}
+     */
+    function sequenceCloseBackslash(code) {
+      effects.consume(code);
+      return sequenceCloseBackslashEnd;
+    }
+
+    /**
+     * After the backslash in a closing sequence.
+     *
+     * @type {State}
+     */
+    function sequenceCloseBackslashEnd(code) {
+      if (code === codeClose) {
+        if (!dataSeen) {
+          return nok(code);
+        }
+        effects.consume(code);
+        effects.exit('mathTextSequence');
+        effects.exit(type);
+        return ok;
+      }
+      token.type = 'mathTextData';
+      previous = 92;
+      return data(code);
+    }
+  }
+}
+
+/** @type {Resolver} */
+function resolveMathText(events) {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  /** @type {number} */
+  let index;
+  /** @type {number | undefined} */
+  let enter;
+
+  // If we start and end with an EOL or a space.
+  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === 'space')) {
+    index = headEnterIndex;
+
+    // And we have data.
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === 'mathTextData') {
+        // Then we have padding.
+        events[tailExitIndex][1].type = 'mathTextPadding';
+        events[headEnterIndex][1].type = 'mathTextPadding';
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break;
+      }
+    }
+  }
+
+  // Merge adjacent spaces and data.
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === undefined) {
+      if (index !== tailExitIndex && events[index][1].type !== "lineEnding") {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === "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 = undefined;
+    }
+  }
+  return events;
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
+function previousCode(code) {
+  // If there is a previous code, there will always be a tail.
+  return code !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+
+/**
+ * @param {number | null} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether `code` can follow an opening single dollar.
+ */
+function validSingleDollarOpen(code) {
+  return code !== null && !markdownLineEnding(code) && !markdownSpace(code);
+}
+
+/**
+ * @param {number | null | undefined} before
+ *   Code before the closing dollar.
+ * @param {number | null} after
+ *   Code after the closing dollar.
+ * @returns {boolean}
+ *   Whether a single dollar can close.
+ */
+function validSingleDollarClose(before, after) {
+  return before !== undefined && before !== null && !markdownLineEnding(before) && !markdownSpace(before) && !asciiDigit(after);
+}

package/lib/syntax.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Create an extension for `micromark` to enable math syntax.
+ *
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable math syntax.
+ */
+export function math(options?: Options | null | undefined): Extension;
+import type { Options } from '@ziloen/micromark-extension-math';
+import type { Extension } from 'micromark-util-types';

package/lib/syntax.js

@@ -0,0 +1,30 @@
+/**
+ * @import {Options} from '@ziloen/micromark-extension-math'
+ * @import {Extension} from 'micromark-util-types'
+ */
+
+import { mathFlow } from './math-flow.js';
+import { mathText } from './math-text.js';
+
+/**
+ * Create an extension for `micromark` to enable math syntax.
+ *
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable math syntax.
+ */
+export function math(options) {
+  const text = mathText(options);
+  return {
+    flow: {
+      [36]: mathFlow,
+      [92]: mathFlow
+    },
+    text: {
+      [36]: text,
+      [92]: text
+    }
+  };
+}

package/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@ziloen/micromark-extension-math",
+  "version": "3.1.0-patch.0",
+  "description": "micromark extension to support math (`$C_L$`)",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "micromark-extension",
+    "math",
+    "katex",
+    "latex",
+    "tex",
+    "markdown",
+    "unified"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/micromark/micromark-extension-math.git"
+  },
+  "bugs": "https://github.com/micromark/micromark-extension-math/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "development": "./dev/index.js",
+    "default": "./index.js"
+  },
+  "files": [
+    "dev/",
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/katex": "^0.16.0",
+    "devlop": "^1.0.0",
+    "katex": "^0.16.0",
+    "micromark-factory-space": "^2.0.0",
+    "micromark-util-character": "^2.0.0",
+    "micromark-util-symbol": "^2.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "c8": "^10.0.0",
+    "micromark": "^4.0.0",
+    "micromark-build": "^2.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-preset-wooorm": "^10.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.59.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build",
+    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "test-api-prod": "node --conditions production test/index.js",
+    "test-api-dev": "node --conditions development test/index.js",
+    "test-api": "npm run test-api-dev && npm run test-api-prod",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.d.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/array-type": [
+            "error",
+            {
+              "default": "generic"
+            }
+          ],
+          "@typescript-eslint/ban-types": [
+            "error",
+            {
+              "extendDefaults": true
+            }
+          ],
+          "@typescript-eslint/consistent-type-definitions": [
+            "error",
+            "interface"
+          ]
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "logical-assignment-operators": "off",
+      "unicorn/no-this-assignment": "off",
+      "unicorn/prefer-at": "off"
+    }
+  }
+}