@openclaw/feishu 2026.7.2-beta.5 → 2026.7.33

package/node_modules/micromark-core-commonmark/lib/code-text.js

@@ -1,225 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   Previous,
- *   Resolver,
- *   State,
- *   TokenizeContext,
- *   Tokenizer,
- *   Token
- * } from 'micromark-util-types'
- */
-
-import { markdownLineEnding } from 'micromark-util-character';
-/** @type {Construct} */
-export const codeText = {
-  name: 'codeText',
-  previous,
-  resolve: resolveCodeText,
-  tokenize: tokenizeCodeText
-};
-
-// To do: next major: don’t resolve, like `markdown-rs`.
-/** @type {Resolver} */
-function resolveCodeText(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 === "codeTextData") {
-        // Then we have padding.
-        events[headEnterIndex][1].type = "codeTextPadding";
-        events[tailExitIndex][1].type = "codeTextPadding";
-        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 = "codeTextData";
-      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}
- *   Context.
- * @type {Previous}
- */
-function previous(code) {
-  // If there is a previous code, there will always be a tail.
-  return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeCodeText(effects, ok, nok) {
-  const self = this;
-  let sizeOpen = 0;
-  /** @type {number} */
-  let size;
-  /** @type {Token} */
-  let token;
-  return start;
-
-  /**
-   * Start of code (text).
-   *
-   * ```markdown
-   * > | `a`
-   *     ^
-   * > | \`a`
-   *      ^
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    effects.enter("codeText");
-    effects.enter("codeTextSequence");
-    return sequenceOpen(code);
-  }
-
-  /**
-   * In opening sequence.
-   *
-   * ```markdown
-   * > | `a`
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function sequenceOpen(code) {
-    if (code === 96) {
-      effects.consume(code);
-      sizeOpen++;
-      return sequenceOpen;
-    }
-    effects.exit("codeTextSequence");
-    return between(code);
-  }
-
-  /**
-   * Between something and something else.
-   *
-   * ```markdown
-   * > | `a`
-   *      ^^
-   * ```
-   *
-   * @type {State}
-   */
-  function between(code) {
-    // EOF.
-    if (code === null) {
-      return nok(code);
-    }
-
-    // To do: next major: don’t do spaces in resolve, but when compiling,
-    // like `markdown-rs`.
-    // Tabs don’t work, and virtual spaces don’t make sense.
-    if (code === 32) {
-      effects.enter('space');
-      effects.consume(code);
-      effects.exit('space');
-      return between;
-    }
-
-    // Closing fence? Could also be data.
-    if (code === 96) {
-      token = effects.enter("codeTextSequence");
-      size = 0;
-      return sequenceClose(code);
-    }
-    if (markdownLineEnding(code)) {
-      effects.enter("lineEnding");
-      effects.consume(code);
-      effects.exit("lineEnding");
-      return between;
-    }
-
-    // Data.
-    effects.enter("codeTextData");
-    return data(code);
-  }
-
-  /**
-   * In data.
-   *
-   * ```markdown
-   * > | `a`
-   *      ^
-   * ```
-   *
-   * @type {State}
-   */
-  function data(code) {
-    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {
-      effects.exit("codeTextData");
-      return between(code);
-    }
-    effects.consume(code);
-    return data;
-  }
-
-  /**
-   * In closing sequence.
-   *
-   * ```markdown
-   * > | `a`
-   *       ^
-   * ```
-   *
-   * @type {State}
-   */
-  function sequenceClose(code) {
-    // More.
-    if (code === 96) {
-      effects.consume(code);
-      size++;
-      return sequenceClose;
-    }
-
-    // Done!
-    if (size === sizeOpen) {
-      effects.exit("codeTextSequence");
-      effects.exit("codeText");
-      return ok(code);
-    }
-
-    // More or less accents: mark as data.
-    token.type = "codeTextData";
-    return data(code);
-  }
-}

package/node_modules/micromark-core-commonmark/lib/content.d.ts

@@ -1,7 +0,0 @@
-/**
- * No name because it must not be turned off.
- * @type {Construct}
- */
-export const content: Construct;
-import type { Construct } from 'micromark-util-types';
-//# sourceMappingURL=content.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["content.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,sBAFU,SAAS,CAEwD;+BAbjE,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/content.js

@@ -1,163 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   Resolver,
- *   State,
- *   TokenizeContext,
- *   Tokenizer,
- *   Token
- * } from 'micromark-util-types'
- */
-
-import { factorySpace } from 'micromark-factory-space';
-import { markdownLineEnding } from 'micromark-util-character';
-import { subtokenize } from 'micromark-util-subtokenize';
-/**
- * No name because it must not be turned off.
- * @type {Construct}
- */
-export const content = {
-  resolve: resolveContent,
-  tokenize: tokenizeContent
-};
-
-/** @type {Construct} */
-const continuationConstruct = {
-  partial: true,
-  tokenize: tokenizeContinuation
-};
-
-/**
- * Content is transparent: it’s parsed right now. That way, definitions are also
- * parsed right now: before text in paragraphs (specifically, media) are parsed.
- *
- * @type {Resolver}
- */
-function resolveContent(events) {
-  subtokenize(events);
-  return events;
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeContent(effects, ok) {
-  /** @type {Token | undefined} */
-  let previous;
-  return chunkStart;
-
-  /**
-   * Before a content chunk.
-   *
-   * ```markdown
-   * > | abc
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function chunkStart(code) {
-    effects.enter("content");
-    previous = effects.enter("chunkContent", {
-      contentType: "content"
-    });
-    return chunkInside(code);
-  }
-
-  /**
-   * In a content chunk.
-   *
-   * ```markdown
-   * > | abc
-   *     ^^^
-   * ```
-   *
-   * @type {State}
-   */
-  function chunkInside(code) {
-    if (code === null) {
-      return contentEnd(code);
-    }
-
-    // To do: in `markdown-rs`, each line is parsed on its own, and everything
-    // is stitched together resolving.
-    if (markdownLineEnding(code)) {
-      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);
-    }
-
-    // Data.
-    effects.consume(code);
-    return chunkInside;
-  }
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function contentEnd(code) {
-    effects.exit("chunkContent");
-    effects.exit("content");
-    return ok(code);
-  }
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function contentContinue(code) {
-    effects.consume(code);
-    effects.exit("chunkContent");
-    previous.next = effects.enter("chunkContent", {
-      contentType: "content",
-      previous
-    });
-    previous = previous.next;
-    return chunkInside;
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeContinuation(effects, ok, nok) {
-  const self = this;
-  return startLookahead;
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function startLookahead(code) {
-    effects.exit("chunkContent");
-    effects.enter("lineEnding");
-    effects.consume(code);
-    effects.exit("lineEnding");
-    return factorySpace(effects, prefixed, "linePrefix");
-  }
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function prefixed(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return nok(code);
-    }
-
-    // Always populated by defaults.
-
-    const tail = self.events[self.events.length - 1];
-    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) {
-      return ok(code);
-    }
-    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);
-  }
-}

