@openclaw/feishu 2026.7.1-beta.6 → 2026.7.2-beta.1

package/node_modules/mdast-util-to-markdown/lib/util/safe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Make a string safe for embedding in markdown constructs.
+ *
+ * In markdown, almost all punctuation characters can, in certain cases,
+ * result in something.
+ * Whether they do is highly subjective to where they happen and in what
+ * they happen.
+ *
+ * To solve this, `mdast-util-to-markdown` tracks:
+ *
+ * * Characters before and after something;
+ * * What “constructs” we are in.
+ *
+ * This information is then used by this function to escape or encode
+ * special characters.
+ *
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {string | null | undefined} input
+ *   Raw value to make safe.
+ * @param {SafeConfig} config
+ *   Configuration.
+ * @returns {string}
+ *   Serialized markdown safe for embedding.
+ */
+export function safe(state: State, input: string | null | undefined, config: SafeConfig): string;
+import type { State } from 'mdast-util-to-markdown';
+import type { SafeConfig } from 'mdast-util-to-markdown';
+//# sourceMappingURL=safe.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/util/safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["safe.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,4BATW,KAAK,SAEL,MAAM,GAAG,IAAI,GAAG,SAAS,UAEzB,UAAU,GAER,MAAM,CAoGlB;2BAhImC,wBAAwB;gCAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/safe.js

