@sqaitech/mcp 0.30.10

package/dist/251.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! For license information please see jimp.js.LICENSE.txt */

package/dist/328.js

@@ -0,0 +1,456 @@
+exports.ids = [
+    "328"
+];
+exports.modules = {
+    "../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var once = __webpack_require__("../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js");
+        var noop = function() {};
+        var isRequest = function(stream) {
+            return stream.setHeader && 'function' == typeof stream.abort;
+        };
+        var isChildProcess = function(stream) {
+            return stream.stdio && Array.isArray(stream.stdio) && 3 === stream.stdio.length;
+        };
+        var eos = function(stream, opts, callback) {
+            if ('function' == typeof opts) return eos(stream, null, opts);
+            if (!opts) opts = {};
+            callback = once(callback || noop);
+            var ws = stream._writableState;
+            var rs = stream._readableState;
+            var readable = opts.readable || false !== opts.readable && stream.readable;
+            var writable = opts.writable || false !== opts.writable && stream.writable;
+            var cancelled = false;
+            var onlegacyfinish = function() {
+                if (!stream.writable) onfinish();
+            };
+            var onfinish = function() {
+                writable = false;
+                if (!readable) callback.call(stream);
+            };
+            var onend = function() {
+                readable = false;
+                if (!writable) callback.call(stream);
+            };
+            var onexit = function(exitCode) {
+                callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+            };
+            var onerror = function(err) {
+                callback.call(stream, err);
+            };
+            var onclose = function() {
+                process.nextTick(onclosenexttick);
+            };
+            var onclosenexttick = function() {
+                if (cancelled) return;
+                if (readable && !(rs && rs.ended && !rs.destroyed)) return callback.call(stream, new Error('premature close'));
+                if (writable && !(ws && ws.ended && !ws.destroyed)) return callback.call(stream, new Error('premature close'));
+            };
+            var onrequest = function() {
+                stream.req.on('finish', onfinish);
+            };
+            if (isRequest(stream)) {
+                stream.on('complete', onfinish);
+                stream.on('abort', onclose);
+                if (stream.req) onrequest();
+                else stream.on('request', onrequest);
+            } else if (writable && !ws) {
+                stream.on('end', onlegacyfinish);
+                stream.on('close', onlegacyfinish);
+            }
+            if (isChildProcess(stream)) stream.on('exit', onexit);
+            stream.on('end', onend);
+            stream.on('finish', onfinish);
+            if (false !== opts.error) stream.on('error', onerror);
+            stream.on('close', onclose);
+            return function() {
+                cancelled = true;
+                stream.removeListener('complete', onfinish);
+                stream.removeListener('abort', onclose);
+                stream.removeListener('request', onrequest);
+                if (stream.req) stream.req.removeListener('finish', onfinish);
+                stream.removeListener('end', onlegacyfinish);
+                stream.removeListener('close', onlegacyfinish);
+                stream.removeListener('finish', onfinish);
+                stream.removeListener('exit', onexit);
+                stream.removeListener('end', onend);
+                stream.removeListener('error', onerror);
+                stream.removeListener('close', onclose);
+            };
+        };
+        module.exports = eos;
+    },
+    "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var once = __webpack_require__("../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js");
+        var eos = __webpack_require__("../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js");
+        var fs;
+        try {
+            fs = __webpack_require__("fs");
+        } catch (e) {}
+        var noop = function() {};
+        var ancient = /^v?\.0/.test(process.version);
+        var isFn = function(fn) {
+            return 'function' == typeof fn;
+        };
+        var isFS = function(stream) {
+            if (!ancient) return false;
+            if (!fs) return false;
+            return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+        };
+        var isRequest = function(stream) {
+            return stream.setHeader && isFn(stream.abort);
+        };
+        var destroyer = function(stream, reading, writing, callback) {
+            callback = once(callback);
+            var closed = false;
+            stream.on('close', function() {
+                closed = true;
+            });
+            eos(stream, {
+                readable: reading,
+                writable: writing
+            }, function(err) {
+                if (err) return callback(err);
+                closed = true;
+                callback();
+            });
+            var destroyed = false;
+            return function(err) {
+                if (closed) return;
+                if (destroyed) return;
+                destroyed = true;
+                if (isFS(stream)) return stream.close(noop);
+                if (isRequest(stream)) return stream.abort();
+                if (isFn(stream.destroy)) return stream.destroy();
+                callback(err || new Error('stream was destroyed'));
+            };
+        };
+        var call = function(fn) {
+            fn();
+        };
+        var pipe = function(from, to) {
+            return from.pipe(to);
+        };
+        var pump = function() {
+            var streams = Array.prototype.slice.call(arguments);
+            var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+            if (Array.isArray(streams[0])) streams = streams[0];
+            if (streams.length < 2) throw new Error('pump requires two streams per minimum');
+            var error;
+            var destroys = streams.map(function(stream, i) {
+                var reading = i < streams.length - 1;
+                var writing = i > 0;
+                return destroyer(stream, reading, writing, function(err) {
+                    if (!error) error = err;
+                    if (err) destroys.forEach(call);
+                    if (reading) return;
+                    destroys.forEach(call);
+                    callback(error);
+                });
+            });
+            return streams.reduce(pipe);
+        };
+        module.exports = pump;
+    },
+    "../../node_modules/.pnpm/tar-fs@3.0.8/node_modules/tar-fs/index.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        const tar = __webpack_require__("../../node_modules/.pnpm/tar-stream@3.1.7/node_modules/tar-stream/index.js");
+        const pump = __webpack_require__("../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js");
+        const fs = __webpack_require__("fs");
+        const path = __webpack_require__("path");
+        const win32 = 'win32' === (global.Bare?.platform || process.platform);
+        exports1.pack = function(cwd, opts) {
+            if (!cwd) cwd = '.';
+            if (!opts) opts = {};
+            const xfs = opts.fs || fs;
+            const ignore = opts.ignore || opts.filter || noop;
+            const mapStream = opts.mapStream || echo;
+            const statNext = statAll(xfs, opts.dereference ? xfs.stat : xfs.lstat, cwd, ignore, opts.entries, opts.sort);
+            const strict = false !== opts.strict;
+            const umask = 'number' == typeof opts.umask ? ~opts.umask : ~processUmask();
+            const pack = opts.pack || tar.pack();
+            const finish = opts.finish || noop;
+            let map = opts.map || noop;
+            let dmode = 'number' == typeof opts.dmode ? opts.dmode : 0;
+            let fmode = 'number' == typeof opts.fmode ? opts.fmode : 0;
+            if (opts.strip) map = strip(map, opts.strip);
+            if (opts.readable) {
+                dmode |= parseInt(555, 8);
+                fmode |= parseInt(444, 8);
+            }
+            if (opts.writable) {
+                dmode |= parseInt(333, 8);
+                fmode |= parseInt(222, 8);
+            }
+            onnextentry();
+            function onsymlink(filename, header) {
+                xfs.readlink(path.join(cwd, filename), function(err, linkname) {
+                    if (err) return pack.destroy(err);
+                    header.linkname = normalize(linkname);
+                    pack.entry(header, onnextentry);
+                });
+            }
+            function onstat(err, filename, stat) {
+                if (pack.destroyed) return;
+                if (err) return pack.destroy(err);
+                if (!filename) {
+                    if (false !== opts.finalize) pack.finalize();
+                    return finish(pack);
+                }
+                if (stat.isSocket()) return onnextentry();
+                let header = {
+                    name: normalize(filename),
+                    mode: (stat.mode | (stat.isDirectory() ? dmode : fmode)) & umask,
+                    mtime: stat.mtime,
+                    size: stat.size,
+                    type: 'file',
+                    uid: stat.uid,
+                    gid: stat.gid
+                };
+                if (stat.isDirectory()) {
+                    header.size = 0;
+                    header.type = 'directory';
+                    header = map(header) || header;
+                    return pack.entry(header, onnextentry);
+                }
+                if (stat.isSymbolicLink()) {
+                    header.size = 0;
+                    header.type = 'symlink';
+                    header = map(header) || header;
+                    return onsymlink(filename, header);
+                }
+                header = map(header) || header;
+                if (!stat.isFile()) {
+                    if (strict) return pack.destroy(new Error('unsupported type for ' + filename));
+                    return onnextentry();
+                }
+                const entry = pack.entry(header, onnextentry);
+                const rs = mapStream(xfs.createReadStream(path.join(cwd, filename), {
+                    start: 0,
+                    end: header.size > 0 ? header.size - 1 : header.size
+                }), header);
+                rs.on('error', function(err) {
+                    entry.destroy(err);
+                });
+                pump(rs, entry);
+            }
+            function onnextentry(err) {
+                if (err) return pack.destroy(err);
+                statNext(onstat);
+            }
+            return pack;
+        };
+        function head(list) {
+            return list.length ? list[list.length - 1] : null;
+        }
+        function processGetuid() {
+            return process.getuid ? process.getuid() : -1;
+        }
+        function processUmask() {
+            return process.umask ? process.umask() : 0;
+        }
+        exports1.extract = function(cwd, opts) {
+            if (!cwd) cwd = '.';
+            if (!opts) opts = {};
+            cwd = path.resolve(cwd);
+            const xfs = opts.fs || fs;
+            const ignore = opts.ignore || opts.filter || noop;
+            const mapStream = opts.mapStream || echo;
+            const own = false !== opts.chown && !win32 && 0 === processGetuid();
+            const extract = opts.extract || tar.extract();
+            const stack = [];
+            const now = new Date();
+            const umask = 'number' == typeof opts.umask ? ~opts.umask : ~processUmask();
+            const strict = false !== opts.strict;
+            let map = opts.map || noop;
+            let dmode = 'number' == typeof opts.dmode ? opts.dmode : 0;
+            let fmode = 'number' == typeof opts.fmode ? opts.fmode : 0;
+            if (opts.strip) map = strip(map, opts.strip);
+            if (opts.readable) {
+                dmode |= parseInt(555, 8);
+                fmode |= parseInt(444, 8);
+            }
+            if (opts.writable) {
+                dmode |= parseInt(333, 8);
+                fmode |= parseInt(222, 8);
+            }
+            extract.on('entry', onentry);
+            if (opts.finish) extract.on('finish', opts.finish);
+            return extract;
+            function onentry(header, stream, next) {
+                header = map(header) || header;
+                header.name = normalize(header.name);
+                const name = path.join(cwd, path.join('/', header.name));
+                if (ignore(name, header)) {
+                    stream.resume();
+                    return next();
+                }
+                if ('directory' === header.type) {
+                    stack.push([
+                        name,
+                        header.mtime
+                    ]);
+                    return mkdirfix(name, {
+                        fs: xfs,
+                        own,
+                        uid: header.uid,
+                        gid: header.gid,
+                        mode: header.mode
+                    }, stat);
+                }
+                const dir = path.dirname(name);
+                validate(xfs, dir, path.join(cwd, '.'), function(err, valid) {
+                    if (err) return next(err);
+                    if (!valid) return next(new Error(dir + ' is not a valid path'));
+                    mkdirfix(dir, {
+                        fs: xfs,
+                        own,
+                        uid: header.uid,
+                        gid: header.gid,
+                        mode: 493
+                    }, function(err) {
+                        if (err) return next(err);
+                        switch(header.type){
+                            case 'file':
+                                return onfile();
+                            case 'link':
+                                return onlink();
+                            case 'symlink':
+                                return onsymlink();
+                        }
+                        if (strict) return next(new Error('unsupported type for ' + name + ' (' + header.type + ')'));
+                        stream.resume();
+                        next();
+                    });
+                });
+                function stat(err) {
+                    if (err) return next(err);
+                    utimes(name, header, function(err) {
+                        if (err) return next(err);
+                        if (win32) return next();
+                        chperm(name, header, next);
+                    });
+                }
+                function onsymlink() {
+                    if (win32) return next();
+                    xfs.unlink(name, function() {
+                        const dst = path.resolve(path.dirname(name), header.linkname);
+                        if (!inCwd(dst)) return next(new Error(name + ' is not a valid symlink'));
+                        xfs.symlink(header.linkname, name, stat);
+                    });
+                }
+                function onlink() {
+                    if (win32) return next();
+                    xfs.unlink(name, function() {
+                        const dst = path.join(cwd, path.join('/', header.linkname));
+                        xfs.link(dst, name, function(err) {
+                            if (err && 'EPERM' === err.code && opts.hardlinkAsFilesFallback) {
+                                stream = xfs.createReadStream(dst);
+                                return onfile();
+                            }
+                            stat(err);
+                        });
+                    });
+                }
+                function inCwd(dst) {
+                    return dst.startsWith(cwd);
+                }
+                function onfile() {
+                    const ws = xfs.createWriteStream(name);
+                    const rs = mapStream(stream, header);
+                    ws.on('error', function(err) {
+                        rs.destroy(err);
+                    });
+                    pump(rs, ws, function(err) {
+                        if (err) return next(err);
+                        ws.on('close', stat);
+                    });
+                }
+            }
+            function utimesParent(name, cb) {
+                let top;
+                while((top = head(stack)) && name.slice(0, top[0].length) !== top[0])stack.pop();
+                if (!top) return cb();
+                xfs.utimes(top[0], now, top[1], cb);
+            }
+            function utimes(name, header, cb) {
+                if (false === opts.utimes) return cb();
+                if ('directory' === header.type) return xfs.utimes(name, now, header.mtime, cb);
+                if ('symlink' === header.type) return utimesParent(name, cb);
+                xfs.utimes(name, now, header.mtime, function(err) {
+                    if (err) return cb(err);
+                    utimesParent(name, cb);
+                });
+            }
+            function chperm(name, header, cb) {
+                const link = 'symlink' === header.type;
+                const chmod = link ? xfs.lchmod : xfs.chmod;
+                const chown = link ? xfs.lchown : xfs.chown;
+                if (!chmod) return cb();
+                const mode = (header.mode | ('directory' === header.type ? dmode : fmode)) & umask;
+                if (chown && own) chown.call(xfs, name, header.uid, header.gid, onchown);
+                else onchown(null);
+                function onchown(err) {
+                    if (err) return cb(err);
+                    if (!chmod) return cb();
+                    chmod.call(xfs, name, mode, cb);
+                }
+            }
+            function mkdirfix(name, opts, cb) {
+                xfs.stat(name, function(err) {
+                    if (!err) return cb(null);
+                    if ('ENOENT' !== err.code) return cb(err);
+                    xfs.mkdir(name, {
+                        mode: opts.mode,
+                        recursive: true
+                    }, function(err, made) {
+                        if (err) return cb(err);
+                        chperm(name, opts, cb);
+                    });
+                });
+            }
+        };
+        function validate(fs, name, root, cb) {
+            if (name === root) return cb(null, true);
+            fs.lstat(name, function(err, st) {
+                if (err && 'ENOENT' === err.code) return validate(fs, path.join(name, '..'), root, cb);
+                if (err) return cb(err);
+                cb(null, st.isDirectory());
+            });
+        }
+        function noop() {}
+        function echo(name) {
+            return name;
+        }
+        function normalize(name) {
+            return win32 ? name.replace(/\\/g, '/').replace(/[:?<>|]/g, '_') : name;
+        }
+        function statAll(fs, stat, cwd, ignore, entries, sort) {
+            if (!entries) entries = [
+                '.'
+            ];
+            const queue = entries.slice(0);
+            return function(callback) {
+                if (!queue.length) return callback(null);
+                const next = queue.shift();
+                const nextAbs = path.join(cwd, next);
+                stat.call(fs, nextAbs, function(err, stat) {
+                    if (err) return callback(-1 === entries.indexOf(next) && 'ENOENT' === err.code ? null : err);
+                    if (!stat.isDirectory()) return callback(null, next, stat);
+                    fs.readdir(nextAbs, function(err, files) {
+                        if (err) return callback(err);
+                        if (sort) files.sort();
+                        for(let i = 0; i < files.length; i++)if (!ignore(path.join(cwd, next, files[i]))) queue.push(path.join(next, files[i]));
+                        callback(null, next, stat);
+                    });
+                });
+            };
+        }
+        function strip(map, level) {
+            return function(header) {
+                header.name = header.name.split('/').slice(level).join('/');
+                const linkname = header.linkname;
+                if (linkname && ('link' === header.type || path.isAbsolute(linkname))) header.linkname = linkname.split('/').slice(level).join('/');
+                return map(header);
+            };
+        }
+    }
+};