package/node_modules/micromark-core-commonmark/lib/definition.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["definition.js"],"names":[],"mappings":"AAuBA,wBAAwB;AACxB,yBADW,SAAS,CACwD;+BAlBlE,sBAAsB"}

package/node_modules/micromark-core-commonmark/lib/definition.js

@@ -1,254 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   State,
- *   TokenizeContext,
- *   Tokenizer
- * } from 'micromark-util-types'
- */
-
-import { factoryDestination } from 'micromark-factory-destination';
-import { factoryLabel } from 'micromark-factory-label';
-import { factorySpace } from 'micromark-factory-space';
-import { factoryTitle } from 'micromark-factory-title';
-import { factoryWhitespace } from 'micromark-factory-whitespace';
-import { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';
-import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
-/** @type {Construct} */
-export const definition = {
-  name: 'definition',
-  tokenize: tokenizeDefinition
-};
-
-/** @type {Construct} */
-const titleBefore = {
-  partial: true,
-  tokenize: tokenizeTitleBefore
-};
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeDefinition(effects, ok, nok) {
-  const self = this;
-  /** @type {string} */
-  let identifier;
-  return start;
-
-  /**
-   * At start of a definition.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    // Do not interrupt paragraphs (but do follow definitions).
-    // To do: do `interrupt` the way `markdown-rs` does.
-    // To do: parse whitespace the way `markdown-rs` does.
-    effects.enter("definition");
-    return before(code);
-  }
-
-  /**
-   * After optional whitespace, at `[`.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function before(code) {
-    // To do: parse whitespace the way `markdown-rs` does.
-
-    return factoryLabel.call(self, effects, labelAfter,
-    // Note: we don’t need to reset the way `markdown-rs` does.
-    nok, "definitionLabel", "definitionLabelMarker", "definitionLabelString")(code);
-  }
-
-  /**
-   * After label.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function labelAfter(code) {
-    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));
-    if (code === 58) {
-      effects.enter("definitionMarker");
-      effects.consume(code);
-      effects.exit("definitionMarker");
-      return markerAfter;
-    }
-    return nok(code);
-  }
-
-  /**
-   * After marker.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function markerAfter(code) {
-    // Note: whitespace is optional.
-    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);
-  }
-
-  /**
-   * Before destination.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *          ^
-   * ```
-   *
-   * @type {State}
-   */
-  function destinationBefore(code) {
-    return factoryDestination(effects, destinationAfter,
-    // Note: we don’t need to reset the way `markdown-rs` does.
-    nok, "definitionDestination", "definitionDestinationLiteral", "definitionDestinationLiteralMarker", "definitionDestinationRaw", "definitionDestinationString")(code);
-  }
-
-  /**
-   * After destination.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function destinationAfter(code) {
-    return effects.attempt(titleBefore, after, after)(code);
-  }
-
-  /**
-   * After definition.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, "whitespace")(code) : afterWhitespace(code);
-  }
-
-  /**
-   * After definition, after optional whitespace.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function afterWhitespace(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("definition");
-
-      // Note: we don’t care about uniqueness.
-      // It’s likely that that doesn’t happen very frequently.
-      // It is more likely that it wastes precious time.
-      self.parser.defined.push(identifier);
-
-      // To do: `markdown-rs` interrupt.
-      // // You’d be interrupting.
-      // tokenizer.interrupt = true
-      return ok(code);
-    }
-    return nok(code);
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeTitleBefore(effects, ok, nok) {
-  return titleBefore;
-
-  /**
-   * After destination, at whitespace.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleBefore(code) {
-    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);
-  }
-
-  /**
-   * At title.
-   *
-   * ```markdown
-   *   | [a]: b
-   * > | "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function beforeMarker(code) {
-    return factoryTitle(effects, titleAfter, nok, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(code);
-  }
-
-  /**
-   * After title.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleAfter(code) {
-    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, "whitespace")(code) : titleAfterOptionalWhitespace(code);
-  }
-
-  /**
-   * After title, after optional whitespace.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleAfterOptionalWhitespace(code) {
-    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
-  }
-}

package/node_modules/micromark-core-commonmark/lib/hard-break-escape.d.ts

@@ -1,4 +0,0 @@
-/** @type {Construct} */
-export const hardBreakEscape: Construct;
-import type { Construct } from 'micromark-util-types';
-//# sourceMappingURL=hard-break-escape.d.ts.map

package/node_modules/micromark-core-commonmark/lib/hard-break-escape.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hard-break-escape.d.ts","sourceRoot":"","sources":["hard-break-escape.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,8BADW,SAAS,CAInB;+BAXS,sBAAsB"}