@openclaw/feishu 2026.7.2-beta.7 → 2026.7.33

package/node_modules/@larksuiteoapi/node-sdk/node_modules/protobufjs/package.json

@@ -1,14 +1,24 @@
 {
   "name": "protobufjs",
-  "version": "8.7.1",
-  "description": "Protocol Buffers for JavaScript & TypeScript.",
+  "version": "7.6.3",
+  "versionScheme": "~",
+  "description": "Protocol Buffers for JavaScript (& TypeScript).",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "license": "BSD-3-Clause",
   "repository": "protobufjs/protobuf.js",
   "bugs": "https://github.com/protobufjs/protobuf.js/issues",
+  "homepage": "https://protobufjs.github.io/protobuf.js/",
   "engines": {
     "node": ">=12.0.0"
   },
+  "eslintConfig": {
+    "env": {
+      "es6": true
+    },
+    "parserOptions": {
+      "ecmaVersion": 6
+    }
+  },
   "keywords": [
     "protobuf",
     "protocol-buffers",
@@ -16,64 +26,80 @@
     "typescript"
   ],
   "main": "index.js",
-  "type": "commonjs",
   "types": "index.d.ts",
   "browser": {
     "fs": false
   },
+  "publishConfig": {
+    "tag": "latest-7"
+  },
   "scripts": {
-    "bench": "npm --prefix bench run bench",
+    "bench": "node bench",
     "build": "npm run build:bundle && npm run build:types",
     "build:bundle": "gulp --gulpfile scripts/gulpfile.js",
-    "build:tests": "node ./scripts/gentests.js",
-    "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/ && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/descriptor.generated.d.ts ext/descriptor.js && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/textformat.generated.d.ts ext/textformat.js && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/protojson.generated.d.ts ext/protojson.js",
+    "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/ lib/aspromise/index.js lib/base64/index.js lib/codegen/index.js lib/eventemitter/index.js lib/float/index.js lib/fetch/index.js lib/inquire/index.js lib/path/index.js lib/pool/index.js lib/utf8/index.js",
+    "changelog": "node scripts/changelog -w",
     "coverage": "npm run coverage:test && npm run coverage:report",
     "coverage:test": "nyc --silent tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
     "coverage:report": "nyc report --reporter=lcov --reporter=text",
-    "docs": "npm run docs:build",
-    "docs:build": "jsdoc -c config/jsdoc.json -R README.md --verbose --pedantic",
-    "docs:publish": "npm run docs:build && node scripts/pages",
+    "docs": "jsdoc -c config/jsdoc.json -R README.md --verbose --pedantic",
     "lint": "npm run lint:sources && npm run lint:types",
-    "lint:sources": "eslint \"**/*.js\"",
+    "lint:sources": "eslint \"**/*.js\" -c config/eslint.json",
     "lint:types": "tslint \"**/*.d.ts\" -e \"**/node_modules/**\" -t stylish -c config/tslint.json",
+    "pages": "node scripts/pages",
     "prepublish": "cd cli && npm install && cd .. && npm run build",
     "prepublishOnly": "cd cli && npm install && cd .. && npm run build",
+    "postinstall": "node scripts/postinstall",
     "prof": "node bench/prof",
     "test": "npm run test:sources && npm run test:types",
     "test:sources": "tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
-    "test:types": "tsc tests/comp_typescript.ts --target es2019 --module commonjs --types node --lib es2019 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc -p tsconfig.test-types.json",
-    "make": "npm run lint:sources && npm run build && npm run lint:types && npm run build:tests && npm test"
+    "test:types": "tsc tests/comp_typescript.ts --lib es2015 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc tests/data/test.js.ts --lib es2015 --esModuleInterop --noEmit --strictNullChecks && tsc tests/data/*.ts --lib es2015 --esModuleInterop --noEmit --strictNullChecks",
+    "make": "npm run lint:sources && npm run build && npm run lint:types && node ./scripts/gentests.js && npm test"
   },
   "dependencies": {
+    "@protobufjs/aspromise": "^1.1.2",
+    "@protobufjs/base64": "^1.1.2",
+    "@protobufjs/codegen": "^2.0.5",
+    "@protobufjs/eventemitter": "^1.1.1",
+    "@protobufjs/fetch": "^1.1.1",
+    "@protobufjs/float": "^1.0.2",
+    "@protobufjs/inquire": "^1.1.2",
+    "@protobufjs/path": "^1.1.2",
+    "@protobufjs/pool": "^1.1.0",
+    "@protobufjs/utf8": "^1.1.1",
+    "@types/node": ">=13.7.0",
     "long": "^5.3.2"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.0",
-    "@types/node": "^18.19.130",
+    "benchmark": "^2.1.4",
     "browserify": "^17.0.0",
     "browserify-wrap": "^1.0.2",
     "bundle-collapser": "^1.3.0",
-    "escodegen": "^2.0.0",
-    "eslint": "^10.0.0",
-    "eslint-plugin-jsdoc": "^63.0.0",
+    "chalk": "^4.0.0",
+    "escodegen": "^1.13.0",
+    "eslint": "^8.15.0",
     "espree": "^9.0.0",
     "estraverse": "^5.1.0",
-    "gh-pages": "^6.0.0",
-    "globals": "^17.0.0",
-    "gulp": "^5.0.0",
+    "gh-pages": "^4.0.0",
+    "git-raw-commits": "^2.0.3",
+    "git-semver-tags": "^4.0.0",
+    "google-protobuf": "^3.11.3",
+    "gulp": "^4.0.2",
     "gulp-header": "^2.0.9",
     "gulp-if": "^3.0.0",
     "gulp-sourcemaps": "^3.0.0",
     "gulp-uglify": "^3.0.2",
+    "jaguarjs-jsdoc": "github:dcodeIO/jaguarjs-jsdoc",
     "jsdoc": "^4.0.0",
-    "minimist": "^1.2.8",
-    "nyc": "^18.0.0",
-    "reflect-metadata": "^0.2.0",
+    "minimist": "^1.2.0",
+    "nyc": "^15.0.0",
+    "reflect-metadata": "^0.1.13",
     "tape": "^5.0.0",
     "tslint": "^6.0.0",
-    "typescript": "^4.9.5",
+    "typescript": "^3.7.5",
+    "uglify-js": "^3.7.7",
     "vinyl-buffer": "^1.0.1",
-    "vinyl-fs": "^4.0.0",
+    "vinyl-fs": "^3.0.3",
     "vinyl-source-stream": "^2.0.0"
   },
   "files": [
@@ -85,6 +111,7 @@
     "minimal.js",
     "package-lock.json",
     "tsconfig.json",
+    "scripts/postinstall.js",
     "dist/**",
     "ext/**",
     "google/**",

package/node_modules/@larksuiteoapi/node-sdk/node_modules/protobufjs/scripts/postinstall.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var path = require("path"),
+    fs   = require("fs"),
+    pkg  = require(path.join(__dirname, "..", "package.json"));
+
+// check version scheme used by dependents
+if (!pkg.versionScheme)
+    return;
+
+var warn = process.stderr.isTTY
+    ? "\x1b[30m\x1b[43mWARN\x1b[0m \x1b[35m" + path.basename(process.argv[1], ".js") + "\x1b[0m"
+    : "WARN " + path.basename(process.argv[1], ".js");
+
+var basePkg;
+try {
+    basePkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "..", "package.json")));
+} catch (e) {
+    return;
+}
+
+[
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies"
+]
+.forEach(function(check) {
+    var version = basePkg && basePkg[check] && basePkg[check][pkg.name];
+    if (typeof version === "string" && version.charAt(0) !== pkg.versionScheme)
+        process.stderr.write(pkg.name + " " + warn + " " + pkg.name + "@" + version + " is configured as a dependency of " + basePkg.name + ". use " + pkg.name + "@" + pkg.versionScheme + version.substring(1) + " instead for API compatibility.\n");
+});

