@openclaw/feishu 2026.7.2-beta.5 → 2026.7.2-beta.7

package/node_modules/mdast-util-gfm-table/node_modules/dequal/dist/index.mjs

@@ -0,0 +1,84 @@
+var has = Object.prototype.hasOwnProperty;
+
+function find(iter, tar, key) {
+	for (key of iter.keys()) {
+		if (dequal(key, tar)) return key;
+	}
+}
+
+export function dequal(foo, bar) {
+	var ctor, len, tmp;
+	if (foo === bar) return true;
+
+	if (foo && bar && (ctor=foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+
+		if (ctor === Array) {
+			if ((len=foo.length) === bar.length) {
+				while (len-- && dequal(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
+
+		if (ctor === Set) {
+			if (foo.size !== bar.size) {
+				return false;
+			}
+			for (len of foo) {
+				tmp = len;
+				if (tmp && typeof tmp === 'object') {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (!bar.has(tmp)) return false;
+			}
+			return true;
+		}
+
+		if (ctor === Map) {
+			if (foo.size !== bar.size) {
+				return false;
+			}
+			for (len of foo) {
+				tmp = len[0];
+				if (tmp && typeof tmp === 'object') {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (!dequal(len[1], bar.get(tmp))) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		if (ctor === ArrayBuffer) {
+			foo = new Uint8Array(foo);
+			bar = new Uint8Array(bar);
+		} else if (ctor === DataView) {
+			if ((len=foo.byteLength) === bar.byteLength) {
+				while (len-- && foo.getInt8(len) === bar.getInt8(len));
+			}
+			return len === -1;
+		}
+
+		if (ArrayBuffer.isView(foo)) {
+			if ((len=foo.byteLength) === bar.byteLength) {
+				while (len-- && foo[len] === bar[len]);
+			}
+			return len === -1;
+		}
+
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+
+	return foo !== foo && bar !== bar;
+}

package/node_modules/mdast-util-gfm-table/node_modules/dequal/index.d.ts

@@ -0,0 +1 @@
+export function dequal(foo: any, bar: any): boolean;

package/node_modules/mdast-util-gfm-table/node_modules/dequal/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.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-gfm-table/node_modules/dequal/lite/index.d.ts

@@ -0,0 +1 @@
+export function dequal(foo: any, bar: any): boolean;

package/node_modules/mdast-util-gfm-table/node_modules/dequal/lite/index.js

@@ -0,0 +1,31 @@
+var has = Object.prototype.hasOwnProperty;
+
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+
+	if (foo && bar && (ctor=foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+
+		if (ctor === Array) {
+			if ((len=foo.length) === bar.length) {
+				while (len-- && dequal(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
+
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+
+	return foo !== foo && bar !== bar;
+}
+
+exports.dequal = dequal;

package/node_modules/mdast-util-gfm-table/node_modules/dequal/lite/index.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t(e.dequal={})}(this,(function(e){var t=Object.prototype.hasOwnProperty;e.dequal=function e(r,n){var o,i;if(r===n)return!0;if(r&&n&&(o=r.constructor)===n.constructor){if(o===Date)return r.getTime()===n.getTime();if(o===RegExp)return r.toString()===n.toString();if(o===Array){if((i=r.length)===n.length)for(;i--&&e(r[i],n[i]););return-1===i}if(!o||"object"==typeof r){for(o in i=0,r){if(t.call(r,o)&&++i&&!t.call(n,o))return!1;if(!(o in n)||!e(r[o],n[o]))return!1}return Object.keys(n).length===i}}return r!=r&&n!=n}}));

package/node_modules/mdast-util-gfm-table/node_modules/dequal/lite/index.mjs

@@ -0,0 +1,29 @@
+var has = Object.prototype.hasOwnProperty;
+
+export function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+
+	if (foo && bar && (ctor=foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+
+		if (ctor === Array) {
+			if ((len=foo.length) === bar.length) {
+				while (len-- && dequal(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
+
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+
+	return foo !== foo && bar !== bar;
+}

package/node_modules/mdast-util-gfm-table/node_modules/dequal/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "dequal",
+  "version": "2.0.3",
+  "repository": "lukeed/dequal",
+  "description": "A tiny (304B to 489B) utility for check for deep equality",
+  "unpkg": "dist/index.min.js",
+  "module": "dist/index.mjs",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "license": "MIT",
+  "author": {
+    "name": "Luke Edwards",
+    "email": "luke.edwards05@gmail.com",
+    "url": "https://lukeed.com"
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "build": "bundt",
+    "pretest": "npm run build",
+    "postbuild": "echo \"lite\" | xargs -n1 cp -v index.d.ts",
+    "test": "uvu -r esm test"
+  },
+  "files": [
+    "*.d.ts",
+    "dist",
+    "lite"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./lite": {
+      "types": "./index.d.ts",
+      "import": "./lite/index.mjs",
+      "require": "./lite/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "modes": {
+    "lite": "src/lite.js",
+    "default": "src/index.js"
+  },
+  "keywords": [
+    "deep",
+    "deep-equal",
+    "equality"
+  ],
+  "devDependencies": {
+    "bundt": "1.0.2",
+    "esm": "3.2.25",
+    "uvu": "0.3.2"
+  }
+}

package/node_modules/mdast-util-gfm-table/node_modules/dequal/readme.md

@@ -0,0 +1,112 @@
+# dequal [![CI](https://github.com/lukeed/dequal/workflows/CI/badge.svg)](https://github.com/lukeed/dequal/actions)
+
+> A tiny (304B to 489B) utility to check for deep equality
+
+This module supports comparison of all types, including `Function`, `RegExp`, `Date`, `Set`, `Map`, `TypedArray`s, `DataView`, `null`, `undefined`, and `NaN` values. Complex values (eg, Objects, Arrays, Sets, Maps, etc) are traversed recursively.
+
+> **Important:**
+> * key order **within Objects** does not matter
+> * value order **within Arrays** _does_ matter
+> * values **within Sets and Maps** use value equality
+> * keys **within Maps** use value equality
+
+
+## Install
+
+```
+$ npm install --save dequal
+```
+
+## Modes
+
+There are two "versions" of `dequal` available:
+
+#### `dequal`
+> **Size (gzip):** 489 bytes<br>
+> **Availability:** [CommonJS](https://unpkg.com/dequal/dist/index.js), [ES Module](https://unpkg.com/dequal/dist/index.mjs), [UMD](https://unpkg.com/dequal/dist/index.min.js)
+
+#### `dequal/lite`
+> **Size (gzip):** 304 bytes<br>
+> **Availability:** [CommonJS](https://unpkg.com/dequal/lite/index.js), [ES Module](https://unpkg.com/dequal/lite/index.mjs)
+
+|  | IE9+ | Number | String | Date | RegExp | Object | Array | Class | Set | Map | ArrayBuffer | [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#TypedArray_objects) | [DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) |
+|-|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+| `dequal` | :x: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+| `dequal/lite` | :+1: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :x: | :x: | :x: | :x: | :x: |
+
+> <sup>**Note:** Table scrolls horizontally!</sup>
+
+## Usage
+
+```js
+import { dequal } from 'dequal';
+
+dequal(1, 1); //=> true
+dequal({}, {}); //=> true
+dequal('foo', 'foo'); //=> true
+dequal([1, 2, 3], [1, 2, 3]); //=> true
+dequal(dequal, dequal); //=> true
+dequal(/foo/, /foo/); //=> true
+dequal(null, null); //=> true
+dequal(NaN, NaN); //=> true
+dequal([], []); //=> true
+dequal(
+  [{ a:1 }, [{ b:{ c:[1] } }]],
+  [{ a:1 }, [{ b:{ c:[1] } }]]
+); //=> true
+
+dequal(1, '1'); //=> false
+dequal(null, undefined); //=> false
+dequal({ a:1, b:[2,3] }, { a:1, b:[2,5] }); //=> false
+dequal(/foo/i, /bar/g); //=> false
+```
+
+## API
+
+### dequal(foo, bar)
+Returns: `Boolean`
+
+Both `foo` and `bar` can be of any type.<br>
+A `Boolean` is returned indicating if the two were deeply equal.
+
+
+## Benchmarks
+
+> Running Node v10.13.0
+
+The benchmarks can be found in the [`/bench`](/bench) directory. They are separated into two categories:
+
+* `basic` – compares an object comprised of `String`, `Number`, `Date`, `Array`, and `Object` values.
+* `complex` – like `basic`, but adds `RegExp`, `Map`, `Set`, and `Uint8Array` values.
+
+> **Note:** Only candidates that pass validation step(s) are listed. <br>For example, `fast-deep-equal/es6` handles `Set` and `Map` values, but uses _referential equality_ while those listed use _value equality_.
+
+```
+Load times:
+  assert             0.109ms
+  util               0.006ms
+  fast-deep-equal    0.479ms
+  lodash/isequal    22.826ms
+  nano-equal         0.417ms
+  dequal             0.396ms
+  dequal/lite        0.264ms
+
+Benchmark :: basic
+  assert.deepStrictEqual  x    325,262 ops/sec ±0.57% (94 runs sampled)
+  util.isDeepStrictEqual  x    318,812 ops/sec ±0.87% (94 runs sampled)
+  fast-deep-equal         x  1,332,393 ops/sec ±0.36% (93 runs sampled)
+  lodash.isEqual          x    269,129 ops/sec ±0.59% (95 runs sampled)
+  nano-equal              x  1,122,053 ops/sec ±0.36% (96 runs sampled)
+  dequal/lite             x  1,700,972 ops/sec ±0.31% (94 runs sampled)
+  dequal                  x  1,698,972 ops/sec ±0.63% (97 runs sampled)
+
+Benchmark :: complex
+  assert.deepStrictEqual  x    124,518 ops/sec ±0.64% (96 runs sampled)
+  util.isDeepStrictEqual  x    125,113 ops/sec ±0.24% (96 runs sampled)
+  lodash.isEqual          x     58,677 ops/sec ±0.49% (96 runs sampled)
+  dequal                  x    345,386 ops/sec ±0.27% (96 runs sampled)
+```
+
+## License
+
+MIT © [Luke Edwards](https://lukeed.com)

package/node_modules/mdast-util-gfm-table/node_modules/devlop/lib/default.js

@@ -0,0 +1,9 @@
+export function deprecate(fn) {
+  return fn
+}
+
+export function equal() {}
+
+export function ok() {}
+
+export function unreachable() {}

package/node_modules/mdast-util-gfm-table/node_modules/devlop/lib/development.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Wrap a function or class to show a deprecation message when first called.
+ *
+ * > 👉 **Important**: only shows a message when the `development` condition is
+ * > used, does nothing in production.
+ *
+ * When the resulting wrapped `fn` is called, emits a warning once to
+ * `console.error` (`stderr`).
+ * If a code is given, one warning message will be emitted in total per code.
+ *
+ * @template {Function} T
+ *   Function or class kind.
+ * @param {T} fn
+ *   Function or class.
+ * @param {string} message
+ *   Message explaining deprecation.
+ * @param {string | null | undefined} [code]
+ *   Deprecation identifier (optional); deprecation messages will be generated
+ *   only once per code.
+ * @returns {T}
+ *   Wrapped `fn`.
+ */
+export function deprecate<T extends Function>(
+  fn: T,
+  message: string,
+  code?: string | null | undefined
+): T
+/**
+ * Assert deep strict equivalence.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @template {unknown} T
+ *   Expected kind.
+ * @param {unknown} actual
+ *   Value.
+ * @param {T} expected
+ *   Baseline.
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Expected values to be deeply equal'`).
+ * @returns {asserts actual is T}
+ *   Nothing; throws when `actual` is not deep strict equal to `expected`.
+ * @throws {AssertionError}
+ *   Throws when `actual` is not deep strict equal to `expected`.
+ */
+export function equal<T extends unknown>(
+  actual: unknown,
+  expected: T,
+  message?: Error | string | null | undefined
+): asserts actual is T
+/**
+ * Assert if `value` is truthy.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @param {unknown} value
+ *   Value to assert.
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Expected value to be truthy'`).
+ * @returns {asserts value}
+ *   Nothing; throws when `value` is falsey.
+ * @throws {AssertionError}
+ *   Throws when `value` is falsey.
+ */
+export function ok(
+  value: unknown,
+  message?: Error | string | null | undefined
+): asserts value
+/**
+ * Assert that a code path never happens.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Unreachable'`).
+ * @returns {never}
+ *   Nothing; always throws.
+ * @throws {AssertionError}
+ *   Throws when `value` is falsey.
+ */
+export function unreachable(message?: Error | string | null | undefined): never

package/node_modules/mdast-util-gfm-table/node_modules/devlop/lib/development.js

@@ -0,0 +1,238 @@
+import {dequal} from 'dequal'
+
+/**
+ * @type {Set<string>}
+ */
+const codesWarned = new Set()
+
+class AssertionError extends Error {
+  name = /** @type {const} */ ('Assertion')
+  code = /** @type {const} */ ('ERR_ASSERTION')
+
+  /**
+   * Create an assertion error.
+   *
+   * @param {string} message
+   *   Message explaining error.
+   * @param {unknown} actual
+   *   Value.
+   * @param {unknown} expected
+   *   Baseline.
+   * @param {string} operator
+   *   Name of equality operation.
+   * @param {boolean} generated
+   *   Whether `message` is a custom message or not
+   * @returns
+   *   Instance.
+   */
+  // eslint-disable-next-line max-params
+  constructor(message, actual, expected, operator, generated) {
+    super(message)
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor)
+    }
+
+    /**
+     * @type {unknown}
+     */
+    this.actual = actual
+
+    /**
+     * @type {unknown}
+     */
+    this.expected = expected
+
+    /**
+     * @type {boolean}
+     */
+    this.generated = generated
+
+    /**
+     * @type {string}
+     */
+    this.operator = operator
+  }
+}
+
+class DeprecationError extends Error {
+  name = /** @type {const} */ ('DeprecationWarning')
+
+  /**
+   * Create a deprecation message.
+   *
+   * @param {string} message
+   *   Message explaining deprecation.
+   * @param {string | undefined} code
+   *   Deprecation identifier; deprecation messages will be generated only once per code.
+   * @returns
+   *   Instance.
+   */
+  constructor(message, code) {
+    super(message)
+
+    /**
+     * @type {string | undefined}
+     */
+    this.code = code
+  }
+}
+
+/**
+ * Wrap a function or class to show a deprecation message when first called.
+ *
+ * > 👉 **Important**: only shows a message when the `development` condition is
+ * > used, does nothing in production.
+ *
+ * When the resulting wrapped `fn` is called, emits a warning once to
+ * `console.error` (`stderr`).
+ * If a code is given, one warning message will be emitted in total per code.
+ *
+ * @template {Function} T
+ *   Function or class kind.
+ * @param {T} fn
+ *   Function or class.
+ * @param {string} message
+ *   Message explaining deprecation.
+ * @param {string | null | undefined} [code]
+ *   Deprecation identifier (optional); deprecation messages will be generated
+ *   only once per code.
+ * @returns {T}
+ *   Wrapped `fn`.
+ */
+export function deprecate(fn, message, code) {
+  let warned = false
+
+  // The wrapper will keep the same prototype as fn to maintain prototype chain
+  Object.setPrototypeOf(deprecated, fn)
+
+  // @ts-expect-error: it’s perfect, typescript…
+  return deprecated
+
+  /**
+   * @this {unknown}
+   * @param  {...Array<unknown>} args
+   * @returns {unknown}
+   */
+  function deprecated(...args) {
+    if (!warned) {
+      warned = true
+
+      if (typeof code === 'string' && codesWarned.has(code)) {
+        // Empty.
+      } else {
+        console.error(new DeprecationError(message, code || undefined))
+
+        if (typeof code === 'string') codesWarned.add(code)
+      }
+    }
+
+    return new.target
+      ? Reflect.construct(fn, args, new.target)
+      : Reflect.apply(fn, this, args)
+  }
+}
+
+/**
+ * Assert deep strict equivalence.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @template {unknown} T
+ *   Expected kind.
+ * @param {unknown} actual
+ *   Value.
+ * @param {T} expected
+ *   Baseline.
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Expected values to be deeply equal'`).
+ * @returns {asserts actual is T}
+ *   Nothing; throws when `actual` is not deep strict equal to `expected`.
+ * @throws {AssertionError}
+ *   Throws when `actual` is not deep strict equal to `expected`.
+ */
+export function equal(actual, expected, message) {
+  assert(
+    dequal(actual, expected),
+    actual,
+    expected,
+    'equal',
+    'Expected values to be deeply equal',
+    message
+  )
+}
+
+/**
+ * Assert if `value` is truthy.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @param {unknown} value
+ *   Value to assert.
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Expected value to be truthy'`).
+ * @returns {asserts value}
+ *   Nothing; throws when `value` is falsey.
+ * @throws {AssertionError}
+ *   Throws when `value` is falsey.
+ */
+export function ok(value, message) {
+  assert(
+    Boolean(value),
+    false,
+    true,
+    'ok',
+    'Expected value to be truthy',
+    message
+  )
+}
+
+/**
+ * Assert that a code path never happens.
+ *
+ * > 👉 **Important**: only asserts when the `development` condition is used,
+ * > does nothing in production.
+ *
+ * @param {Error | string | null | undefined} [message]
+ *   Message for assertion error (default: `'Unreachable'`).
+ * @returns {never}
+ *   Nothing; always throws.
+ * @throws {AssertionError}
+ *   Throws when `value` is falsey.
+ */
+export function unreachable(message) {
+  assert(false, false, true, 'ok', 'Unreachable', message)
+}
+
+/**
+ * @param {boolean} bool
+ *   Whether to skip this operation.
+ * @param {unknown} actual
+ *   Actual value.
+ * @param {unknown} expected
+ *   Expected value.
+ * @param {string} operator
+ *   Operator.
+ * @param {string} defaultMessage
+ *   Default message for operation.
+ * @param {Error | string | null | undefined} userMessage
+ *   User-provided message.
+ * @returns {asserts bool}
+ *   Nothing; throws when falsey.
+ */
+// eslint-disable-next-line max-params
+function assert(bool, actual, expected, operator, defaultMessage, userMessage) {
+  if (!bool) {
+    throw userMessage instanceof Error
+      ? userMessage
+      : new AssertionError(
+          userMessage || defaultMessage,
+          actual,
+          expected,
+          operator,
+          !userMessage
+        )
+  }
+}