main funcions fixes

desktop-operator/node_modules/zip-stream/CHANGELOG.md

@@ -0,0 +1,112 @@
+## Changelog
+
+**4.1.1** - <small>September 2, 2023</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.1.0...4.1.1)
+
+**4.1.0** - <small>March 2, 2021</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.5...4.1.0)
+
+## Features
+
+- Allow prepending forward slash in entry name (#79)
+
+## Maintenance
+
+- Bump mocha from 8.2.1 to 8.3.0 (#76)
+- Bump actions/setup-node from v2.1.4 to v2.1.5 (#77)
+- Bump actions/setup-node from v2.1.2 to v2.1.4 (#74)
+
+**4.0.5** - <small>November 18, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.4...4.0.5)
+
+- No Changes
+
+**4.0.4** - <small>November 18, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.3...4.0.4)
+
+### Maintenance
+
+- Bump compress-commons from 4.0.1 to 4.0.2 (#72)
+
+**4.0.3** - <small>November 18, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.2...4.0.3)
+
+### Maintenance
+
+- Update docs example with latest ES6 syntax (#60)
+- Update archiver-jsdoc-theme to ^1.1.3 (#71)
+- Update archiver-jsdoc-theme to ^1.1.2 (#70)
+- Bump jsdoc from 3.6.5 to 3.6.6 (#62)
+- Bump actions/setup-node from v2.1.1 to v2.1.2 (#64)
+- Bump mocha from 8.1.1 to 8.2.1 (#66)
+- Bump actions/checkout from v2.3.2 to v2.3.4 (#67)
+- Bump mocha from 8.1.0 to 8.1.1 (#55)
+- Bump actions/checkout from v2.3.1 to v2.3.2 (#56)
+- Bump mocha from 8.0.1 to 8.1.0 (#54)
+- Bump actions/setup-node from v2.1.0 to v2.1.1 (#52)
+- Bump jsdoc from 3.6.4 to 3.6.5 (#53)
+
+
+**4.0.2** - <small>July 20, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.1...4.0.2)
+
+* Bump compress-commons from 4.0.0 to 4.0.1 (#51) @dependabot
+
+**4.0.1** - <small>July 20, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/4.0.0...4.0.1)
+
+* Bump compress-commons from 3.0.0 to 4.0.0 (#50) @dependabot
+
+**4.0.0** - <small>July 18, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/3.0.1...4.0.0)
+
+* Bump mocha from 6.2.3 to 8.0.1 (#47) @dependabot
+* Bump rimraf from 2.7.1 to 3.0.2 (#46) @dependabot
+* Bump actions/setup-node from v1 to v2.1.0 (#45) @dependabot
+* Bump mkdirp from 0.5.5 to 1.0.4 (#48) @dependabot
+* remove support for node < 10 (#49) @ctalkington
+* Bump actions/checkout from v1 to v2.3.1 (#44) @dependabot
+
+**3.0.1** - <small>April 14, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/3.0.0...3.0.1)
+
+- update to compress-commons@^3.0.0
+
+**3.0.0** - <small>April 14, 2020</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.1.3...3.0.0)
+
+- breaking: slowly catch up with node LTS, remove support for versions under 8.
+- update multiple deps.
+
+**2.1.3** — <small> January 8, 2020 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.1.0...2.1.3)
+
+- allow zip64 for no compression (#40)
+
+**2.1.2** — <small> August 2, 2019 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.1.0...2.1.2)
+
+- update compress-commons to v2.1.1
+
+**2.1.1** — <small> August 2, 2019 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.1.0...2.1.1)
+
+- update compress-commons to v2.1.0
+
+**2.1.0** — <small> July 19, 2019 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.0.1...2.1.0)
+
+- test: now targeting node v12
+- other: update dependencies.
+
+**2.0.1** — <small> August 22, 2018 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/2.0.0...2.0.1)
+
+- update to archiver-utils@2
+
+**2.0.0** — <small> August 22, 2018 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/1.2.0...2.0.0)
+
+- breaking: follow node LTS, remove support for versions under 6.
+- other: remove unused lodash dependence (#35)
+
+**1.2.0** — <small> June 16, 2017 </small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/1.1.1...1.2.0)
+
+- groundwork for symlinks support.
+
+*NOTE: this will be the last release for node v0.10 and v0.12. node v4 will become the minimum and a version bump to 2.0.0 will take place.*
+
+**1.1.1** — <small>_January 17, 2017_</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/1.1.0...1.1.1)
+
+- actually use STORE method if level is 0 (GH #21)
+- bump deps to ensure latest versions are used.
+
+**1.1.0** — <small>_August 27, 2016_</small> — [Diff](https://github.com/archiverjs/node-zip-stream/compare/1.0.0...1.1.0)
+
+- bump deps to ensure latest versions are used.
+
+[Release Archive](https://github.com/archiverjs/node-zip-stream/releases)

desktop-operator/node_modules/zip-stream/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Talkington, contributors.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

desktop-operator/node_modules/zip-stream/README.md

@@ -0,0 +1,45 @@
+# ZipStream
+
+zip-stream is a streaming zip archive generator based on the `ZipArchiveOutputStream` prototype found in the [compress-commons](https://www.npmjs.org/package/compress-commons) project.
+
+It was originally created to be a successor to [zipstream](https://npmjs.org/package/zipstream).
+
+Visit the [API documentation](http://archiverjs.com/zip-stream) for a list of all methods available.
+
+### Install
+
+```bash
+npm install zip-stream --save
+```
+
+You can also use `npm install https://github.com/archiverjs/node-zip-stream/archive/master.tar.gz` to test upcoming versions.
+
+### Usage
+
+This module is meant to be wrapped internally by other modules and therefore lacks any queue management. This means you have to wait until the previous entry has been fully consumed to add another. Nested callbacks should be used to add multiple entries. There are modules like [async](https://npmjs.org/package/async) that ease the so called "callback hell".
+
+If you want a module that handles entry queueing and much more, you should check out [archiver](https://npmjs.org/package/archiver) which uses this module internally.
+
+```js
+const Packer = require('zip-stream');
+const archive = new Packer(); // OR new Packer(options)
+
+archive.on('error', function(err) {
+  throw err;
+});
+
+// pipe archive where you want it (ie fs, http, etc)
+// listen to the destination's end, close, or finish event
+
+archive.entry('string contents', { name: 'string.txt' }, function(err, entry) {
+  if (err) throw err;
+  archive.entry(null, { name: 'directory/' }, function(err, entry) {
+    if (err) throw err;
+    archive.finish();
+  });
+});
+```
+
+## Credits
+
+Concept inspired by Antoine van Wel's [zipstream](https://npmjs.org/package/zipstream) module, which is no longer being updated.

desktop-operator/node_modules/zip-stream/index.js

@@ -0,0 +1,187 @@
+/**
+ * ZipStream
+ *
+ * @ignore
+ * @license [MIT]{@link https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE}
+ * @copyright (c) 2014 Chris Talkington, contributors.
+ */
+var inherits = require('util').inherits;
+
+var ZipArchiveOutputStream = require('compress-commons').ZipArchiveOutputStream;
+var ZipArchiveEntry = require('compress-commons').ZipArchiveEntry;
+
+var util = require('archiver-utils');
+
+/**
+ * @constructor
+ * @extends external:ZipArchiveOutputStream
+ * @param {Object} [options]
+ * @param {String} [options.comment] Sets the zip archive comment.
+ * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+ * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+ * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+ * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+ * to control compression.
+ */
+var ZipStream = module.exports = function(options) {
+  if (!(this instanceof ZipStream)) {
+    return new ZipStream(options);
+  }
+
+  options = this.options = options || {};
+  options.zlib = options.zlib || {};
+
+  ZipArchiveOutputStream.call(this, options);
+
+  if (typeof options.level === 'number' && options.level >= 0) {
+    options.zlib.level = options.level;
+    delete options.level;
+  }
+
+  if (!options.forceZip64 && typeof options.zlib.level === 'number' && options.zlib.level === 0) {
+    options.store = true;
+  }
+
+  options.namePrependSlash = options.namePrependSlash || false;
+
+  if (options.comment && options.comment.length > 0) {
+    this.setComment(options.comment);
+  }
+};
+
+inherits(ZipStream, ZipArchiveOutputStream);
+
+/**
+ * Normalizes entry data with fallbacks for key properties.
+ *
+ * @private
+ * @param  {Object} data
+ * @return {Object}
+ */
+ZipStream.prototype._normalizeFileData = function(data) {
+  data = util.defaults(data, {
+    type: 'file',
+    name: null,
+    namePrependSlash: this.options.namePrependSlash,
+    linkname: null,
+    date: null,
+    mode: null,
+    store: this.options.store,
+    comment: ''
+  });
+
+  var isDir = data.type === 'directory';
+  var isSymlink = data.type === 'symlink';
+
+  if (data.name) {
+    data.name = util.sanitizePath(data.name);
+
+    if (!isSymlink && data.name.slice(-1) === '/') {
+      isDir = true;
+      data.type = 'directory';
+    } else if (isDir) {
+      data.name += '/';
+    }
+  }
+
+  if (isDir || isSymlink) {
+    data.store = true;
+  }
+
+  data.date = util.dateify(data.date);
+
+  return data;
+};
+
+/**
+ * Appends an entry given an input source (text string, buffer, or stream).
+ *
+ * @param  {(Buffer|Stream|String)} source The input source.
+ * @param  {Object} data
+ * @param  {String} data.name Sets the entry name including internal path.
+ * @param  {String} [data.comment] Sets the entry comment.
+ * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
+ * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+ * @param  {Boolean} [data.store=options.store] Sets the compression method to STORE.
+ * @param  {String} [data.type=file] Sets the entry type. Defaults to `directory`
+ * if name ends with trailing slash.
+ * @param  {Function} callback
+ * @return this
+ */
+ZipStream.prototype.entry = function(source, data, callback) {
+  if (typeof callback !== 'function') {
+    callback = this._emitErrorCallback.bind(this);
+  }
+
+  data = this._normalizeFileData(data);
+
+  if (data.type !== 'file' && data.type !== 'directory' && data.type !== 'symlink') {
+    callback(new Error(data.type + ' entries not currently supported'));
+    return;
+  }
+
+  if (typeof data.name !== 'string' || data.name.length === 0) {
+    callback(new Error('entry name must be a non-empty string value'));
+    return;
+  }
+
+  if (data.type === 'symlink' && typeof data.linkname !== 'string') {
+    callback(new Error('entry linkname must be a non-empty string value when type equals symlink'));
+    return;
+  }
+
+  var entry = new ZipArchiveEntry(data.name);
+  entry.setTime(data.date, this.options.forceLocalTime);
+
+  if (data.namePrependSlash) {
+    entry.setName(data.name, true);
+  }
+
+  if (data.store) {
+    entry.setMethod(0);
+  }
+
+  if (data.comment.length > 0) {
+    entry.setComment(data.comment);
+  }
+
+  if (data.type === 'symlink' && typeof data.mode !== 'number') {
+    data.mode = 40960; // 0120000
+  }
+
+  if (typeof data.mode === 'number') {
+    if (data.type === 'symlink') {
+      data.mode |= 40960;
+    }
+
+    entry.setUnixMode(data.mode);
+  }
+
+  if (data.type === 'symlink' && typeof data.linkname === 'string') {
+    source = Buffer.from(data.linkname);
+  }
+
+  return ZipArchiveOutputStream.prototype.entry.call(this, entry, source, callback);
+};
+
+/**
+ * Finalizes the instance and prevents further appending to the archive
+ * structure (queue will continue til drained).
+ *
+ * @return void
+ */
+ZipStream.prototype.finalize = function() {
+  this.finish();
+};
+
+/**
+ * Returns the current number of bytes written to this stream.
+ * @function ZipStream#getBytesWritten
+ * @returns {Number}
+ */
+
+/**
+ * Compress Commons ZipArchiveOutputStream
+ * @external ZipArchiveOutputStream
+ * @see {@link https://github.com/archiverjs/node-compress-commons}
+ */

desktop-operator/node_modules/zip-stream/node_modules/archiver-utils/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Chris Talkington.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

desktop-operator/node_modules/zip-stream/node_modules/archiver-utils/README.md

@@ -0,0 +1,6 @@
+# Archiver Utils
+
+## Things of Interest
+- [Changelog](https://github.com/archiverjs/archiver-utils/releases)
+- [Contributing](https://github.com/archiverjs/archiver-utils/blob/master/CONTRIBUTING.md)
+- [MIT License](https://github.com/archiverjs/archiver-utils/blob/master/LICENSE)

desktop-operator/node_modules/zip-stream/node_modules/archiver-utils/file.js

@@ -0,0 +1,209 @@
+/**
+ * archiver-utils
+ *
+ * Copyright (c) 2012-2014 Chris Talkington, contributors.
+ * Licensed under the MIT license.
+ * https://github.com/archiverjs/node-archiver/blob/master/LICENSE-MIT
+ */
+var fs = require('graceful-fs');
+var path = require('path');
+
+var flatten = require('lodash.flatten');
+var difference = require('lodash.difference');
+var union = require('lodash.union');
+var isPlainObject = require('lodash.isplainobject');
+
+var glob = require('glob');
+
+var file = module.exports = {};
+
+var pathSeparatorRe = /[\/\\]/g;
+
+// Process specified wildcard glob patterns or filenames against a
+// callback, excluding and uniquing files in the result set.
+var processPatterns = function(patterns, fn) {
+  // Filepaths to return.
+  var result = [];
+  // Iterate over flattened patterns array.
+  flatten(patterns).forEach(function(pattern) {
+    // If the first character is ! it should be omitted
+    var exclusion = pattern.indexOf('!') === 0;
+    // If the pattern is an exclusion, remove the !
+    if (exclusion) { pattern = pattern.slice(1); }
+    // Find all matching files for this pattern.
+    var matches = fn(pattern);
+    if (exclusion) {
+      // If an exclusion, remove matching files.
+      result = difference(result, matches);
+    } else {
+      // Otherwise add matching files.
+      result = union(result, matches);
+    }
+  });
+  return result;
+};
+
+// True if the file path exists.
+file.exists = function() {
+  var filepath = path.join.apply(path, arguments);
+  return fs.existsSync(filepath);
+};
+
+// Return an array of all file paths that match the given wildcard patterns.
+file.expand = function(...args) {
+  // If the first argument is an options object, save those options to pass
+  // into the File.prototype.glob.sync method.
+  var options = isPlainObject(args[0]) ? args.shift() : {};
+  // Use the first argument if it's an Array, otherwise convert the arguments
+  // object to an array and use that.
+  var patterns = Array.isArray(args[0]) ? args[0] : args;
+  // Return empty set if there are no patterns or filepaths.
+  if (patterns.length === 0) { return []; }
+  // Return all matching filepaths.
+  var matches = processPatterns(patterns, function(pattern) {
+    // Find all matching files for this pattern.
+    return glob.sync(pattern, options);
+  });
+  // Filter result set?
+  if (options.filter) {
+    matches = matches.filter(function(filepath) {
+      filepath = path.join(options.cwd || '', filepath);
+      try {
+        if (typeof options.filter === 'function') {
+          return options.filter(filepath);
+        } else {
+          // If the file is of the right type and exists, this should work.
+          return fs.statSync(filepath)[options.filter]();
+        }
+      } catch(e) {
+        // Otherwise, it's probably not the right type.
+        return false;
+      }
+    });
+  }
+  return matches;
+};
+
+// Build a multi task "files" object dynamically.
+file.expandMapping = function(patterns, destBase, options) {
+  options = Object.assign({
+    rename: function(destBase, destPath) {
+      return path.join(destBase || '', destPath);
+    }
+  }, options);
+  var files = [];
+  var fileByDest = {};
+  // Find all files matching pattern, using passed-in options.
+  file.expand(options, patterns).forEach(function(src) {
+    var destPath = src;
+    // Flatten?
+    if (options.flatten) {
+      destPath = path.basename(destPath);
+    }
+    // Change the extension?
+    if (options.ext) {
+      destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
+    }
+    // Generate destination filename.
+    var dest = options.rename(destBase, destPath, options);
+    // Prepend cwd to src path if necessary.
+    if (options.cwd) { src = path.join(options.cwd, src); }
+    // Normalize filepaths to be unix-style.
+    dest = dest.replace(pathSeparatorRe, '/');
+    src = src.replace(pathSeparatorRe, '/');
+    // Map correct src path to dest path.
+    if (fileByDest[dest]) {
+      // If dest already exists, push this src onto that dest's src array.
+      fileByDest[dest].src.push(src);
+    } else {
+      // Otherwise create a new src-dest file mapping object.
+      files.push({
+        src: [src],
+        dest: dest,
+      });
+      // And store a reference for later use.
+      fileByDest[dest] = files[files.length - 1];
+    }
+  });
+  return files;
+};
+
+// reusing bits of grunt's multi-task source normalization
+file.normalizeFilesArray = function(data) {
+  var files = [];
+
+  data.forEach(function(obj) {
+    var prop;
+    if ('src' in obj || 'dest' in obj) {
+      files.push(obj);
+    }
+  });
+
+  if (files.length === 0) {
+    return [];
+  }
+
+  files = _(files).chain().forEach(function(obj) {
+    if (!('src' in obj) || !obj.src) { return; }
+    // Normalize .src properties to flattened array.
+    if (Array.isArray(obj.src)) {
+      obj.src = flatten(obj.src);
+    } else {
+      obj.src = [obj.src];
+    }
+  }).map(function(obj) {
+    // Build options object, removing unwanted properties.
+    var expandOptions = Object.assign({}, obj);
+    delete expandOptions.src;
+    delete expandOptions.dest;
+
+    // Expand file mappings.
+    if (obj.expand) {
+      return file.expandMapping(obj.src, obj.dest, expandOptions).map(function(mapObj) {
+        // Copy obj properties to result.
+        var result = Object.assign({}, obj);
+        // Make a clone of the orig obj available.
+        result.orig = Object.assign({}, obj);
+        // Set .src and .dest, processing both as templates.
+        result.src = mapObj.src;
+        result.dest = mapObj.dest;
+        // Remove unwanted properties.
+        ['expand', 'cwd', 'flatten', 'rename', 'ext'].forEach(function(prop) {
+          delete result[prop];
+        });
+        return result;
+      });
+    }
+
+    // Copy obj properties to result, adding an .orig property.
+    var result = Object.assign({}, obj);
+    // Make a clone of the orig obj available.
+    result.orig = Object.assign({}, obj);
+
+    if ('src' in result) {
+      // Expose an expand-on-demand getter method as .src.
+      Object.defineProperty(result, 'src', {
+        enumerable: true,
+        get: function fn() {
+          var src;
+          if (!('result' in fn)) {
+            src = obj.src;
+            // If src is an array, flatten it. Otherwise, make it into an array.
+            src = Array.isArray(src) ? flatten(src) : [src];
+            // Expand src files, memoizing result.
+            fn.result = file.expand(expandOptions, src);
+          }
+          return fn.result;
+        }
+      });
+    }
+
+    if ('dest' in result) {
+      result.dest = obj.dest;
+    }
+
+    return result;
+  }).flatten().value();
+
+  return files;
+};

desktop-operator/node_modules/zip-stream/node_modules/archiver-utils/index.js

@@ -0,0 +1,149 @@
+/**
+ * archiver-utils
+ *
+ * Copyright (c) 2015 Chris Talkington.
+ * Licensed under the MIT license.
+ * https://github.com/archiverjs/archiver-utils/blob/master/LICENSE
+ */
+var fs = require('graceful-fs');
+var path = require('path');
+var lazystream = require('lazystream');
+var normalizePath = require('normalize-path');
+var defaults = require('lodash.defaults');
+
+var Stream = require('stream').Stream;
+var PassThrough = require('readable-stream').PassThrough;
+
+var utils = module.exports = {};
+utils.file = require('./file.js');
+
+utils.collectStream = function(source, callback) {
+  var collection = [];
+  var size = 0;
+
+  source.on('error', callback);
+
+  source.on('data', function(chunk) {
+    collection.push(chunk);
+    size += chunk.length;
+  });
+
+  source.on('end', function() {
+    var buf = Buffer.alloc(size);
+    var offset = 0;
+
+    collection.forEach(function(data) {
+      data.copy(buf, offset);
+      offset += data.length;
+    });
+
+    callback(null, buf);
+  });
+};
+
+utils.dateify = function(dateish) {
+  dateish = dateish || new Date();
+
+  if (dateish instanceof Date) {
+    dateish = dateish;
+  } else if (typeof dateish === 'string') {
+    dateish = new Date(dateish);
+  } else {
+    dateish = new Date();
+  }
+
+  return dateish;
+};
+
+// this is slightly different from lodash version
+utils.defaults = function(object, source, guard) {
+  var args = arguments;
+  args[0] = args[0] || {};
+
+  return defaults(...args);
+};
+
+utils.isStream = function(source) {
+  return source instanceof Stream;
+};
+
+utils.lazyReadStream = function(filepath) {
+  return new lazystream.Readable(function() {
+    return fs.createReadStream(filepath);
+  });
+};
+
+utils.normalizeInputSource = function(source) {
+  if (source === null) {
+    return Buffer.alloc(0);
+  } else if (typeof source === 'string') {
+    return Buffer.from(source);
+  } else if (utils.isStream(source)) {
+    // Always pipe through a PassThrough stream to guarantee pausing the stream if it's already flowing,
+    // since it will only be processed in a (distant) future iteration of the event loop, and will lose
+    // data if already flowing now.
+    return source.pipe(new PassThrough());
+  }
+
+  return source;
+};
+
+utils.sanitizePath = function(filepath) {
+  return normalizePath(filepath, false).replace(/^\w+:/, '').replace(/^(\.\.\/|\/)+/, '');
+};
+
+utils.trailingSlashIt = function(str) {
+  return str.slice(-1) !== '/' ? str + '/' : str;
+};
+
+utils.unixifyPath = function(filepath) {
+  return normalizePath(filepath, false).replace(/^\w+:/, '');
+};
+
+utils.walkdir = function(dirpath, base, callback) {
+  var results = [];
+
+  if (typeof base === 'function') {
+    callback = base;
+    base = dirpath;
+  }
+
+  fs.readdir(dirpath, function(err, list) {
+    var i = 0;
+    var file;
+    var filepath;
+
+    if (err) {
+      return callback(err);
+    }
+
+    (function next() {
+      file = list[i++];
+
+      if (!file) {
+        return callback(null, results);
+      }
+
+      filepath = path.join(dirpath, file);
+
+      fs.stat(filepath, function(err, stats) {
+        results.push({
+          path: filepath,
+          relative: path.relative(base, filepath).replace(/\\/g, '/'),
+          stats: stats
+        });
+
+        if (stats && stats.isDirectory()) {
+          utils.walkdir(filepath, base, function(err, res) {
+            res.forEach(function(dirEntry) {
+              results.push(dirEntry);
+            });
+            next();
+          });
+        } else {
+          next();
+        }
+      });
+    })();
+  });
+};

desktop-operator/node_modules/zip-stream/node_modules/archiver-utils/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "archiver-utils",
+  "version": "3.0.4",
+  "license": "MIT",
+  "description": "utility functions for archiver",
+  "homepage": "https://github.com/archiverjs/archiver-utils#readme",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/archiver-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/archiver-utils/issues"
+  },
+  "keywords": [
+    "archiver",
+    "utils"
+  ],
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "file.js"
+  ],
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot"
+  },
+  "dependencies": {
+    "glob": "^7.2.3",
+    "graceful-fs": "^4.2.0",
+    "lazystream": "^1.0.0",
+    "lodash.defaults": "^4.2.0",
+    "lodash.difference": "^4.5.0",
+    "lodash.flatten": "^4.4.0",
+    "lodash.isplainobject": "^4.0.6",
+    "lodash.union": "^4.6.0",
+    "normalize-path": "^3.0.0",
+    "readable-stream": "^3.6.0"
+  },
+  "devDependencies": {
+    "chai": "4.3.8",
+    "mkdirp": "3.0.1",
+    "mocha": "9.2.2",
+    "rimraf": "3.0.2"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

desktop-operator/node_modules/zip-stream/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "zip-stream",
+  "version": "4.1.1",
+  "description": "a streaming zip archive generator.",
+  "homepage": "https://github.com/archiverjs/node-zip-stream",
+  "author": {
+    "name": "Chris Talkington",
+    "url": "http://christalkington.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archiverjs/node-zip-stream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archiverjs/node-zip-stream/issues"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "test": "mocha --reporter dot",
+    "jsdoc": "jsdoc -c jsdoc.json README.md"
+  },
+  "dependencies": {
+    "archiver-utils": "^3.0.4",
+    "compress-commons": "^4.1.2",
+    "readable-stream": "^3.6.0"
+  },
+  "devDependencies": {
+    "archiver-jsdoc-theme": "1.1.3",
+    "chai": "4.3.8",
+    "jsdoc": "3.6.11",
+    "minami": "1.2.3",
+    "mkdirp": "2.1.6",
+    "mocha": "9.2.2",
+    "rimraf": "3.0.2"
+  },
+  "keywords": [
+    "archive",
+    "stream",
+    "zip-stream",
+    "zip"
+  ]
+}