@@ -0,0 +1,174 @@
+/**
+ * @import {SafeConfig, State} from 'mdast-util-to-markdown'
+ */
+
+import {encodeCharacterReference} from './encode-character-reference.js'
+import {patternInScope} from './pattern-in-scope.js'
+
+/**
+ * Make a string safe for embedding in markdown constructs.
+ *
+ * In markdown, almost all punctuation characters can, in certain cases,
+ * result in something.
+ * Whether they do is highly subjective to where they happen and in what
+ * they happen.
+ *
+ * To solve this, `mdast-util-to-markdown` tracks:
+ *
+ * * Characters before and after something;
+ * * What “constructs” we are in.
+ *
+ * This information is then used by this function to escape or encode
+ * special characters.
+ *
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {string | null | undefined} input
+ *   Raw value to make safe.
+ * @param {SafeConfig} config
+ *   Configuration.
+ * @returns {string}
+ *   Serialized markdown safe for embedding.
+ */
+export function safe(state, input, config) {
+  const value = (config.before || '') + (input || '') + (config.after || '')
+  /** @type {Array<number>} */
+  const positions = []
+  /** @type {Array<string>} */
+  const result = []
+  /** @type {Record<number, {before: boolean, after: boolean}>} */
+  const infos = {}
+  let index = -1
+
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index]
+
+    if (!patternInScope(state.stack, pattern)) {
+      continue
+    }
+
+    const expression = state.compilePattern(pattern)
+    /** @type {RegExpExecArray | null} */
+    let match
+
+    while ((match = expression.exec(value))) {
+      const before = 'before' in pattern || Boolean(pattern.atBreak)
+      const after = 'after' in pattern
+      const position = match.index + (before ? match[1].length : 0)
+
+      if (positions.includes(position)) {
+        if (infos[position].before && !before) {
+          infos[position].before = false
+        }
+
+        if (infos[position].after && !after) {
+          infos[position].after = false
+        }
+      } else {
+        positions.push(position)
+        infos[position] = {before, after}
+      }
+    }
+  }
+
+  positions.sort(numerical)
+
+  let start = config.before ? config.before.length : 0
+  const end = value.length - (config.after ? config.after.length : 0)
+  index = -1
+
+  while (++index < positions.length) {
+    const position = positions[index]
+
+    // Character before or after matched:
+    if (position < start || position >= end) {
+      continue
+    }
+
+    // If this character is supposed to be escaped because it has a condition on
+    // the next character, and the next character is definitly being escaped,
+    // then skip this escape.
+    if (
+      (position + 1 < end &&
+        positions[index + 1] === position + 1 &&
+        infos[position].after &&
+        !infos[position + 1].before &&
+        !infos[position + 1].after) ||
+      (positions[index - 1] === position - 1 &&
+        infos[position].before &&
+        !infos[position - 1].before &&
+        !infos[position - 1].after)
+    ) {
+      continue
+    }
+
+    if (start !== position) {
+      // If we have to use a character reference, an ampersand would be more
+      // correct, but as backslashes only care about punctuation, either will
+      // do the trick
+      result.push(escapeBackslashes(value.slice(start, position), '\\'))
+    }
+
+    start = position
+
+    if (
+      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
+      (!config.encode || !config.encode.includes(value.charAt(position)))
+    ) {
+      // Character escape.
+      result.push('\\')
+    } else {
+      // Character reference.
+      result.push(encodeCharacterReference(value.charCodeAt(position)))
+      start++
+    }
+  }
+
+  result.push(escapeBackslashes(value.slice(start, end), config.after))
+
+  return result.join('')
+}
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function numerical(a, b) {
+  return a - b
+}
+
+/**
+ * @param {string} value
+ * @param {string} after
+ * @returns {string}
+ */
+function escapeBackslashes(value, after) {
+  const expression = /\\(?=[!-/:-@[-`{-~])/g
+  /** @type {Array<number>} */
+  const positions = []
+  /** @type {Array<string>} */
+  const results = []
+  const whole = value + after
+  let index = -1
+  let start = 0
+  /** @type {RegExpExecArray | null} */
+  let match
+
+  while ((match = expression.exec(whole))) {
+    positions.push(match.index)
+  }
+
+  while (++index < positions.length) {
+    if (start !== positions[index]) {
+      results.push(value.slice(start, positions[index]))
+    }
+
+    results.push('\\')
+    start = positions[index]
+  }
+
+  results.push(value.slice(start))
+
+  return results.join('')
+}

package/node_modules/mdast-util-to-markdown/lib/util/track.d.ts

@@ -0,0 +1,2 @@
+export function track(info: import("../types.js").TrackFields): import("../types.js").Tracker;
+//# sourceMappingURL=track.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/util/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["track.js"],"names":[],"mappings":""}

package/node_modules/mdast-util-to-markdown/lib/util/track.js

@@ -0,0 +1,55 @@
+/**
+ * @import {CreateTracker, TrackCurrent, TrackMove, TrackShift} from '../types.js'
+ */
+
+/**
+ * Track positional info in the output.
+ *
+ * @type {CreateTracker}
+ */
+export function track(config) {
+  // Defaults are used to prevent crashes when older utilities somehow activate
+  // this code.
+  /* c8 ignore next 5 */
+  const options = config || {}
+  const now = options.now || {}
+  let lineShift = options.lineShift || 0
+  let line = now.line || 1
+  let column = now.column || 1
+
+  return {move, current, shift}
+
+  /**
+   * Get the current tracked info.
+   *
+   * @type {TrackCurrent}
+   */
+  function current() {
+    return {now: {line, column}, lineShift}
+  }
+
+  /**
+   * Define an increased line shift (the typical indent for lines).
+   *
+   * @type {TrackShift}
+   */
+  function shift(value) {
+    lineShift += value
+  }
+
+  /**
+   * Move past some generated markdown.
+   *
+   * @type {TrackMove}
+   */
+  function move(input) {
+    // eslint-disable-next-line unicorn/prefer-default-parameters
+    const value = input || ''
+    const chunks = value.split(/\r?\n|\r/g)
+    const tail = chunks[chunks.length - 1]
+    line += chunks.length - 1
+    column =
+      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift
+    return value
+  }
+}

package/node_modules/mdast-util-to-markdown/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 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/node_modules/mdast-util-to-markdown/package.json

@@ -0,0 +1,132 @@
+{
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "bugs": "https://github.com/syntax-tree/mdast-util-to-markdown/issues",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0",
+    "@types/unist": "^3.0.0",
+    "longest-streak": "^3.0.0",
+    "mdast-util-phrasing": "^4.0.0",
+    "mdast-util-to-string": "^4.0.0",
+    "micromark-util-classify-character": "^2.0.0",
+    "micromark-util-decode-string": "^2.0.0",
+    "unist-util-visit": "^5.0.0",
+    "zwitch": "^2.0.0"
+  },
+  "description": "mdast utility to serialize markdown",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "c8": "^10.0.0",
+    "mdast-util-from-markdown": "^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",
+    "unist-util-remove-position": "^5.0.0",
+    "xo": "^0.59.0"
+  },
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "keywords": [
+    "ast",
+    "compile",
+    "markdown",
+    "markup",
+    "mdast-util",
+    "mdast",
+    "serialize",
+    "stringify",
+    "syntax",
+    "tree",
+    "unist",
+    "utility",
+    "util"
+  ],
+  "license": "MIT",
+  "name": "mdast-util-to-markdown",
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "repository": "syntax-tree/mdast-util-to-markdown",
+  "version": "2.1.2",
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "test-api": "node --conditions development test/index.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "ignoreFiles": [
+      "lib/types.d.ts"
+    ],
+    "strict": true
+  },
+  "type": "module",
+  "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"
+          ]
+        }
+      },
+      {
+        "files": [
+          "test/**/*.js"
+        ],
+        "rules": {
+          "max-depth": "off",
+          "no-await-in-loop": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "complexity": "off",
+      "unicorn/prefer-at": "off",
+      "unicorn/prefer-code-point": "off"
+    }
+  }
+}