package/dist/663.js

@@ -0,0 +1,105 @@
+/*! For license information please see 663.js.LICENSE.txt */
+exports.ids = [
+    "663"
+];
+exports.modules = {
+    "../../node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        /*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */ if (!globalThis.DOMException) try {
+            const { MessageChannel } = __webpack_require__("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer();
+            port.postMessage(ab, [
+                ab,
+                ab
+            ]);
+        } catch (err) {
+            'DOMException' === err.constructor.name && (globalThis.DOMException = err.constructor);
+        }
+        module.exports = globalThis.DOMException;
+    },
+    "../../node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/fileFromPath.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            fileFromPath: ()=>fileFromPath
+        });
+        var external_fs_ = __webpack_require__("fs");
+        var external_path_ = __webpack_require__("path");
+        var node_domexception = __webpack_require__("../../node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js");
+        var File = __webpack_require__("../../node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/File.js");
+        const getType = (value)=>Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+        function isPlainObject(value) {
+            if ("object" !== getType(value)) return false;
+            const pp = Object.getPrototypeOf(value);
+            if (null == pp) return true;
+            const Ctor = pp.constructor && pp.constructor.toString();
+            return Ctor === Object.toString();
+        }
+        const esm_isPlainObject = isPlainObject;
+        __webpack_require__("../../node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isFile.js");
+        var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+            if ("m" === kind) throw new TypeError("Private method is not writable");
+            if ("a" === kind && !f) throw new TypeError("Private accessor was defined without a setter");
+            if ("function" == typeof state ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+            return "a" === kind ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+        };
+        var __classPrivateFieldGet = function(receiver, state, kind, f) {
+            if ("a" === kind && !f) throw new TypeError("Private accessor was defined without a getter");
+            if ("function" == typeof state ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+            return "m" === kind ? f : "a" === kind ? f.call(receiver) : f ? f.value : state.get(receiver);
+        };
+        var _FileFromPath_path, _FileFromPath_start;
+        const MESSAGE = "The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.";
+        class FileFromPath {
+            constructor(input){
+                _FileFromPath_path.set(this, void 0);
+                _FileFromPath_start.set(this, void 0);
+                __classPrivateFieldSet(this, _FileFromPath_path, input.path, "f");
+                __classPrivateFieldSet(this, _FileFromPath_start, input.start || 0, "f");
+                this.name = (0, external_path_.basename)(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+                this.size = input.size;
+                this.lastModified = input.lastModified;
+            }
+            slice(start, end) {
+                return new FileFromPath({
+                    path: __classPrivateFieldGet(this, _FileFromPath_path, "f"),
+                    lastModified: this.lastModified,
+                    size: end - start,
+                    start
+                });
+            }
+            async *stream() {
+                const { mtimeMs } = await external_fs_.promises.stat(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+                if (mtimeMs > this.lastModified) throw new node_domexception(MESSAGE, "NotReadableError");
+                if (this.size) yield* (0, external_fs_.createReadStream)(__classPrivateFieldGet(this, _FileFromPath_path, "f"), {
+                    start: __classPrivateFieldGet(this, _FileFromPath_start, "f"),
+                    end: __classPrivateFieldGet(this, _FileFromPath_start, "f") + this.size - 1
+                });
+            }
+            get [(_FileFromPath_path = new WeakMap(), _FileFromPath_start = new WeakMap(), Symbol.toStringTag)]() {
+                return "File";
+            }
+        }
+        function createFileFromPath(path, { mtimeMs, size }, filenameOrOptions, options = {}) {
+            let filename;
+            if (esm_isPlainObject(filenameOrOptions)) [options, filename] = [
+                filenameOrOptions,
+                void 0
+            ];
+            else filename = filenameOrOptions;
+            const file = new FileFromPath({
+                path,
+                size,
+                lastModified: mtimeMs
+            });
+            if (!filename) filename = file.name;
+            return new File.$([
+                file
+            ], filename, {
+                ...options,
+                lastModified: file.lastModified
+            });
+        }
+        async function fileFromPath(path, filenameOrOptions, options) {
+            const stats = await external_fs_.promises.stat(path);
+            return createFileFromPath(path, stats, filenameOrOptions, options);
+        }
+    }
+};

package/dist/663.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */

package/dist/79.js

@@ -0,0 +1,40 @@
+"use strict";
+exports.ids = [
+    "79"
+];
+exports.modules = {
+    "../../node_modules/.pnpm/puppeteer-core@24.2.0_bufferutil@4.0.9_utf-8-validate@6.0.5/node_modules/puppeteer-core/lib/esm/puppeteer/common/BrowserWebSocketTransport.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            BrowserWebSocketTransport: ()=>BrowserWebSocketTransport
+        });
+        class BrowserWebSocketTransport {
+            static create(url) {
+                return new Promise((resolve, reject)=>{
+                    const ws = new WebSocket(url);
+                    ws.addEventListener('open', ()=>resolve(new BrowserWebSocketTransport(ws)));
+                    ws.addEventListener('error', reject);
+                });
+            }
+            #ws;
+            onmessage;
+            onclose;
+            constructor(ws){
+                this.#ws = ws;
+                this.#ws.addEventListener('message', (event)=>{
+                    if (this.onmessage) this.onmessage.call(null, event.data);
+                });
+                this.#ws.addEventListener('close', ()=>{
+                    if (this.onclose) this.onclose.call(null);
+                });
+                this.#ws.addEventListener('error', ()=>{});
+            }
+            send(message) {
+                this.#ws.send(message);
+            }
+            close() {
+                this.#ws.close();
+            }
+        }
+    }
+};