@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/node_modules/@slack/bolt/node_modules/iconv-lite/encodings/utf32.js

@@ -31,9 +31,7 @@ function Utf32Encoder (options, codec) {
 
 Utf32Encoder.prototype.write = function (str) {
   var src = Buffer.from(str, "ucs2")
-  // 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 dst = Buffer.alloc(src.length * 2)
   var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE
   var offset = 0
 
@@ -115,9 +113,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[0] | (overflow[1] << 8) | (overflow[2] << 16) | (overflow[3] << 24)
+        codepoint = overflow[i] | (overflow[i + 1] << 8) | (overflow[i + 2] << 16) | (overflow[i + 3] << 24)
       } else {
-        codepoint = overflow[3] | (overflow[2] << 8) | (overflow[1] << 16) | (overflow[0] << 24)
+        codepoint = overflow[i + 3] | (overflow[i + 2] << 8) | (overflow[i + 1] << 16) | (overflow[i] << 24)
       }
       overflow.length = 0
 
@@ -171,12 +169,7 @@ 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/@slack/bolt/node_modules/iconv-lite/package.json

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

package/node_modules/@slack/bolt/node_modules/iconv-lite/types/encodings.d.ts

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

package/node_modules/@slack/bolt/node_modules/media-typer/README.md

@@ -1,18 +1,18 @@
 # media-typer
 
-[![NPM Version][npm-image]][npm-url]
-[![NPM Downloads][downloads-image]][downloads-url]
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
 [![Node.js Version][node-version-image]][node-version-url]
-[![Build Status][ci-image]][ci-url]
+[![Build Status][travis-image]][travis-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
 
 Simple RFC 6838 media type parser.
 
-This module will parse a given media type into its component parts, like type,
+This module will parse a given media type into it's component parts, like type,
 subtype, and suffix. A formatter is also provided to put them back together and
 the two can be combined to normalize media types into a canonical form.
 
-If you are looking to parse the string that represents a media type and its
+If you are looking to parse the string that represents a media type and it's
 parameters in HTTP (for example, the `Content-Type` header), use the
 [content-type module](https://www.npmjs.com/package/content-type).
 
@@ -75,20 +75,19 @@ If any of the given object values are invalid, then a `TypeError` is thrown.
 var valid = typer.test('image/svg+xml')
 ```
 
-Validate a media type string. This will return `true` if the string is a well-
+Validate a media type string. This will return `true` is the string is a well-
 formatted media type, or `false` otherwise.
 
 ## License
 
 [MIT](LICENSE)
 
-[ci-image]: https://img.shields.io/github/workflow/status/jshttp/media-typer/ci/master?label=ci
-[ci-url]: https://github.com/jshttp/media-typer/actions/workflows/ci.yml
-[npm-image]: https://img.shields.io/npm/v/media-typer.svg
-[npm-url]: https://npmjs.org/package/media-typer
-[node-version-image]: https://img.shields.io/node/v/media-typer.svg
-[node-version-url]: https://nodejs.org/en/
-[coveralls-image]: https://img.shields.io/coveralls/jshttp/media-typer/master.svg
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/media-typer/master
 [coveralls-url]: https://coveralls.io/r/jshttp/media-typer?branch=master
-[downloads-image]: https://img.shields.io/npm/dm/media-typer.svg
-[downloads-url]: https://npmjs.org/package/media-typer
+[node-version-image]: https://badgen.net/npm/node/media-typer
+[node-version-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/media-typer
+[npm-url]: https://npmjs.org/package/media-typer
+[npm-version-image]: https://badgen.net/npm/v/media-typer
+[travis-image]: https://badgen.net/travis/jshttp/media-typer/master
+[travis-url]: https://travis-ci.org/jshttp/media-typer

package/node_modules/@slack/bolt/node_modules/media-typer/index.js

@@ -83,6 +83,10 @@ function format (obj) {
  */
 
 function test (string) {
+  if (!string) {
+    throw new TypeError('argument string is required')
+  }
+
   if (typeof string !== 'string') {
     throw new TypeError('argument string is required to be a string')
   }
@@ -99,6 +103,10 @@ function test (string) {
  */
 
 function parse (string) {
+  if (!string) {
+    throw new TypeError('argument string is required')
+  }
+
   if (typeof string !== 'string') {
     throw new TypeError('argument string is required to be a string')
   }

package/node_modules/@slack/bolt/node_modules/media-typer/package.json

@@ -1,24 +1,20 @@
 {
   "name": "media-typer",
   "description": "Simple RFC 6838 media type parser and formatter",
-  "version": "1.1.1",
+  "version": "1.1.0",
   "author": "Douglas Christopher Wilson <doug@somethingdoug.com>",
   "license": "MIT",
   "repository": "jshttp/media-typer",
-  "funding": {
-    "type": "opencollective",
-    "url": "https://opencollective.com/express"
-  },
   "devDependencies": {
-    "eslint": "7.23.0",
-    "eslint-config-standard": "14.1.1",
-    "eslint-plugin-import": "2.22.1",
-    "eslint-plugin-markdown": "1.0.2",
-    "eslint-plugin-node": "11.1.0",
-    "eslint-plugin-promise": "4.3.1",
-    "eslint-plugin-standard": "4.1.0",
-    "mocha": "9.2.0",
-    "nyc": "15.1.0"
+    "eslint": "5.16.0",
+    "eslint-config-standard": "12.0.0",
+    "eslint-plugin-import": "2.17.2",
+    "eslint-plugin-markdown": "1.0.0",
+    "eslint-plugin-node": "8.0.1",
+    "eslint-plugin-promise": "4.1.1",
+    "eslint-plugin-standard": "4.0.0",
+    "mocha": "6.1.4",
+    "nyc": "14.0.0"
   },
   "files": [
     "LICENSE",
@@ -31,7 +27,7 @@
   "scripts": {
     "lint": "eslint --plugin markdown --ext js,md .",
     "test": "mocha --reporter spec --check-leaks --bail test/",
-    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
-    "test-cov": "nyc --reporter=html --reporter=text npm test"
+    "test-cov": "nyc --reporter=html --reporter=text npm test",
+    "test-travis": "nyc --reporter=text npm test"
   }
 }

package/node_modules/@slack/bolt/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`, `param`, `wildcard`, or `group`.
+- **tokens** A sequence of tokens, currently of types `text`, `parameter`, `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: "param", name: "foo" },
+  { type: "parameter", name: "foo" },
 ];
 const originalPath = "/[foo]"; // To help debug error messages.
 const path = { tokens, originalPath };
 const fn = match(path);
 
-fn("/test"); //=> { path: '/test', params: { foo: 'test' } }
+fn("/test"); //=> { path: '/test', index: 0, params: { foo: 'test' } }
 ```
 
 ## Errors

package/node_modules/@slack/bolt/node_modules/path-to-regexp/dist/index.js

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