@openclaw/discord 2026.10.5-beta.1 → 2026.10.5-beta.2

package/node_modules/micromark-core-commonmark/lib/html-flow.js

@@ -12,6 +12,7 @@
 import { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';
 import { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';
 import { blankLine } from './blank-line.js';
+import { nonLazyContinuation } from './partial-non-lazy-continuation.js';
 
 /** @type {Construct} */
 export const htmlFlow = {
@@ -26,10 +27,6 @@ const blankLineBefore = {
   partial: true,
   tokenize: tokenizeBlankLineBefore
 };
-const nonLazyContinuationStart = {
-  partial: true,
-  tokenize: tokenizeNonLazyContinuationStart
-};
 
 /** @type {Resolver} */
 function resolveToHtmlFlow(events) {
@@ -608,7 +605,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
    * @type {State}
    */
   function continuationStart(code) {
-    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+    return effects.check(nonLazyContinuation, continuationStartNonLazy, continuationAfter)(code);
   }
 
   /**
@@ -802,52 +799,6 @@ function tokenizeHtmlFlow(effects, ok, nok) {
   }
 }
 
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeNonLazyContinuationStart(effects, ok, nok) {
-  const self = this;
-  return start;
-
-  /**
-   * At eol, before continuation.
-   *
-   * ```markdown
-   * > | * ```js
-   *            ^
-   *   | b
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    if (markdownLineEnding(code)) {
-      effects.enter("lineEnding");
-      effects.consume(code);
-      effects.exit("lineEnding");
-      return after;
-    }
-    return nok(code);
-  }
-
-  /**
-   * A continuation.
-   *
-   * ```markdown
-   *   | * ```js
-   * > | b
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
-  }
-}
-
 /**
  * @this {TokenizeContext}
  *   Context.

package/node_modules/micromark-core-commonmark/lib/label-end.js

@@ -66,8 +66,6 @@ function resolveAllLabelEnd(events) {
 function resolveToLabelEnd(events, context) {
   let index = events.length;
   let offset = 0;
-  /** @type {Token} */
-  let token;
   /** @type {number | undefined} */
   let open;
   /** @type {number | undefined} */
@@ -77,7 +75,7 @@ function resolveToLabelEnd(events, context) {
 
   // Find an opening.
   while (index--) {
-    token = events[index][1];
+    const token = events[index][1];
     if (open) {
       // If we see another link, or inactive link label, we’ve been here before.
       if (token.type === "link" || token.type === "labelLink" && token._inactive) {
@@ -160,18 +158,18 @@ function resolveToLabelEnd(events, context) {
  */
 function tokenizeLabelEnd(effects, ok, nok) {
   const self = this;
-  let index = self.events.length;
+  const labelStarts = self._labelStarts;
   /** @type {Token} */
   let labelStart;
   /** @type {boolean} */
   let defined;
-
-  // Find an opening.
-  while (index--) {
-    if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) {
-      labelStart = self.events[index][1];
-      break;
+  if (labelStarts) {
+    // Discard ones that failed to close,
+    // they’re not needed anymore.
+    while (labelStarts.length > 0 && labelStarts[labelStarts.length - 1]._balanced) {
+      labelStarts.pop();
     }
+    labelStart = labelStarts[labelStarts.length - 1];
   }
   return start;
 
@@ -290,6 +288,9 @@ function tokenizeLabelEnd(effects, ok, nok) {
    */
   function labelEndOk(code) {
     // Note: `markdown-rs` does a bunch of stuff here.
+    // This label start is now used up: discard it so it’s never found again.
+
+    labelStarts.pop();
     return ok(code);
   }
 

package/node_modules/micromark-core-commonmark/lib/label-start-image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"label-start-image.d.ts","sourceRoot":"","sources":["label-start-image.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,8BADW,SAAS,CAKnB;+BAZS,sBAAsB"}
+{"version":3,"file":"label-start-image.d.ts","sourceRoot":"","sources":["label-start-image.js"],"names":[],"mappings":"AAcA,wBAAwB;AACxB,8BADW,SAAS,CAKnB;+BAZS,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/label-start-image.js

@@ -2,6 +2,7 @@
  * @import {
  *   Construct,
  *   State,
+ *   Token,
  *   TokenizeContext,
  *   Tokenizer
  * } from 'micromark-util-types'
@@ -23,6 +24,8 @@ export const labelStartImage = {
  */
 function tokenizeLabelStartImage(effects, ok, nok) {
   const self = this;
+  /** @type {Token} */
+  let labelImage;
   return start;
 
   /**
@@ -58,7 +61,7 @@ function tokenizeLabelStartImage(effects, ok, nok) {
       effects.enter("labelMarker");
       effects.consume(code);
       effects.exit("labelMarker");
-      effects.exit("labelImage");
+      labelImage = effects.exit("labelImage");
       return after;
     }
     return nok(code);
@@ -96,7 +99,12 @@ function tokenizeLabelStartImage(effects, ok, nok) {
     // `micromark-extension-gfm-footnote`, but the `label-start-link`
     // behavior isn’t.
     // Hidden footnotes hook.
-    /* c8 ignore next 3 */
-    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);
+    /* c8 ignore next 6 */
+    if (code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs) {
+      return nok(code);
+    }
+    self._labelStarts = self._labelStarts || [];
+    self._labelStarts.push(labelImage);
+    return ok(code);
   }
 }

package/node_modules/micromark-core-commonmark/lib/label-start-link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"label-start-link.d.ts","sourceRoot":"","sources":["label-start-link.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,6BADW,SAAS,CAKnB;+BAZS,sBAAsB"}
+{"version":3,"file":"label-start-link.d.ts","sourceRoot":"","sources":["label-start-link.js"],"names":[],"mappings":"AAcA,wBAAwB;AACxB,6BADW,SAAS,CAKnB;+BAZS,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/label-start-link.js

@@ -2,6 +2,7 @@
  * @import {
  *   Construct,
  *   State,
+ *   Token,
  *   TokenizeContext,
  *   Tokenizer
  * } from 'micromark-util-types'
@@ -23,6 +24,8 @@ export const labelStartLink = {
  */
 function tokenizeLabelStartLink(effects, ok, nok) {
   const self = this;
+  /** @type {Token} */
+  let labelLink;
   return start;
 
   /**
@@ -40,7 +43,7 @@ function tokenizeLabelStartLink(effects, ok, nok) {
     effects.enter("labelMarker");
     effects.consume(code);
     effects.exit("labelMarker");
-    effects.exit("labelLink");
+    labelLink = effects.exit("labelLink");
     return after;
   }
 
@@ -49,7 +52,12 @@ function tokenizeLabelStartLink(effects, ok, nok) {
     // To do: this isn’t needed in `micromark-extension-gfm-footnote`,
     // remove.
     // Hidden footnotes hook.
-    /* c8 ignore next 3 */
-    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);
+    /* c8 ignore next 6 */
+    if (code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs) {
+      return nok(code);
+    }
+    self._labelStarts = self._labelStarts || [];
+    self._labelStarts.push(labelLink);
+    return ok(code);
   }
 }

package/node_modules/micromark-core-commonmark/lib/partial-non-lazy-continuation.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const nonLazyContinuation: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=partial-non-lazy-continuation.d.ts.map

package/node_modules/micromark-core-commonmark/lib/partial-non-lazy-continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-non-lazy-continuation.d.ts","sourceRoot":"","sources":["partial-non-lazy-continuation.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,kCADW,SAAS,CAInB;+BAXS,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/partial-non-lazy-continuation.js

@@ -0,0 +1,61 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import { markdownLineEnding } from 'micromark-util-character';
+/** @type {Construct} */
+export const nonLazyContinuation = {
+  partial: true,
+  tokenize: tokenizeNonLazyContinuation
+};
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+
+  /**
+   * At eol, before continuation.
+   *
+   * ```markdown
+   * > | * ```js
+   *            ^
+   *   | b
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    if (code === null) {
+      return nok(code);
+    }
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return after;
+  }
+
+  /**
+   * A continuation.
+   *
+   * ```markdown
+   *   | * ```js
+   * > | b
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}

package/node_modules/micromark-core-commonmark/lib/setext-underline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setext-underline.d.ts","sourceRoot":"","sources":["setext-underline.js"],"names":[],"mappings":"AAgBA,wBAAwB;AACxB,8BADW,SAAS,CAKnB;+BAbS,sBAAsB"}
+{"version":3,"file":"setext-underline.d.ts","sourceRoot":"","sources":["setext-underline.js"],"names":[],"mappings":"AAiBA,wBAAwB;AACxB,8BADW,SAAS,CAKnB;+BAdS,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/setext-underline.js

@@ -11,6 +11,7 @@
 
 import { factorySpace } from 'micromark-factory-space';
 import { markdownLineEnding, markdownSpace } from 'micromark-util-character';
+import { EditMap } from 'micromark-util-edit-map';
 /** @type {Construct} */
 export const setextUnderline = {
   name: 'setextUnderline',
@@ -20,7 +21,7 @@ export const setextUnderline = {
 
 /** @type {Resolver} */
 function resolveToSetextUnderline(events, context) {
-  // To do: resolve like `markdown-rs`.
+  const editMap = new EditMap();
   let index = events.length;
   /** @type {number | undefined} */
   let content;
@@ -45,7 +46,7 @@ function resolveToSetextUnderline(events, context) {
     else {
       if (events[index][1].type === "content") {
         // Remove the content end (if needed we’ll add it later)
-        events.splice(index, 1);
+        editMap.add(index, 1, []);
       }
       if (!definition && events[index][1].type === "definition") {
         definition = index;
@@ -68,8 +69,8 @@ function resolveToSetextUnderline(events, context) {
   // If we have definitions in the content, we’ll keep on having content,
   // but we need move it.
   if (definition) {
-    events.splice(text, 0, ['enter', heading, context]);
-    events.splice(definition + 1, 0, ['exit', events[content][1], context]);
+    editMap.add(text, 0, [['enter', heading, context]]);
+    editMap.add(definition + 1, 0, [['exit', events[content][1], context]]);
     events[content][1].end = {
       ...events[definition][1].end
     };
@@ -78,7 +79,8 @@ function resolveToSetextUnderline(events, context) {
   }
 
   // Add the heading exit at the end.
-  events.push(['exit', heading, context]);
+  editMap.add(events.length, 0, [['exit', heading, context]]);
+  editMap.consume(events);
   return events;
 }
 

package/node_modules/micromark-core-commonmark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micromark-core-commonmark",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "The CommonMark markdown constructs",
   "license": "MIT",
   "keywords": [
@@ -42,33 +42,21 @@
     "devlop": "^1.0.0",
     "micromark-factory-destination": "^2.0.0",
     "micromark-factory-label": "^2.0.0",
-    "micromark-factory-space": "^2.0.0",
+    "micromark-factory-space": "^2.1.0",
     "micromark-factory-title": "^2.0.0",
     "micromark-factory-whitespace": "^2.0.0",
     "micromark-util-character": "^2.0.0",
     "micromark-util-chunked": "^2.0.0",
     "micromark-util-classify-character": "^2.0.0",
+    "micromark-util-edit-map": "^1.0.0",
     "micromark-util-html-tag-name": "^2.0.0",
     "micromark-util-normalize-identifier": "^2.0.0",
     "micromark-util-resolve-all": "^2.0.0",
     "micromark-util-subtokenize": "^2.0.0",
     "micromark-util-symbol": "^2.0.0",
-    "micromark-util-types": "^2.0.0"
+    "micromark-util-types": "^2.0.3"
   },
   "scripts": {
     "build": "micromark-build"
-  },
-  "xo": {
-    "envs": [
-      "shared-node-browser"
-    ],
-    "prettier": true,
-    "rules": {
-      "logical-assignment-operators": "off",
-      "max-depth": "off",
-      "unicorn/no-this-assignment": "off",
-      "unicorn/prefer-at": "off",
-      "unicorn/prefer-code-point": "off"
-    }
   }
 }

package/node_modules/micromark-factory-space/dev/index.d.ts

@@ -24,13 +24,36 @@
  * @param {State} ok
  *   State switched to when successful.
  * @param {TokenType} type
- *   Type (`' \t'`).
+ *   Type of the whole whitespace.
  * @param {number | undefined} [max=Infinity]
  *   Max (exclusive).
  * @returns {State}
  *   Start state.
  */
 export function factorySpace(effects: Effects, ok: State, type: TokenType, max?: number | undefined): State;
+/**
+ * Parse spaces and tabs, with a required minimum and maximum, matching
+ * `markdown-rs`’s `space_or_tab_min_max`.
+ *
+ * Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+ * `min` spaces or tabs are found.
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {State} nok
+ *   State switched to when unsuccessful.
+ * @param {TokenType} type
+ *   Type of the whole whitespace.
+ * @param {number} min
+ *   Minimum allowed characters (inclusive).
+ * @param {number} max
+ *   Maximum allowed characters (inclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpaceMinMax(effects: Effects, ok: State, nok: State, type: TokenType, min: number, max: number): State;
 import type { Effects } from 'micromark-util-types';
 import type { State } from 'micromark-util-types';
 import type { TokenType } from 'micromark-util-types';

package/node_modules/micromark-factory-space/dev/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sCAXW,OAAO,MAEP,KAAK,QAEL,SAAS,QAET,MAAM,GAAG,SAAS,GAEhB,KAAK,CA6BjB;6BAjE2C,sBAAsB;2BAAtB,sBAAsB;+BAAtB,sBAAsB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sCAXW,OAAO,MAEP,KAAK,QAEL,SAAS,QAET,MAAM,GAAG,SAAS,GAEhB,KAAK,CA6BjB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAfW,OAAO,MAEP,KAAK,OAEL,KAAK,QAEL,SAAS,OAET,MAAM,OAEN,MAAM,GAEJ,KAAK,CAkCjB;6BAxH2C,sBAAsB;2BAAtB,sBAAsB;+BAAtB,sBAAsB"}

package/node_modules/micromark-factory-space/dev/index.js

@@ -4,7 +4,7 @@
 
 import {markdownSpace} from 'micromark-util-character'
 
-// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+// To do: implement `spaceOrTabWithOptions` (`connect`, `content`).
 
 /**
  * Parse spaces and tabs.
@@ -32,14 +32,14 @@ import {markdownSpace} from 'micromark-util-character'
  * @param {State} ok
  *   State switched to when successful.
  * @param {TokenType} type
- *   Type (`' \t'`).
+ *   Type of the whole whitespace.
  * @param {number | undefined} [max=Infinity]
  *   Max (exclusive).
  * @returns {State}
  *   Start state.
  */
 export function factorySpace(effects, ok, type, max) {
-  const limit = max ? max - 1 : Number.POSITIVE_INFINITY
+  const limit = max ? max - 1 : Infinity
   let size = 0
 
   return start
@@ -65,3 +65,58 @@ export function factorySpace(effects, ok, type, max) {
     return ok(code)
   }
 }
+
+/**
+ * Parse spaces and tabs, with a required minimum and maximum, matching
+ * `markdown-rs`’s `space_or_tab_min_max`.
+ *
+ * Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+ * `min` spaces or tabs are found.
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {State} nok
+ *   State switched to when unsuccessful.
+ * @param {TokenType} type
+ *   Type of the whole whitespace.
+ * @param {number} min
+ *   Minimum allowed characters (inclusive).
+ * @param {number} max
+ *   Maximum allowed characters (inclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpaceMinMax(effects, ok, nok, type, min, max) {
+  let size = 0
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    if (max > 0 && markdownSpace(code)) {
+      effects.enter(type)
+      return prefix(code)
+    }
+
+    return after(code)
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size < max) {
+      effects.consume(code)
+      size++
+      return prefix
+    }
+
+    effects.exit(type)
+    return after(code)
+  }
+
+  /** @type {State} */
+  function after(code) {
+    return size >= min ? ok(code) : nok(code)
+  }
+}

package/node_modules/micromark-factory-space/index.d.ts

@@ -24,13 +24,36 @@
  * @param {State} ok
  *   State switched to when successful.
  * @param {TokenType} type
- *   Type (`' \t'`).
+ *   Type of the whole whitespace.
  * @param {number | undefined} [max=Infinity]
  *   Max (exclusive).
  * @returns {State}
  *   Start state.
  */
 export function factorySpace(effects: Effects, ok: State, type: TokenType, max?: number | undefined): State;
+/**
+ * Parse spaces and tabs, with a required minimum and maximum, matching
+ * `markdown-rs`’s `space_or_tab_min_max`.
+ *
+ * Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+ * `min` spaces or tabs are found.
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {State} nok
+ *   State switched to when unsuccessful.
+ * @param {TokenType} type
+ *   Type of the whole whitespace.
+ * @param {number} min
+ *   Minimum allowed characters (inclusive).
+ * @param {number} max
+ *   Maximum allowed characters (inclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpaceMinMax(effects: Effects, ok: State, nok: State, type: TokenType, min: number, max: number): State;
 import type { Effects } from 'micromark-util-types';
 import type { State } from 'micromark-util-types';
 import type { TokenType } from 'micromark-util-types';

package/node_modules/micromark-factory-space/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sCAXW,OAAO,MAEP,KAAK,QAEL,SAAS,QAET,MAAM,GAAG,SAAS,GAEhB,KAAK,CA6BjB;6BAjE2C,sBAAsB;2BAAtB,sBAAsB;+BAAtB,sBAAsB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sCAXW,OAAO,MAEP,KAAK,QAEL,SAAS,QAET,MAAM,GAAG,SAAS,GAEhB,KAAK,CA6BjB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAfW,OAAO,MAEP,KAAK,OAEL,KAAK,QAEL,SAAS,OAET,MAAM,OAEN,MAAM,GAEJ,KAAK,CAkCjB;6BAxH2C,sBAAsB;2BAAtB,sBAAsB;+BAAtB,sBAAsB"}

package/node_modules/micromark-factory-space/index.js

@@ -4,7 +4,7 @@
 
 import { markdownSpace } from 'micromark-util-character';
 
-// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+// To do: implement `spaceOrTabWithOptions` (`connect`, `content`).
 
 /**
  * Parse spaces and tabs.
@@ -32,14 +32,14 @@ import { markdownSpace } from 'micromark-util-character';
  * @param {State} ok
  *   State switched to when successful.
  * @param {TokenType} type
- *   Type (`' \t'`).
+ *   Type of the whole whitespace.
  * @param {number | undefined} [max=Infinity]
  *   Max (exclusive).
  * @returns {State}
  *   Start state.
  */
 export function factorySpace(effects, ok, type, max) {
-  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  const limit = max ? max - 1 : Infinity;
   let size = 0;
   return start;
 
@@ -61,4 +61,56 @@ export function factorySpace(effects, ok, type, max) {
     effects.exit(type);
     return ok(code);
   }
+}
+
+/**
+ * Parse spaces and tabs, with a required minimum and maximum, matching
+ * `markdown-rs`’s `space_or_tab_min_max`.
+ *
+ * Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+ * `min` spaces or tabs are found.
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {State} nok
+ *   State switched to when unsuccessful.
+ * @param {TokenType} type
+ *   Type of the whole whitespace.
+ * @param {number} min
+ *   Minimum allowed characters (inclusive).
+ * @param {number} max
+ *   Maximum allowed characters (inclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpaceMinMax(effects, ok, nok, type, min, max) {
+  let size = 0;
+  return start;
+
+  /** @type {State} */
+  function start(code) {
+    if (max > 0 && markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return after(code);
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size < max) {
+      effects.consume(code);
+      size++;
+      return prefix;
+    }
+    effects.exit(type);
+    return after(code);
+  }
+
+  /** @type {State} */
+  function after(code) {
+    return size >= min ? ok(code) : nok(code);
+  }
 }

package/node_modules/micromark-factory-space/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micromark-factory-space",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "micromark factory to parse markdown space (found in lots of places)",
   "license": "MIT",
   "keywords": [
@@ -42,14 +42,5 @@
   },
   "scripts": {
     "build": "micromark-build"
-  },
-  "xo": {
-    "envs": [
-      "shared-node-browser"
-    ],
-    "prettier": true,
-    "rules": {
-      "unicorn/prefer-code-point": "off"
-    }
   }
 }