package/node_modules/@larksuiteoapi/node-sdk/node_modules/protobufjs/src/common.js

@@ -163,33 +163,27 @@ common("struct", {
         fields: {
             nullValue: {
                 type: "NullValue",
-                id: 1,
-                protoName: "null_value"
+                id: 1
             },
             numberValue: {
                 type: "double",
-                id: 2,
-                protoName: "number_value"
+                id: 2
             },
             stringValue: {
                 type: "string",
-                id: 3,
-                protoName: "string_value"
+                id: 3
             },
             boolValue: {
                 type: "bool",
-                id: 4,
-                protoName: "bool_value"
+                id: 4
             },
             structValue: {
                 type: "Struct",
-                id: 5,
-                protoName: "struct_value"
+                id: 5
             },
             listValue: {
                 type: "ListValue",
-                id: 6,
-                protoName: "list_value"
+                id: 6
             }
         }
     },
@@ -369,9 +363,9 @@ common("field_mask", {
 
     /**
      * Properties of a google.protobuf.FieldMask message.
-     * @interface IFieldMask
+     * @interface IDoubleValue
      * @type {Object}
-     * @property {string[]} [paths]
+     * @property {number} [value]
      * @memberof common
      */
     FieldMask: {

package/node_modules/@larksuiteoapi/node-sdk/node_modules/protobufjs/src/converter.js

@@ -5,9 +5,8 @@
  */
 var converter = exports;
 
-var Enum  = require("./enum"),
-    types = require("./types"),
-    util  = require("./util");
+var Enum = require("./enum"),
+    util = require("./util");
 
 /**
  * Generates a partial value fromObject conveter.
@@ -15,38 +14,36 @@ var Enum  = require("./enum"),
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
  * @param {string} prop Property reference
- * @param {string} [dstProp] Repeated destination property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {
+function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
+    var defaultAlreadyEmitted = false;
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     if (field.resolvedType) {
-        if (field.resolvedType instanceof Enum) {
-            var dst = dstProp
-                ? "m" + dstProp + "[m" + dstProp + ".length]"
-                : "m" + prop;
-            gen
+        if (field.resolvedType instanceof Enum) { gen
             ("switch(d%s){", prop);
-            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) { gen
+            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
+                // enum unknown values passthrough
+                if (values[keys[i]] === field.typeDefault && !defaultAlreadyEmitted) { gen
+                    ("default:")
+                        ("if(typeof(d%s)===\"number\"){m%s=d%s;break}", prop, prop, prop);
+                    if (!field.repeated) gen // fallback to default value only for
+                                             // arrays, to avoid leaving holes.
+                        ("break");           // for non-repeated fields, just ignore
+                    defaultAlreadyEmitted = true;
+                }
+                gen
                 ("case%j:", keys[i])
                 ("case %i:", values[keys[i]])
-                    ("%s=%j", dst, values[keys[i]])
+                    ("m%s=%j", prop, values[keys[i]])
                     ("break");
-            }
-            gen
-                ("default:");
-            if (field.resolvedType._features.enum_type !== "CLOSED") {
-                gen
-                    ("if(typeof d%s===\"number\"&&(d%s|0)===d%s)", prop, prop, prop)
-                        ("%s=d%s", dst, prop);
-            }
-            gen
+            } gen
             ("}");
         } else gen
             ("if(!util.isObject(d%s))", prop)
                 ("throw TypeError(%j)", field.fullName + ": object expected")
-            ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
+            ("m%s=types[%i].fromObject(d%s,n+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
@@ -82,7 +79,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {
             case "bytes": gen
                 ("if(typeof d%s===\"string\")", prop)
                     ("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)
-                ("else if(d%s.length>=0)", prop)
+                ("else if(d%s.length >= 0)", prop)
                     ("m%s=d%s", prop, prop);
                 break;
             case "string": gen
@@ -108,23 +105,22 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {
 converter.fromObject = function fromObject(mtype) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     var fields = mtype.fieldsArray;
-    var gen = util.codegen(["d", "q"])
-    ("if(d instanceof C)")
-        ("return d")
+    var gen = util.codegen(["d", "n"], mtype.name + "$fromObject")
+    ("if(d instanceof this.ctor)")
+        ("return d");
+    if (!fields.length) return gen
+    ("return new this.ctor");
+    gen
     ("if(!util.isObject(d))")
         ("throw TypeError(%j)", mtype.fullName + ": object expected")
-    ("if(q===undefined)q=0")
-    ("if(q>util.recursionLimit)")
-        ("throw Error(\"max depth exceeded\")");
-    if (!fields.length) return gen
-    ("return new C");
+    ("if(n===undefined)n=0")
+    ("if(n>util.recursionLimit)")
+        ("throw Error(\"maximum nesting depth exceeded\")");
     gen
-    ("var m=new C");
+    ("var m=new this.ctor");
     for (var i = 0; i < fields.length; ++i) {
         var field  = fields[i].resolve(),
-            prop   = util.safeProp(field.name),
-            implicitPresence = !field.hasPresence && !field.repeated && !field.map
-                && (field.resolvedType instanceof Enum || types.basic[field.type] !== undefined);
+            prop   = util.safeProp(field.name);
 
         // Map fields
         if (field.map) { gen
@@ -144,14 +140,10 @@ converter.fromObject = function fromObject(mtype) {
         } else if (field.repeated) { gen
     ("if(d%s){", prop)
         ("if(!Array.isArray(d%s))", prop)
-            ("throw TypeError(%j)", field.fullName + ": array expected");
-            if (field.resolvedType instanceof Enum) gen
-        ("m%s=[]", prop);
-            else gen
-        ("m%s=Array(d%s.length)", prop, prop);
-            gen
+            ("throw TypeError(%j)", field.fullName + ": array expected")
+        ("m%s=[]", prop)
         ("for(var i=0;i<d%s.length;++i){", prop);
-            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]", field.resolvedType instanceof Enum ? prop : undefined)
+            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
         ("}")
     ("}");
 
@@ -159,25 +151,7 @@ converter.fromObject = function fromObject(mtype) {
         } else {
             if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
     ("if(d%s!=null){", prop); // !== undefined && !== null
-            if (implicitPresence) {
-                if (field.resolvedType instanceof Enum) gen
-    ("if(d%s!==%j&&(typeof d%s!==\"string\"||types[%i].values[d%s]!==%j)){", prop, field.typeDefault, prop, i, prop, field.typeDefault);
-                else if (field.type === "string") gen
-    ("if(typeof d%s!==\"string\"||d%s.length){", prop, prop);
-                else if (field.type === "bytes") gen
-    ("if(d%s.length){", prop);
-                else if (field.type === "bool") gen
-    ("if(d%s){", prop);
-                else if (field.type === "double" || field.type === "float") gen
-    ("if(!Object.is(Number(d%s),0)){", prop);
-                else if (types.long[field.type] !== undefined) gen
-    ("if(typeof d%s===\"object\"?d%s.low||d%s.high:Number(d%s)!==0){", prop, prop, prop, prop);
-                else gen
-    ("if(Number(d%s)!==0){", prop);
-            }
         genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
-            if (implicitPresence) gen
-    ("}");
             if (!(field.resolvedType instanceof Enum)) gen
     ("}");
         }
@@ -191,26 +165,23 @@ converter.fromObject = function fromObject(mtype) {
  * @param {Codegen} gen Codegen instance
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
- * @param {string} dstProp Destination property reference
- * @param {string} [srcProp] Source property reference
+ * @param {string} prop Property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
+function genValuePartial_toObject(gen, field, fieldIndex, prop) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
-    if (!srcProp)
-        srcProp = dstProp;
     if (field.resolvedType) {
         if (field.resolvedType instanceof Enum) gen
-            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);
+            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", prop, fieldIndex, prop, prop, fieldIndex, prop, prop);
         else gen
-            ("d%s=types[%i].toObject(m%s,o,q+1)", dstProp, fieldIndex, srcProp);
+            ("d%s=types[%i].toObject(m%s,o,q+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
             case "double":
             case "float": gen
-            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", dstProp, srcProp, srcProp, srcProp);
+            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
                 break;
             case "uint64":
             case "fixed64":
@@ -220,17 +191,17 @@ function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
             case "sint64":
             case "sfixed64": gen
             ("if(typeof BigInt!==\"undefined\"&&o.longs===BigInt)")
-                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", dstProp, srcProp, srcProp, srcProp, srcProp, isUnsigned)
-            ("else if(typeof m%s===\"number\")", srcProp)
-                ("d%s=o.longs===String?String(m%s):m%s", dstProp, srcProp, srcProp)
+                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", prop, prop, prop, prop, prop, isUnsigned)
+            ("else if(typeof m%s===\"number\")", prop)
+                ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
             ("else") // Long-like
-                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", dstProp, srcProp, srcProp, srcProp, isUnsigned ? "true": "", srcProp);
+                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
                 break;
             case "bytes": gen
-            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", dstProp, srcProp, srcProp, srcProp, srcProp);
+            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
                 break;
             default: gen
-            ("d%s=m%s", dstProp, srcProp);
+            ("d%s=m%s", prop, prop);
                 break;
         }
     }
@@ -248,7 +219,7 @@ converter.toObject = function toObject(mtype) {
     var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
     if (!fields.length)
         return util.codegen()("return {}");
-    var gen = util.codegen(["m", "o", "q"])
+    var gen = util.codegen(["m", "o", "q"], mtype.name + "$toObject")
     ("if(!o)")
         ("o={}")
     ("if(q===undefined)q=0")
@@ -298,7 +269,7 @@ converter.toObject = function toObject(mtype) {
             else if (field.bytes) {
                 var arrayDefault = Array.prototype.slice.call(field.typeDefault);
                 gen
-        ("if(o.bytes===String)d%s=%j", prop, util.base64.encode(field.typeDefault, 0, field.typeDefault.length))
+        ("if(o.bytes===String)d%s=%j", prop, String.fromCharCode.apply(String, field.typeDefault))
         ("else{")
             ("d%s=%j", prop, arrayDefault)
             ("if(o.bytes!==Array)d%s=util.newBuffer(d%s)", prop, prop)
@@ -318,28 +289,23 @@ converter.toObject = function toObject(mtype) {
     ("var ks2");
             } gen
     ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
-        ("d%s={}", prop);
-            var longKey = types.long[field.keyType] !== undefined,
-                srcProp = prop + "[ks2[j]]";
-            gen
+        ("d%s={}", prop)
         ("for(var j=0;j<ks2.length;++j){");
-            if (longKey) gen
-            ("var k2=util.longFromKey(ks2[j],%j).toString()", field.keyType === "uint64" || field.keyType === "fixed64");
             gen
         ("if(ks2[j]===\"__proto__\")")
             ("util.makeProp(d%s,ks2[j])", prop);
-            genValuePartial_toObject(gen, field, /* sorted */ index, longKey ? prop + "[k2]" : srcProp, srcProp)
+            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
         ("}");
         } else if (field.repeated) { gen
     ("if(m%s&&m%s.length){", prop, prop)
-        ("d%s=Array(m%s.length)", prop, prop)
+        ("d%s=[]", prop)
         ("for(var j=0;j<m%s.length;++j){", prop);
             genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
         ("}");
         } else { gen
     ("if(m%s!=null&&Object.hasOwnProperty.call(m,%j)){", prop, field.name); // !== undefined && !== null
         genValuePartial_toObject(gen, field, /* sorted */ index, prop);
-        if (field.partOf && !field.partOf.isProto3Optional) gen
+        if (field.partOf) gen
         ("if(o.oneofs)")
             ("d%s=%j", util.safeProp(field.partOf.name), field.name);
         }