@iflyrpa/actions 3.0.0-beta.2 → 3.0.0-beta.3

package/dist/bundle.js

@@ -8733,10 +8733,8 @@ var __webpack_exports__ = {};
         navigator: ()=>_navigator,
         origin: ()=>utils_origin
     });
-    var package_namespaceObject = {
-        i8: "0.0.18"
-    };
-    var package_namespaceObject_0 = JSON.parse('{"i8":"3.0.0-beta.1"}');
+    var package_namespaceObject = JSON.parse('{"i8":"0.0.19-beta.0"}');
+    var package_namespaceObject_0 = JSON.parse('{"i8":"3.0.0-beta.2"}');
     const external_node_fs_namespaceObject = require("node:fs");
     var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
     const external_node_http_namespaceObject = require("node:http");
@@ -23281,7 +23279,11 @@ var __webpack_exports__ = {};
             url: "http://172.29.194.32:9998/pool/eip/proxy",
             data: params
         }).catch((err)=>{
-            throw new Error(`请求代理失败：${err.message}`);
+            throw {
+                code: 414,
+                message: `请求代理失败：${err.message}`,
+                data: {}
+            };
         });
         const loggerInfo = {
             params,
@@ -31516,6 +31518,558 @@ var __webpack_exports__ = {};
         };
         return utils_response(isSuccess ? 0 : 414, message, data);
     };
