@openclaw/slack 2026.7.2-beta.3 → 2026.7.2-beta.5

package/node_modules/@types/retry/index.d.ts

@@ -1,3 +1,10 @@
+// Type definitions for retry 0.12
+// Project: https://github.com/tim-kos/node-retry
+// Definitions by: Stan Goldmann <https://github.com/krenor>
+//                 BendingBender <https://github.com/BendingBender>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
 export interface RetryOperation {
     /**
      * Returns an array of all errors that have been passed to `retryOperation.retry()` so far.
@@ -52,7 +59,7 @@ export interface AttemptTimeoutOptions {
     /**
      * A timeout in milliseconds.
      */
-    timeout?: number | undefined;
+    timeout?: number;
     /**
      * Callback to execute when the operation takes longer than the timeout.
      */
@@ -69,27 +76,26 @@ export interface AttemptTimeoutOptions {
  * @param [options.randomize=false] Randomizes the timeouts by multiplying a factor between 1-2.
  * @param [options.forever=false] Wether to retry forever.
  * @param [options.unref=false] Wether to unref the setTimeout's.
+ *
  */
 export function operation(options?: OperationOptions): RetryOperation;
 
-export type OperationOptions = WrapOptions | number[];
-
-export interface WrapOptions extends TimeoutsOptions {
+export interface OperationOptions extends TimeoutsOptions {
     /**
      * Whether to retry forever.
      * @default false
      */
-    forever?: boolean | undefined;
+    forever?: boolean;
     /**
      * Whether to [unref](https://nodejs.org/api/timers.html#timers_unref) the setTimeout's.
      * @default false
      */
-    unref?: boolean | undefined;
+    unref?: boolean;
     /**
      * The maximum time (in milliseconds) that the retried operation is allowed to run.
      * @default Infinity
      */
-    maxRetryTime?: number | undefined;
+    maxRetryTime?: number;
 }
 
 /** Get an array with timeouts and their return values in milliseconds. */
@@ -100,7 +106,7 @@ export interface TimeoutsOptions extends CreateTimeoutOptions {
      * The maximum amount of times to retry the operation.
      * @default 10
      */
-    retries?: number | undefined;
+    retries?: number;
 }
 
 /**
@@ -116,22 +122,22 @@ export interface CreateTimeoutOptions {
      * The exponential factor to use.
      * @default 2
      */
-    factor?: number | undefined;
+    factor?: number;
     /**
      * The number of milliseconds before starting the first retry.
      * @default 1000
      */
-    minTimeout?: number | undefined;
+    minTimeout?: number;
     /**
      * The maximum number of milliseconds between two retries.
      * @default Infinity
      */
-    maxTimeout?: number | undefined;
+    maxTimeout?: number;
     /**
      * Randomizes the timeouts by multiplying a factor between 1-2.
      * @default false
      */
-    randomize?: boolean | undefined;
+    randomize?: boolean;
 }
 
 /**
@@ -139,6 +145,7 @@ export interface CreateTimeoutOptions {
  *
  * @param object The object to be wrapped
  * @param methods Methods which need to be wrapped
+ *
  */
 export function wrap(object: object, methods?: string[]): void;
-export function wrap(object: object, options?: WrapOptions, methods?: string[]): void;
+export function wrap(object: object, options?: OperationOptions, methods?: string[]): void;

package/node_modules/@types/retry/package.json

@@ -1,30 +1,28 @@
 {
     "name": "@types/retry",
-    "version": "0.12.5",
+    "version": "0.12.0",
     "description": "TypeScript definitions for retry",
-    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/retry",
     "license": "MIT",
     "contributors": [
         {
             "name": "Stan Goldmann",
-            "githubUsername": "krenor",
-            "url": "https://github.com/krenor"
+            "url": "https://github.com/krenor",
+            "githubUsername": "krenor"
         },
         {
             "name": "BendingBender",
-            "githubUsername": "BendingBender",
-            "url": "https://github.com/BendingBender"
+            "url": "https://github.com/BendingBender",
+            "githubUsername": "BendingBender"
         }
     ],
     "main": "",
-    "types": "index.d.ts",
+    "types": "index",
     "repository": {
         "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
-        "directory": "types/retry"
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git"
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "aa54558b4adab882512b32e89d71a59d1864fa79684a3ef317002d0e144cba11",
-    "typeScriptVersion": "4.5"
+    "typesPublisherContentHash": "dc8156aa3c27632d2585c45d8951c4a0f7ae9122bd17190d8973018556d174f3",
+    "typeScriptVersion": "2.3"
 }

package/node_modules/iconv-lite/encodings/sbcs-data.js

@@ -109,6 +109,8 @@ module.exports = {
 
   hebrew: "iso88598",
   hebrew8: "iso88598",
+  iso88598i: "iso88598",
+  iso88598e: "iso88598",
 
   turkish: "iso88599",
   turkish8: "iso88599",

package/node_modules/iconv-lite/encodings/utf32.js

@@ -31,7 +31,9 @@ function Utf32Encoder (options, codec) {
 
 Utf32Encoder.prototype.write = function (str) {
   var src = Buffer.from(str, "ucs2")
-  var dst = Buffer.alloc(src.length * 2)
+  // src.length * 2 covers this chunk's code units (4 bytes each); the extra 4 bytes leave room for a
+  // high surrogate held over from a previous chunk, which is flushed ahead of this chunk's units.
+  var dst = Buffer.alloc(src.length * 2 + 4)
   var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE
   var offset = 0
 
@@ -113,9 +115,9 @@ Utf32Decoder.prototype.write = function (src) {
       // NOTE: codepoint is a signed int32 and can be negative.
       // NOTE: We copied this block from below to help V8 optimize it (it works with array, not buffer).
       if (isLE) {
-        codepoint = overflow[i] | (overflow[i + 1] << 8) | (overflow[i + 2] << 16) | (overflow[i + 3] << 24)
+        codepoint = overflow[0] | (overflow[1] << 8) | (overflow[2] << 16) | (overflow[3] << 24)
       } else {
-        codepoint = overflow[i + 3] | (overflow[i + 2] << 8) | (overflow[i + 1] << 16) | (overflow[i] << 24)
+        codepoint = overflow[3] | (overflow[2] << 8) | (overflow[1] << 16) | (overflow[0] << 24)
       }
       overflow.length = 0
 
@@ -169,7 +171,12 @@ function _writeCodepoint (dst, offset, codepoint, badChar) {
 };
 
 Utf32Decoder.prototype.end = function () {
+  if (this.overflow.length === 0) { return }
+
+  // A leftover, incomplete 4-byte code unit at the end of the input is ill-formed. Substitute a
+  // single U+FFFD (Unicode Standard conformance clause C10) instead of silently dropping the bytes.
   this.overflow.length = 0
+  return String.fromCharCode(this.badChar)
 }
 
 // == UTF-32 Auto codec =============================================================

package/node_modules/iconv-lite/package.json

@@ -1,7 +1,7 @@
 {
     "name": "iconv-lite",
     "description": "Convert character encodings in pure javascript.",
-    "version": "0.7.2",
+    "version": "0.7.3",
     "license": "MIT",
     "keywords": [
         "iconv",
@@ -46,7 +46,7 @@
         "stream": false
     },
     "devDependencies": {
-        "@arethetypeswrong/cli": "^0.17.4",
+        "@arethetypeswrong/cli": "^0.18.4",
         "@stylistic/eslint-plugin": "^5.1.0",
         "@stylistic/eslint-plugin-js": "^4.1.0",
         "@types/node": "^24.0.12",

package/node_modules/iconv-lite/types/encodings.d.ts

@@ -276,6 +276,8 @@ export type Encoding =
   | "iso88596"
   | "iso88597"
   | "iso88598"
+  | "iso88598e"
+  | "iso88598i"
   | "iso88599"
   | "isoceltic"
   | "isoir100"

package/node_modules/path-to-regexp/Readme.md

@@ -153,7 +153,7 @@ The `parse` function accepts a string and returns `TokenData`, which can be used
 
 `TokenData` has two properties:
 
-- **tokens** A sequence of tokens, currently of types `text`, `parameter`, `wildcard`, or `group`.
+- **tokens** A sequence of tokens, currently of types `text`, `param`, `wildcard`, or `group`.
 - **originalPath** The original path used with `parse`, shown in error messages to assist debugging.
 
 ### Custom path
@@ -165,13 +165,13 @@ import { match } from "path-to-regexp";
 
 const tokens = [
   { type: "text", value: "/" },
-  { type: "parameter", name: "foo" },
+  { type: "param", name: "foo" },
 ];
 const originalPath = "/[foo]"; // To help debug error messages.
 const path = { tokens, originalPath };
 const fn = match(path);
 
-fn("/test"); //=> { path: '/test', index: 0, params: { foo: 'test' } }
+fn("/test"); //=> { path: '/test', params: { foo: 'test' } }
 ```
 
 ## Errors

package/node_modules/path-to-regexp/dist/index.js

@@ -11,7 +11,6 @@ const NOOP_VALUE = (value) => value;
 const ID_START = /^[$_\p{ID_Start}]$/u;
 const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
 const ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
-const SIMPLE_TOKENS = "{}()[]+?!";
 /**
  * Escape text for stringify to path.
  */
@@ -54,95 +53,91 @@ exports.PathError = PathError;
 function parse(str, options = {}) {
     const { encodePath = NOOP_VALUE } = options;
     const chars = [...str];
-    const tokens = [];
     let index = 0;
-    let pos = 0;
-    function name() {
-        let value = "";
-        if (ID_START.test(chars[index])) {
-            do {
-                value += chars[index++];
-            } while (ID_CONTINUE.test(chars[index]));
+    function consumeUntil(end) {
+        const output = [];
+        let path = "";
+        function writePath() {
+            if (!path)
+                return;
+            output.push({
+                type: "text",
+                value: encodePath(path),
+            });
+            path = "";
         }
-        else if (chars[index] === '"') {
-            let quoteStart = index;
-            while (index < chars.length) {
-                if (chars[++index] === '"') {
-                    index++;
-                    quoteStart = 0;
-                    break;
-                }
-                // Increment over escape characters.
-                if (chars[index] === "\\")
-                    index++;
-                value += chars[index];
+        while (index < chars.length) {
+            const value = chars[index++];
+            if (value === end) {
+                writePath();
+                return output;
             }
-            if (quoteStart) {
-                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
-            }
-        }
-        if (!value) {
-            throw new PathError(`Missing parameter name at index ${index}`, str);
-        }
-        return value;
-    }
-    while (index < chars.length) {
-        const value = chars[index++];
-        if (SIMPLE_TOKENS.includes(value)) {
-            tokens.push({ type: value, index, value });
-        }
-        else if (value === "\\") {
-            tokens.push({ type: "escape", index, value: chars[index++] });
-        }
-        else if (value === ":") {
-            tokens.push({ type: "param", index, value: name() });
-        }
-        else if (value === "*") {
-            tokens.push({ type: "wildcard", index, value: name() });
-        }
-        else {
-            tokens.push({ type: "char", index, value });
-        }
-    }
-    tokens.push({ type: "end", index, value: "" });
-    function consumeUntil(endType) {
-        const output = [];
-        while (true) {
-            const token = tokens[pos++];
-            if (token.type === endType)
-                break;
-            if (token.type === "char" || token.type === "escape") {
-                let path = token.value;
-                let cur = tokens[pos];
-                while (cur.type === "char" || cur.type === "escape") {
-                    path += cur.value;
-                    cur = tokens[++pos];
+            if (value === "\\") {
+                if (index === chars.length) {
+                    throw new PathError(`Unexpected end after \\ at index ${index}`, str);
                 }
-                output.push({
-                    type: "text",
-                    value: encodePath(path),
-                });
+                path += chars[index++];
                 continue;
             }
-            if (token.type === "param" || token.type === "wildcard") {
-                output.push({
-                    type: token.type,
-                    name: token.value,
-                });
+            if (value === ":" || value === "*") {
+                const type = value === ":" ? "param" : "wildcard";
+                let name = "";
+                if (ID_START.test(chars[index])) {
+                    do {
+                        name += chars[index++];
+                    } while (ID_CONTINUE.test(chars[index]));
+                }
+                else if (chars[index] === '"') {
+                    let quoteStart = index;
+                    while (index < chars.length) {
+                        if (chars[++index] === '"') {
+                            index++;
+                            quoteStart = 0;
+                            break;
+                        }
+                        // Increment over escape characters.
+                        if (chars[index] === "\\")
+                            index++;
+                        name += chars[index];
+                    }
+                    if (quoteStart) {
+                        throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+                    }
+                }
+                if (!name) {
+                    throw new PathError(`Missing parameter name at index ${index}`, str);
+                }
+                writePath();
+                output.push({ type, name });
                 continue;
             }
-            if (token.type === "{") {
+            if (value === "{") {
+                writePath();
                 output.push({
                     type: "group",
                     tokens: consumeUntil("}"),
                 });
                 continue;
             }
-            throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
+            if (value === "}" ||
+                value === "(" ||
+                value === ")" ||
+                value === "[" ||
+                value === "]" ||
+                value === "+" ||
+                value === "?" ||
+                value === "!") {
+                throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+            }
+            path += value;
+        }
+        if (end) {
+            throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
         }
+        writePath();
         return output;
     }
-    return new TokenData(consumeUntil("end"), str);
+    return new TokenData(consumeUntil(""), str);
 }
 /**
  * Compile a string to a template function for the path.
@@ -152,7 +147,8 @@ function compile(path, options = {}) {
     const data = typeof path === "object" ? path : parse(path, options);
     const fn = tokensToFunction(data.tokens, delimiter, encode);
     return function path(params = {}) {
-        const [path, ...missing] = fn(params);
+        const missing = [];
+        const path = fn(params, missing);
         if (missing.length) {
             throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
         }
@@ -161,12 +157,10 @@ function compile(path, options = {}) {
 }
 function tokensToFunction(tokens, delimiter, encode) {
     const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
-    return (data) => {
-        const result = [""];
+    return (data, missing) => {
+        let result = "";
         for (const encoder of encoders) {
-            const [value, ...extras] = encoder(data);
-            result[0] += value;
-            result.push(...extras);
+            result += encoder(data, missing);
         }
         return result;
     };
@@ -176,45 +170,51 @@ function tokensToFunction(tokens, delimiter, encode) {
  */
 function tokenToFunction(token, delimiter, encode) {
     if (token.type === "text")
-        return () => [token.value];
+        return () => token.value;
     if (token.type === "group") {
         const fn = tokensToFunction(token.tokens, delimiter, encode);
-        return (data) => {
-            const [value, ...missing] = fn(data);
-            if (!missing.length)
-                return [value];
-            return [""];
+        return (data, missing) => {
+            const len = missing.length;
+            const value = fn(data, missing);
+            if (missing.length === len)
+                return value;
+            missing.length = len; // Reset optional group.
+            return "";
         };
     }
     const encodeValue = encode || NOOP_VALUE;
     if (token.type === "wildcard" && encode !== false) {
-        return (data) => {
+        return (data, missing) => {
             const value = data[token.name];
-            if (value == null)
-                return ["", token.name];
+            if (value == null) {
+                missing.push(token.name);
+                return "";
+            }
             if (!Array.isArray(value) || value.length === 0) {
                 throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
             }
-            return [
-                value
-                    .map((value, index) => {
-                    if (typeof value !== "string") {
-                        throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
-                    }
-                    return encodeValue(value);
-                })
-                    .join(delimiter),
-            ];
+            let result = "";
+            for (let i = 0; i < value.length; i++) {
+                if (typeof value[i] !== "string") {
+                    throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+                }
+                if (i > 0)
+                    result += delimiter;
+                result += encodeValue(value[i]);
+            }
+            return result;
         };
     }
-    return (data) => {
+    return (data, missing) => {
         const value = data[token.name];
-        if (value == null)
-            return ["", token.name];
+        if (value == null) {
+            missing.push(token.name);
+            return "";
+        }
         if (typeof value !== "string") {
             throw new TypeError(`Expected "${token.name}" to be a string`);
         }
-        return [encodeValue(value)];
+        return encodeValue(value);
     };
 }
 /**
@@ -251,55 +251,33 @@ function match(path, options = {}) {
  */
 function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
-    const root = new SourceNode("^");
-    const paths = [path];
+    const keys = [];
+    let source = "";
     let combinations = 0;
-    while (paths.length) {
-        const path = paths.shift();
+    function process(path) {
         if (Array.isArray(path)) {
-            paths.push(...path);
-            continue;
+            for (const p of path)
+                process(p);
+            return;
         }
         const data = typeof path === "object" ? path : parse(path, options);
         flatten(data.tokens, 0, [], (tokens) => {
-            if (combinations++ >= 256) {
+            if (combinations >= 256) {
                 throw new PathError("Too many path combinations", data.originalPath);
             }
-            let node = root;
-            for (const part of toRegExpSource(tokens, delimiter, data.originalPath)) {
-                node = node.add(part.source, part.key);
-            }
-            node.add(""); // Mark the end of the source.
+            if (combinations > 0)
+                source += "|";
+            source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+            combinations++;
         });
     }
-    const keys = [];
-    let pattern = toRegExp(root, keys);
+    process(path);
+    let pattern = `^(?:${source})`;
     if (trailing)
         pattern += "(?:" + escape(delimiter) + "$)?";
     pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
     return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
 }
-function toRegExp(node, keys) {
-    if (node.key)
-        keys.push(node.key);
-    const children = Object.keys(node.children);
-    const text = children
-        .map((id) => toRegExp(node.children[id], keys))
-        .join("|");
-    return node.source + (children.length < 2 ? text : `(?:${text})`);
-}
-class SourceNode {
-    constructor(source, key) {
-        this.source = source;
-        this.key = key;
-        this.children = Object.create(null);
-    }
-    add(source, key) {
-        var _a;
-        const id = source + ":" + (key ? key.name : "");
-        return ((_a = this.children)[id] || (_a[id] = new SourceNode(source, key)));
-    }
-}
 /**
  * Generate a flat list of sequence tokens from the given tokens.
  */
@@ -307,7 +285,9 @@ function flatten(tokens, index, result, callback) {
     while (index < tokens.length) {
         const token = tokens[index++];
         if (token.type === "group") {
-            flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
+            const len = result.length;
+            flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+            result.length = len;
             continue;
         }
         result.push(token);
@@ -317,8 +297,8 @@ function flatten(tokens, index, result, callback) {
 /**
  * Transform a flat sequence of tokens into a regular expression.
  */
-function toRegExpSource(tokens, delimiter, originalPath) {
-    let result = [];
+function toRegExpSource(tokens, delimiter, keys, originalPath) {
+    let result = "";
     let backtrack = "";
     let wildcardBacktrack = "";
     let prevCaptureType = 0;
@@ -349,7 +329,7 @@ function toRegExpSource(tokens, delimiter, originalPath) {
     while (index < tokens.length) {
         const token = tokens[index++];
         if (token.type === "text") {
-            result.push({ source: escape(token.value) });
+            result += escape(token.value);
             backtrack += token.value;
             if (prevCaptureType === 2)
                 wildcardBacktrack += token.value;
@@ -362,30 +342,27 @@ function toRegExpSource(tokens, delimiter, originalPath) {
                 throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
             }
             if (token.type === "param") {
-                result.push({
-                    source: hasSegmentCapture // Seen param/wildcard in segment.
-                        ? `(${negate(delimiter, backtrack)}+?)`
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(delimiter, backtrack)}+)`
                         : hasInSegment(index, "wildcard") // See wildcard later in segment.
-                            ? `(${negate(delimiter, peekText(index))}+?)`
-                            : `(${negate(delimiter, "")}+?)`,
-                    key: token,
-                });
+                            ? `(${negate(delimiter, peekText(index))}+)`
+                            : hasSegmentCapture & 1 // Seen parameter in segment.
+                                ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})`
+                                : `(${negate(delimiter, "")}+)`;
                 hasSegmentCapture |= prevCaptureType = 1;
             }
             else {
-                result.push({
-                    source: hasSegmentCapture & 2 // Seen wildcard in segment.
-                        ? `(${negate(backtrack, "")}+?)`
-                        : hasSegmentCapture & 1 // Seen param in segment.
-                            ? `(${negate(wildcardBacktrack, "")}+?)`
-                            : wildcardBacktrack // No capture in segment, seen wildcard in path.
-                                ? `(${negate(wildcardBacktrack, "")}+?|${negate(delimiter, "")}+?)`
-                                : `([^]+?)`,
-                    key: token,
-                });
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(backtrack, "")}+)`
+                        : wildcardBacktrack // No capture in segment, seen wildcard in path.
+                            ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)`
+                            : `([^]+)`;
                 wildcardBacktrack = "";
                 hasSegmentCapture |= prevCaptureType = 2;
             }
+            keys.push(token);
             backtrack = "";
             continue;
         }