soda-nodejs 0.6.6 → 0.7.1

package/dist/index.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __webpack_modules__ = {
+    "@/utils/compress": function(module) {
+        module.exports = require("./utils/compress.cjs");
+    },
+    "@/utils/copy": function(module) {
+        module.exports = require("./utils/copy.cjs");
+    },
+    "@/utils/execAsync": function(module) {
+        module.exports = require("./utils/execAsync.cjs");
+    },
+    "@/utils/saveFile": function(module) {
+        module.exports = require("./utils/saveFile.cjs");
+    },
+    "@/utils/saveResponse": function(module) {
+        module.exports = require("./utils/saveResponse.cjs");
+    },
+    "@/utils/spawnAsync": function(module) {
+        module.exports = require("./utils/spawnAsync.cjs");
+    },
+    "@/utils/unzip": function(module) {
+        module.exports = require("./utils/unzip.cjs");
+    },
+    "@/utils/zip": function(module) {
+        module.exports = require("./utils/zip.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _utils_compress__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@/utils/compress");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_compress__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_compress__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_copy__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("@/utils/copy");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_copy__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_copy__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_execAsync__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("@/utils/execAsync");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_execAsync__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_execAsync__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_saveFile__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("@/utils/saveFile");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_saveFile__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_saveFile__WEBPACK_IMPORTED_MODULE_3__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_saveResponse__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("@/utils/saveResponse");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_saveResponse__WEBPACK_IMPORTED_MODULE_4__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_saveResponse__WEBPACK_IMPORTED_MODULE_4__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_spawnAsync__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("@/utils/spawnAsync");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_spawnAsync__WEBPACK_IMPORTED_MODULE_5__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_spawnAsync__WEBPACK_IMPORTED_MODULE_5__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_unzip__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("@/utils/unzip");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_unzip__WEBPACK_IMPORTED_MODULE_6__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_unzip__WEBPACK_IMPORTED_MODULE_6__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils_zip__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("@/utils/zip");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils_zip__WEBPACK_IMPORTED_MODULE_7__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils_zip__WEBPACK_IMPORTED_MODULE_7__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./utils/compress.js";
+export * from "./utils/copy.js";
+export * from "./utils/execAsync.js";
+export * from "./utils/saveFile.js";
+export * from "./utils/saveResponse.js";
+export * from "./utils/spawnAsync.js";
+export * from "./utils/unzip.js";
+export * from "./utils/zip.js";

package/dist/utils/compress.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    compress: ()=>compress
+});
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+const external_tar_namespaceObject = require("tar");
+async function compress({ input, output }) {
+    input = (0, external_path_namespaceObject.resolve)(input);
+    if (!(0, external_fs_namespaceObject.existsSync)(input)) throw new Error("Source folder does not exist");
+    const outputDir = (0, external_path_namespaceObject.dirname)(output);
+    if (!(0, external_fs_namespaceObject.existsSync)(outputDir)) (0, external_fs_namespaceObject.mkdirSync)(outputDir, {
+        recursive: true
+    });
+    await (0, external_tar_namespaceObject.create)({
+        gzip: true,
+        file: output,
+        cwd: (0, external_path_namespaceObject.dirname)(input)
+    }, [
+        (0, external_path_namespaceObject.basename)(input)
+    ]);
+    return (0, external_path_namespaceObject.resolve)(output);
+}
+exports.compress = __webpack_exports__.compress;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "compress"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/compress.js

@@ -0,0 +1,20 @@
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_tar__ from "tar";
+async function compress({ input, output }) {
+    input = (0, __WEBPACK_EXTERNAL_MODULE_path__.resolve)(input);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(input)) throw new Error("Source folder does not exist");
+    const outputDir = (0, __WEBPACK_EXTERNAL_MODULE_path__.dirname)(output);
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(outputDir)) (0, __WEBPACK_EXTERNAL_MODULE_fs__.mkdirSync)(outputDir, {
+        recursive: true
+    });
+    await (0, __WEBPACK_EXTERNAL_MODULE_tar__.create)({
+        gzip: true,
+        file: output,
+        cwd: (0, __WEBPACK_EXTERNAL_MODULE_path__.dirname)(input)
+    }, [
+        (0, __WEBPACK_EXTERNAL_MODULE_path__.basename)(input)
+    ]);
+    return (0, __WEBPACK_EXTERNAL_MODULE_path__.resolve)(output);
+}
+export { compress };