+    var esm_ab = ArrayBuffer, u8 = Uint8Array, u16 = Uint16Array, i16 = Int16Array, i32 = Int32Array;
+    var slc = function(v, s, e) {
+        if (u8.prototype.slice) return u8.prototype.slice.call(v, s, e);
+        if (null == s || s < 0) s = 0;
+        if (null == e || e > v.length) e = v.length;
+        var n = new u8(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    var fill = function(v, n, s, e) {
+        if (u8.prototype.fill) return u8.prototype.fill.call(v, n, s, e);
+        if (null == s || s < 0) s = 0;
+        if (null == e || e > v.length) e = v.length;
+        for(; s < e; ++s)v[s] = n;
+        return v;
+    };
+    var cpw = function(v, t, s, e) {
+        if (u8.prototype.copyWithin) return u8.prototype.copyWithin.call(v, t, s, e);
+        if (null == s || s < 0) s = 0;
+        if (null == e || e > v.length) e = v.length;
+        while(s < e)v[t++] = v[s++];
+    };
+    var ec = [
+        'invalid zstd data',
+        'window size too large (>2046MB)',
+        'invalid block type',
+        'FSE accuracy too high',
+        'match distance too far back',
+        'unexpected EOF'
+    ];
+    var esm_err = function(ind, msg, nt) {
+        var e = new Error(msg || ec[ind]);
+        e.code = ind;
+        if (Error.captureStackTrace) Error.captureStackTrace(e, esm_err);
+        if (!nt) throw e;
+        return e;
+    };
+    var rb = function(d, b, n) {
+        var i = 0, o = 0;
+        for(; i < n; ++i)o |= d[b++] << (i << 3);
+        return o;
+    };
+    var b4 = function(d, b) {
+        return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    var rzfh = function(dat, w) {
+        var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+        if (0x2FB528 == n3 && 253 == dat[3]) {
+            var flg = dat[4];
+            var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = 3 & flg, fcf = flg >> 6;
+            if (8 & flg) esm_err(0);
+            var bt = 6 - ss;
+            var db = 3 == df ? 4 : df;
+            var di = rb(dat, bt, db);
+            bt += db;
+            var fsb = fcf ? 1 << fcf : ss;
+            var fss = rb(dat, bt, fsb) + (1 == fcf && 256);
+            var ws = fss;
+            if (!ss) {
+                var wb = 1 << 10 + (dat[5] >> 3);
+                ws = wb + (wb >> 3) * (7 & dat[5]);
+            }
+            if (ws > 2145386496) esm_err(1);
+            var buf = new u8((1 == w ? fss || ws : w ? 0 : ws) + 12);
+            buf[0] = 1, buf[4] = 4, buf[8] = 8;
+            return {
+                b: bt + fsb,
+                y: 0,
+                l: 0,
+                d: di,
+                w: w && 1 != w ? w : buf.subarray(12),
+                e: ws,
+                o: new i32(buf.buffer, 0, 3),
+                u: fss,
+                c: cc,
+                m: Math.min(131072, ws)
+            };
+        }
+        if ((n3 >> 4 | dat[3] << 20) == 0x184D2A5) return b4(dat, 4) + 8;
+        esm_err(0);
+    };
+    var msb = function(val) {
+        var bits = 0;
+        for(; 1 << bits <= val; ++bits);
+        return bits - 1;
+    };
+    var rfse = function(dat, bt, mal) {
+        var tpos = (bt << 3) + 4;
+        var al = (15 & dat[bt]) + 5;
+        if (al > mal) esm_err(3);
+        var sz = 1 << al;
+        var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+        var buf = new esm_ab(512 + (sz << 2));
+        var freq = new i16(buf, 0, 256);
+        var dstate = new u16(buf, 0, 256);
+        var nstate = new u16(buf, 512, sz);
+        var bb1 = 512 + (sz << 1);
+        var syms = new u8(buf, bb1, sz);
+        var nbits = new u8(buf, bb1 + sz);
+        while(sym < 255 && probs > 0){
+            var bits = msb(probs + 1);
+            var cbt = tpos >> 3;
+            var msk = (1 << bits + 1) - 1;
+            var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (7 & tpos) & msk;
+            var msk1fb = (1 << bits) - 1;
+            var msv = msk - probs - 1;
+            var sval = val & msk1fb;
+            if (sval < msv) tpos += bits, val = sval;
+            else {
+                tpos += bits + 1;
+                if (val > msk1fb) val -= msv;
+            }
+            freq[++sym] = --val;
+            if (-1 == val) {
+                probs += val;
+                syms[--ht] = sym;
+            } else probs -= val;
+            if (!val) do {
+                var rbt = tpos >> 3;
+                re = (dat[rbt] | dat[rbt + 1] << 8) >> (7 & tpos) & 3;
+                tpos += 2;
+                sym += re;
+            }while (3 == re);
+        }
+        if (sym > 255 || probs) esm_err(0);
+        var sympos = 0;
+        var sstep = (sz >> 1) + (sz >> 3) + 3;
+        var smask = sz - 1;
+        for(var s = 0; s <= sym; ++s){
+            var sf = freq[s];
+            if (sf < 1) {
+                dstate[s] = -sf;
+                continue;
+            }
+            for(i = 0; i < sf; ++i){
+                syms[sympos] = s;
+                do sympos = sympos + sstep & smask;
+                while (sympos >= ht);
+            }
+        }
+        if (sympos) esm_err(0);
+        for(i = 0; i < sz; ++i){
+            var ns = dstate[syms[i]]++;
+            var nb = nbits[i] = al - msb(ns);
+            nstate[i] = (ns << nb) - sz;
+        }
+        return [
+            tpos + 7 >> 3,
+            {
+                b: al,
+                s: syms,
+                n: nbits,
+                t: nstate
+            }
+        ];
+    };
+    var rhu = function(dat, bt) {
+        var i = 0, wc = -1;
+        var buf = new u8(292), hb = dat[bt];
+        var hw = buf.subarray(0, 256);
+        var rc = buf.subarray(256, 268);
+        var ri = new u16(buf.buffer, 268);
+        if (hb < 128) {
+            var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+            bt += hb;
+            var epos = ebt << 3;
+            var lb = dat[bt];
+            if (!lb) esm_err(0);
+            var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+            var fpos = (++bt << 3) - 8 + msb(lb);
+            for(;;){
+                fpos -= btr1;
+                if (fpos < epos) break;
+                var cbt = fpos >> 3;
+                st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (7 & fpos) & (1 << btr1) - 1;
+                hw[++wc] = fdt.s[st1];
+                fpos -= btr2;
+                if (fpos < epos) break;
+                cbt = fpos >> 3;
+                st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (7 & fpos) & (1 << btr2) - 1;
+                hw[++wc] = fdt.s[st2];
+                btr1 = fdt.n[st1];
+                st1 = fdt.t[st1];
+                btr2 = fdt.n[st2];
+                st2 = fdt.t[st2];
+            }
+            if (++wc > 255) esm_err(0);
+        } else {
+            wc = hb - 127;
+            for(; i < wc; i += 2){
+                var byte = dat[++bt];
+                hw[i] = byte >> 4;
+                hw[i + 1] = 15 & byte;
+            }
+            ++bt;
+        }
+        var wes = 0;
+        for(i = 0; i < wc; ++i){
+            var wt = hw[i];
+            if (wt > 11) esm_err(0);
+            wes += wt && 1 << wt - 1;
+        }
+        var mb = msb(wes) + 1;
+        var ts = 1 << mb;
+        var rem = ts - wes;
+        if (rem & rem - 1) esm_err(0);
+        hw[wc++] = msb(rem) + 1;
+        for(i = 0; i < wc; ++i){
+            var wt = hw[i];
+            ++rc[hw[i] = wt && mb + 1 - wt];
+        }
+        var hbuf = new u8(ts << 1);
+        var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+        ri[mb] = 0;
+        for(i = mb; i > 0; --i){
+            var pv = ri[i];
+            fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+        }
+        if (ri[0] != ts) esm_err(0);
+        for(i = 0; i < wc; ++i){
+            var bits = hw[i];
+            if (bits) {
+                var code = ri[bits];
+                fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+            }
+        }
+        return [
+            bt,
+            {
+                n: nb,
+                b: mb,
+                s: syms
+            }
+        ];
+    };
+    var dllt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
+        81,
+        16,
+        99,
+        140,
+        49,
+        198,
+        24,
+        99,
+        12,
+        33,
+        196,
+        24,
+        99,
+        102,
+        102,
+        134,
+        70,
+        146,
+        4
+    ]), 0, 6)[1];
+    var dmlt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
+        33,
+        20,
+        196,
+        24,
+        99,
+        140,
+        33,
+        132,
+        16,
+        66,
+        8,
+        33,
+        132,
+        16,
+        66,
+        8,
+        33,
+        68,
+        68,
+        68,
+        68,
+        68,
+        68,
+        68,
+        68,
+        36,
+        9
+    ]), 0, 6)[1];
+    var doct = /*#__PURE__ */ rfse(/*#__PURE__*/ new u8([
+        32,
+        132,
+        16,
+        66,
+        102,
+        70,
+        68,
+        68,
+        68,
+        68,
+        36,
+        73,
+        2
+    ]), 0, 5)[1];
+    var b2bl = function(b, s) {
+        var len = b.length, bl = new i32(len);
+        for(var i = 0; i < len; ++i){
+            bl[i] = s;
+            s += 1 << b[i];
+        }
+        return bl;
+    };
+    var llb = /*#__PURE__ */ new u8(/*#__PURE__ */ new i32([
+        0,
+        0,
+        0,
+        0,
+        16843009,
+        50528770,
+        134678020,
+        202050057,
+        269422093
+    ]).buffer, 0, 36);
+    var llbl = /*#__PURE__ */ b2bl(llb, 0);
+    var mlb = /*#__PURE__ */ new u8(/*#__PURE__ */ new i32([
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        16843009,
+        50528770,
+        117769220,
+        185207048,
+        252579084,
+        16
+    ]).buffer, 0, 53);
+    var mlbl = /*#__PURE__ */ b2bl(mlb, 3);
+    var dhu = function(dat, out, hu) {
+        var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+        if (!lb) esm_err(0);
+        var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+        for(; pos > eb && i < ss;){
+            var cbt = pos >> 3;
+            var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (7 & pos);
+            st = (st << btr | val) & msk;
+            out[++i] = hu.s[st];
+            pos -= btr = hu.n[st];
+        }
+        if (pos != eb || i + 1 != ss) esm_err(0);
+    };
+    var dhu4 = function(dat, out, hu) {
+        var bt = 6;
+        var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+        dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+        dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+        dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+        dhu(dat.subarray(bt), out.subarray(sz3), hu);
+    };
+    var rzb = function(dat, st, out) {
+        var _a;
+        var bt = st.b;
+        var b0 = dat[bt], btype = b0 >> 1 & 3;
+        st.l = 1 & b0;
+        var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+        var ebt = (bt += 3) + sz;
+        if (1 == btype) {
+            if (bt >= dat.length) return;
+            st.b = bt + 1;
+            if (out) {
+                fill(out, dat[bt], st.y, st.y += sz);
+                return out;
+            }
+            return fill(new u8(sz), dat[bt]);
+        }
+        if (ebt > dat.length) return;
+        if (0 == btype) {
+            st.b = ebt;
+            if (out) {
+                out.set(dat.subarray(bt, ebt), st.y);
+                st.y += sz;
+                return out;
+            }
+            return slc(dat, bt, ebt);
+        }
+        if (2 == btype) {
+            var b3 = dat[bt], lbt = 3 & b3, sf = b3 >> 2 & 3;
+            var lss = b3 >> 4, lcs = 0, s4 = 0;
+            if (lbt < 2) {
+                if (1 & sf) lss |= dat[++bt] << 4 | (2 & sf && dat[++bt] << 12);
+                else lss = b3 >> 3;
+            } else {
+                s4 = sf;
+                if (sf < 2) lss |= (63 & dat[++bt]) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+                else if (2 == sf) lss |= dat[++bt] << 4 | (3 & dat[++bt]) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+                else lss |= dat[++bt] << 4 | (63 & dat[++bt]) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+            }
+            ++bt;
+            var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+            var spl = buf.length - lss;
+            if (0 == lbt) buf.set(dat.subarray(bt, bt += lss), spl);
+            else if (1 == lbt) fill(buf, dat[bt++], spl);
+            else {
+                var hu = st.h;
+                if (2 == lbt) {
+                    var hud = rhu(dat, bt);
+                    lcs += bt - (bt = hud[0]);
+                    st.h = hu = hud[1];
+                } else if (!hu) esm_err(0);
+                (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+            }
+            var ns = dat[bt++];
+            if (ns) {
+                if (255 == ns) ns = (dat[bt++] | dat[bt++] << 8) + 0x7F00;
+                else if (ns > 127) ns = ns - 128 << 8 | dat[bt++];
+                var scm = dat[bt++];
+                if (3 & scm) esm_err(0);
+                var dts = [
+                    dmlt,
+                    doct,
+                    dllt
+                ];
+                for(var i = 2; i > -1; --i){
+                    var md = scm >> (i << 1) + 2 & 3;
+                    if (1 == md) {
+                        var rbuf = new u8([
+                            0,
+                            0,
+                            dat[bt++]
+                        ]);
+                        dts[i] = {
+                            s: rbuf.subarray(2, 3),
+                            n: rbuf.subarray(0, 1),
+                            t: new u16(rbuf.buffer, 0, 1),
+                            b: 0
+                        };
+                    } else if (2 == md) _a = rfse(dat, bt, 9 - (1 & i)), bt = _a[0], dts[i] = _a[1];
+                    else if (3 == md) {
+                        if (!st.t) esm_err(0);
+                        dts[i] = st.t[i];
+                    }
+                }
+                var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+                var lb = dat[ebt - 1];
+                if (!lb) esm_err(0);
+                var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+                var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << llt.b) - 1;
+                cbt = (spos -= oct.b) >> 3;
+                var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << oct.b) - 1;
+                cbt = (spos -= mlt.b) >> 3;
+                var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << mlt.b) - 1;
+                for(++ns; --ns;){
+                    var llc = llt.s[lst];
+                    var lbtr = llt.n[lst];
+                    var mlc = mlt.s[mst];
+                    var mbtr = mlt.n[mst];
+                    var ofc = oct.s[ost];
+                    var obtr = oct.n[ost];
+                    cbt = (spos -= ofc) >> 3;
+                    var ofp = 1 << ofc;
+                    var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (7 & spos) & ofp - 1);
+                    cbt = (spos -= mlb[mlc]) >> 3;
+                    var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (7 & spos) & (1 << mlb[mlc]) - 1);
+                    cbt = (spos -= llb[llc]) >> 3;
+                    var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (7 & spos) & (1 << llb[llc]) - 1);
+                    cbt = (spos -= lbtr) >> 3;
+                    lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << lbtr) - 1);
+                    cbt = (spos -= mbtr) >> 3;
+                    mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << mbtr) - 1);
+                    cbt = (spos -= obtr) >> 3;
+                    ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (7 & spos) & (1 << obtr) - 1);
+                    if (off > 3) {
+                        st.o[2] = st.o[1];
+                        st.o[1] = st.o[0];
+                        st.o[0] = off -= 3;
+                    } else {
+                        var idx = off - (0 != ll);
+                        if (idx) {
+                            off = 3 == idx ? st.o[0] - 1 : st.o[idx];
+                            if (idx > 1) st.o[2] = st.o[1];
+                            st.o[1] = st.o[0];
+                            st.o[0] = off;
+                        } else off = st.o[0];
+                    }
+                    for(var i = 0; i < ll; ++i)buf[oubt + i] = buf[spl + i];
+                    oubt += ll, spl += ll;
+                    var stin = oubt - off;
+                    if (stin < 0) {
+                        var len = -stin;
+                        var bs = st.e + stin;
+                        if (len > ml) len = ml;
+                        for(var i = 0; i < len; ++i)buf[oubt + i] = st.w[bs + i];
+                        oubt += len, ml -= len, stin = 0;
+                    }
+                    for(var i = 0; i < ml; ++i)buf[oubt + i] = buf[stin + i];
+                    oubt += ml;
+                }
+                if (oubt != spl) while(spl < buf.length)buf[oubt++] = buf[spl++];
+                else oubt = buf.length;
+                if (out) st.y += oubt;
+                else buf = slc(buf, 0, oubt);
+            } else if (out) {
+                st.y += lss;
+                if (spl) for(var i = 0; i < lss; ++i)buf[i] = buf[spl + i];
+            } else if (spl) buf = slc(buf, spl);
+            st.b = ebt;
+            return buf;
+        }
+        esm_err(2);
+    };
+    var cct = function(bufs, ol) {
+        if (1 == bufs.length) return bufs[0];
+        var buf = new u8(ol);
+        for(var i = 0, b = 0; i < bufs.length; ++i){
+            var chk = bufs[i];
+            buf.set(chk, b);
+            b += chk.length;
+        }
+        return buf;
+    };
+    function decompress(dat, buf) {
+        var bufs = [], nb = +!buf;
+        var bt = 0, ol = 0;
+        for(; dat.length;){
+            var st = rzfh(dat, nb || buf);
+            if ('object' == typeof st) {
+                if (nb) {
+                    buf = null;
+                    if (st.w.length == st.u) {
+                        bufs.push(buf = st.w);
+                        ol += st.u;
+                    }
+                } else {
+                    bufs.push(buf);
+                    st.e = 0;
+                }
+                for(; !st.l;){
+                    var blk = rzb(dat, st, buf);
+                    if (!blk) esm_err(5);
+                    if (buf) st.e = st.y;
+                    else {
+                        bufs.push(blk);
+                        ol += blk.length;
+                        cpw(st.w, 0, blk.length);
+                        st.w.set(blk, st.w.length - blk.length);
+                    }
+                }
+                bt = st.b + 4 * st.c;
+            } else bt = st;
+            dat = dat.subarray(bt);
+        }
+        return cct(bufs, ol);
+    }
     const DouyinGetMusicParamsSchema = ActionCommonParamsSchema.extend({
         keyword: classic_schemas_string().optional(),
         count: classic_schemas_number().optional()
@@ -31597,8 +32151,11 @@ var __webpack_exports__ = {};
             browser_version: userAgent,
             browser_online: "true",
             timezone_name: "Asia/Shanghai",
-            support_h265: "1"
+            support_h265: "1",
+            a_bogus: ""
         };
+        const authQueryBefore = new URLSearchParams(authorizationParams).toString();
+        authorizationParams.a_bogus = douyinGetMusic_getABogus(`https://creator.douyin.com/web/api/media/aweme/search/post/auth/?${authQueryBefore}`, {}, userAgent);
         const authorizationQueryString = new URLSearchParams(authorizationParams).toString();
         const authorization = await http.api({
             method: "get",
@@ -31617,20 +32174,36 @@ var __webpack_exports__ = {};
             total: 0
         });
         console.log("抖音获取音乐权限:", authorization);
-        const res = await http.api({
+        const musicRes = await http.api({
             method: "get",
             url: `https://tsearch.amemv.com/openapi/aweme/v1/music/search/?${queryString}`,
             headers: {
-                ...headers,
+                Accept: "application/json, text/plain, */*",
+                "Accept-Language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+                "cache-control": "no-cache",
+                pragma: "no-cache",
+                priority: "u=1, i",
+                origin: "https://creator.douyin.com",
+                referer: "https://creator.douyin.com/",
+                "sec-ch-ua": params.extraParam?.browserInfo?.["sec-ch-ua"] || "",
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": params.extraParam?.browserInfo?.["sec-ch-ua-platform"] || "",
+                "sec-fetch-dest": "empty",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-site": "cross-site",
+                "user-agent": userAgent,
                 "agw-auth": authorization?.signature || "",
-                "X-secsdk-csrf-token": csrfToken
-            }
+                "openapi-omit-shark": "1"
+            },
+            responseType: "arraybuffer"
         }, {
             retries: 3,
             retryDelay: 20,
             timeout: 3000
         });
-        console.log("抖音获取音乐响应:", res);
+        const decompressed = decompress(new Uint8Array(musicRes));
+        const res = JSON.parse(Buffer.from(decompressed).toString("utf-8"));
+        console.log("抖音获取音乐响应:", JSON.stringify(res));
         const isSuccess = 0 === res.status_code;
         const message = `抖音获取音乐${isSuccess ? "成功" : `失败，原因：${res.status_msg}`}${_task.debug ? ` ${http.proxyInfo}` : ""}`;
         const data = isSuccess ? {