package/dist/utils/copy.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    copy: ()=>copy
+});
+const external_fs_namespaceObject = require("fs");
+const promises_namespaceObject = require("fs/promises");
+const external_path_namespaceObject = require("path");
+async function copy({ input, output, mode }) {
+    if (Array.isArray(input)) {
+        for (const item of input)await copy({
+            input: item,
+            output,
+            mode
+        });
+        return;
+    }
+    if (!(0, external_fs_namespaceObject.existsSync)(output)) await (0, promises_namespaceObject.mkdir)(output, {
+        recursive: true
+    });
+    const status = await (0, promises_namespaceObject.stat)(input);
+    const { base } = (0, external_path_namespaceObject.parse)(input);
+    if (status.isFile()) {
+        await (0, promises_namespaceObject.copyFile)(input, (0, external_path_namespaceObject.join)(output, base), mode);
+        return;
+    }
+    if (status.isDirectory()) {
+        await (0, promises_namespaceObject.mkdir)((0, external_path_namespaceObject.join)(output, base), {
+            recursive: true
+        });
+        const entries = await (0, promises_namespaceObject.readdir)(input, {
+            withFileTypes: true
+        });
+        for (const entry of entries)await copy({
+            input: (0, external_path_namespaceObject.join)(input, entry.name),
+            output: (0, external_path_namespaceObject.join)(output, base),
+            mode
+        });
+    }
+}
+exports.copy = __webpack_exports__.copy;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "copy"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/copy.js

@@ -0,0 +1,36 @@
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__ from "fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+async function copy({ input, output, mode }) {
+    if (Array.isArray(input)) {
+        for (const item of input)await copy({
+            input: item,
+            output,
+            mode
+        });
+        return;
+    }
+    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(output)) await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.mkdir)(output, {
+        recursive: true
+    });
+    const status = await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.stat)(input);
+    const { base } = (0, __WEBPACK_EXTERNAL_MODULE_path__.parse)(input);
+    if (status.isFile()) {
+        await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.copyFile)(input, (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base), mode);
+        return;
+    }
+    if (status.isDirectory()) {
+        await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.mkdir)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base), {
+            recursive: true
+        });
+        const entries = await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.readdir)(input, {
+            withFileTypes: true
+        });
+        for (const entry of entries)await copy({
+            input: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(input, entry.name),
+            output: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base),
+            mode
+        });
+    }
+}
+export { copy };

package/dist/utils/execAsync.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    execAsync: ()=>execAsync
+});
+const external_child_process_namespaceObject = require("child_process");
+const external_iconv_lite_namespaceObject = require("iconv-lite");
+var external_iconv_lite_default = /*#__PURE__*/ __webpack_require__.n(external_iconv_lite_namespaceObject);
+async function execAsync(command, options) {
+    const decode = options?.decode;
+    if ("object" == typeof options && null !== options && options.decode) {
+        const { decode, ...rest } = options;
+        options = rest;
+    }
+    return await new Promise((resolve, reject)=>{
+        (0, external_child_process_namespaceObject.exec)(command, options, (error, stdout, stderr)=>{
+            if (error) return reject(error);
+            if (decode && stdout instanceof Buffer) return resolve(external_iconv_lite_default().decode(stdout, decode.encoding, decode.options));
+            resolve(stdout);
+        });
+    });
+}
+exports.execAsync = __webpack_exports__.execAsync;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "execAsync"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/{esm/utils → utils}/execAsync.d.ts

@@ -1,7 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import { ExecOptions } from "child_process";
 import { ObjectEncodingOptions } from "fs";
 import { Options } from "iconv-lite";

package/dist/utils/execAsync.js

@@ -0,0 +1,17 @@
+import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_iconv_lite_e3756a92__ from "iconv-lite";
+async function execAsync(command, options) {
+    const decode = options?.decode;
+    if ("object" == typeof options && null !== options && options.decode) {
+        const { decode, ...rest } = options;
+        options = rest;
+    }
+    return await new Promise((resolve, reject)=>{
+        (0, __WEBPACK_EXTERNAL_MODULE_child_process__.exec)(command, options, (error, stdout, stderr)=>{
+            if (error) return reject(error);
+            if (decode && stdout instanceof Buffer) return resolve(__WEBPACK_EXTERNAL_MODULE_iconv_lite_e3756a92__["default"].decode(stdout, decode.encoding, decode.options));
+            resolve(stdout);
+        });
+    });
+}
+export { execAsync };

package/dist/utils/saveFile.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    saveFile: ()=>saveFile
+});
+const external_fs_namespaceObject = require("fs");
+const external_stream_namespaceObject = require("stream");
+async function saveFile({ input, output }) {
+    await new Promise((resolve, reject)=>{
+        const writeAble = (0, external_fs_namespaceObject.createWriteStream)(output);
+        external_stream_namespaceObject.Readable.fromWeb(input.stream()).pipe(writeAble).on("finish", resolve).on("error", reject);
+    });
+}
+exports.saveFile = __webpack_exports__.saveFile;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "saveFile"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/saveFile.js

@@ -0,0 +1,9 @@
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+async function saveFile({ input, output }) {
+    await new Promise((resolve, reject)=>{
+        const writeAble = (0, __WEBPACK_EXTERNAL_MODULE_fs__.createWriteStream)(output);
+        __WEBPACK_EXTERNAL_MODULE_stream__.Readable.fromWeb(input.stream()).pipe(writeAble).on("finish", resolve).on("error", reject);
+    });
+}
+export { saveFile };

package/dist/utils/saveResponse.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    saveResponse: ()=>saveResponse
+});
+const external_fs_namespaceObject = require("fs");
+const external_stream_namespaceObject = require("stream");
+async function saveResponse(response, file) {
+    const writeable = (0, external_fs_namespaceObject.createWriteStream)(file);
+    await new Promise((resolve, reject)=>external_stream_namespaceObject.Readable.fromWeb(response.body).pipe(writeable).on("close", resolve).on("error", reject));
+}
+exports.saveResponse = __webpack_exports__.saveResponse;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "saveResponse"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/saveResponse.js

@@ -0,0 +1,7 @@
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+async function saveResponse(response, file) {
+    const writeable = (0, __WEBPACK_EXTERNAL_MODULE_fs__.createWriteStream)(file);
+    await new Promise((resolve, reject)=>__WEBPACK_EXTERNAL_MODULE_stream__.Readable.fromWeb(response.body).pipe(writeable).on("close", resolve).on("error", reject));
+}
+export { saveResponse };

package/dist/utils/spawnAsync.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getDefaultOptions: ()=>getDefaultOptions,
+    spawnAsync: ()=>spawnAsync,
+    setDefaultOptions: ()=>setDefaultOptions
+});
+const external_child_process_namespaceObject = require("child_process");
+let defaultOptions = {};
+function getDefaultOptions() {
+    return defaultOptions;
+}
+function setDefaultOptions(options) {
+    if ("function" == typeof options) {
+        defaultOptions = options(defaultOptions);
+        return;
+    }
+    defaultOptions = options;
+    return defaultOptions;
+}
+function spawnAsync(command, args, options) {
+    let child;
+    const promise = new Promise((resolve, reject)=>{
+        if (Array.isArray(args)) options = {
+            ...defaultOptions,
+            ...options
+        };
+        else args = {
+            ...defaultOptions,
+            ...args
+        };
+        child = (0, external_child_process_namespaceObject.spawn)(command, args, options);
+        child.on("exit", (code)=>{
+            if (0 === code) return resolve(child);
+            if (Array.isArray(args)) {
+                const args2 = args.map((item)=>item.trim()).filter(Boolean);
+                if (args2.length > 0) command = `${command} ${args2.join(" ")}`;
+            }
+            reject(new Error(`spawn "${command}" failed with code ${code}`));
+        });
+    });
+    promise.child = child;
+    return promise;
+}
+exports.getDefaultOptions = __webpack_exports__.getDefaultOptions;
+exports.setDefaultOptions = __webpack_exports__.setDefaultOptions;
+exports.spawnAsync = __webpack_exports__.spawnAsync;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getDefaultOptions",
+    "setDefaultOptions",
+    "spawnAsync"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/{cjs/utils → utils}/spawnAsync.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { ChildProcess, ChildProcessByStdio, ChildProcessWithoutNullStreams, SpawnOptions, SpawnOptionsWithStdioTuple, SpawnOptionsWithoutStdio, StdioNull, StdioPipe } from "child_process";
 import { Readable, Writable } from "stream";
 export interface PromiseWithChildProcess<T> extends Promise<T> {

package/dist/utils/spawnAsync.js

@@ -0,0 +1,38 @@
+import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+let defaultOptions = {};
+function getDefaultOptions() {
+    return defaultOptions;
+}
+function setDefaultOptions(options) {
+    if ("function" == typeof options) {
+        defaultOptions = options(defaultOptions);
+        return;
+    }
+    defaultOptions = options;
+    return defaultOptions;
+}
+function spawnAsync(command, args, options) {
+    let child;
+    const promise = new Promise((resolve, reject)=>{
+        if (Array.isArray(args)) options = {
+            ...defaultOptions,
+            ...options
+        };
+        else args = {
+            ...defaultOptions,
+            ...args
+        };
+        child = (0, __WEBPACK_EXTERNAL_MODULE_child_process__.spawn)(command, args, options);
+        child.on("exit", (code)=>{
+            if (0 === code) return resolve(child);
+            if (Array.isArray(args)) {
+                const args2 = args.map((item)=>item.trim()).filter(Boolean);
+                if (args2.length > 0) command = `${command} ${args2.join(" ")}`;
+            }
+            reject(new Error(`spawn "${command}" failed with code ${code}`));
+        });
+    });
+    promise.child = child;
+    return promise;
+}
+export { getDefaultOptions, setDefaultOptions, spawnAsync };