@nocobase/plugin-backups 2.0.56

package/dist/node_modules/archiver/node_modules/tar-stream/pack.js

@@ -0,0 +1,255 @@
+var constants = require('fs-constants')
+var eos = require('end-of-stream')
+var inherits = require('inherits')
+var alloc = Buffer.alloc
+
+var Readable = require('readable-stream').Readable
+var Writable = require('readable-stream').Writable
+var StringDecoder = require('string_decoder').StringDecoder
+
+var headers = require('./headers')
+
+var DMODE = parseInt('755', 8)
+var FMODE = parseInt('644', 8)
+
+var END_OF_TAR = alloc(1024)
+
+var noop = function () {}
+
+var overflow = function (self, size) {
+  size &= 511
+  if (size) self.push(END_OF_TAR.slice(0, 512 - size))
+}
+
+function modeToType (mode) {
+  switch (mode & constants.S_IFMT) {
+    case constants.S_IFBLK: return 'block-device'
+    case constants.S_IFCHR: return 'character-device'
+    case constants.S_IFDIR: return 'directory'
+    case constants.S_IFIFO: return 'fifo'
+    case constants.S_IFLNK: return 'symlink'
+  }
+
+  return 'file'
+}
+
+var Sink = function (to) {
+  Writable.call(this)
+  this.written = 0
+  this._to = to
+  this._destroyed = false
+}
+
+inherits(Sink, Writable)
+
+Sink.prototype._write = function (data, enc, cb) {
+  this.written += data.length
+  if (this._to.push(data)) return cb()
+  this._to._drain = cb
+}
+
+Sink.prototype.destroy = function () {
+  if (this._destroyed) return
+  this._destroyed = true
+  this.emit('close')
+}
+
+var LinkSink = function () {
+  Writable.call(this)
+  this.linkname = ''
+  this._decoder = new StringDecoder('utf-8')
+  this._destroyed = false
+}
+
+inherits(LinkSink, Writable)
+
+LinkSink.prototype._write = function (data, enc, cb) {
+  this.linkname += this._decoder.write(data)
+  cb()
+}
+
+LinkSink.prototype.destroy = function () {
+  if (this._destroyed) return
+  this._destroyed = true
+  this.emit('close')
+}
+
+var Void = function () {
+  Writable.call(this)
+  this._destroyed = false
+}
+
+inherits(Void, Writable)
+
+Void.prototype._write = function (data, enc, cb) {
+  cb(new Error('No body allowed for this entry'))
+}
+
+Void.prototype.destroy = function () {
+  if (this._destroyed) return
+  this._destroyed = true
+  this.emit('close')
+}
+
+var Pack = function (opts) {
+  if (!(this instanceof Pack)) return new Pack(opts)
+  Readable.call(this, opts)
+
+  this._drain = noop
+  this._finalized = false
+  this._finalizing = false
+  this._destroyed = false
+  this._stream = null
+}
+
+inherits(Pack, Readable)
+
+Pack.prototype.entry = function (header, buffer, callback) {
+  if (this._stream) throw new Error('already piping an entry')
+  if (this._finalized || this._destroyed) return
+
+  if (typeof buffer === 'function') {
+    callback = buffer
+    buffer = null
+  }
+
+  if (!callback) callback = noop
+
+  var self = this
+
+  if (!header.size || header.type === 'symlink') header.size = 0
+  if (!header.type) header.type = modeToType(header.mode)
+  if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE
+  if (!header.uid) header.uid = 0
+  if (!header.gid) header.gid = 0
+  if (!header.mtime) header.mtime = new Date()
+
+  if (typeof buffer === 'string') buffer = Buffer.from(buffer)
+  if (Buffer.isBuffer(buffer)) {
+    header.size = buffer.length
+    this._encode(header)
+    var ok = this.push(buffer)
+    overflow(self, header.size)
+    if (ok) process.nextTick(callback)
+    else this._drain = callback
+    return new Void()
+  }
+
+  if (header.type === 'symlink' && !header.linkname) {
+    var linkSink = new LinkSink()
+    eos(linkSink, function (err) {
+      if (err) { // stream was closed
+        self.destroy()
+        return callback(err)
+      }
+
+      header.linkname = linkSink.linkname
+      self._encode(header)
+      callback()
+    })
+
+    return linkSink
+  }
+
+  this._encode(header)
+
+  if (header.type !== 'file' && header.type !== 'contiguous-file') {
+    process.nextTick(callback)
+    return new Void()
+  }
+
+  var sink = new Sink(this)
+
+  this._stream = sink
+
+  eos(sink, function (err) {
+    self._stream = null
+
+    if (err) { // stream was closed
+      self.destroy()
+      return callback(err)
+    }
+
+    if (sink.written !== header.size) { // corrupting tar
+      self.destroy()
+      return callback(new Error('size mismatch'))
+    }
+
+    overflow(self, header.size)
+    if (self._finalizing) self.finalize()
+    callback()
+  })
+
+  return sink
+}
+
+Pack.prototype.finalize = function () {
+  if (this._stream) {
+    this._finalizing = true
+    return
+  }
+
+  if (this._finalized) return
+  this._finalized = true
+  this.push(END_OF_TAR)
+  this.push(null)
+}
+
+Pack.prototype.destroy = function (err) {
+  if (this._destroyed) return
+  this._destroyed = true
+
+  if (err) this.emit('error', err)
+  this.emit('close')
+  if (this._stream && this._stream.destroy) this._stream.destroy()
+}
+
+Pack.prototype._encode = function (header) {
+  if (!header.pax) {
+    var buf = headers.encode(header)
+    if (buf) {
+      this.push(buf)
+      return
+    }
+  }
+  this._encodePax(header)
+}
+
+Pack.prototype._encodePax = function (header) {
+  var paxHeader = headers.encodePax({
+    name: header.name,
+    linkname: header.linkname,
+    pax: header.pax
+  })
+
+  var newHeader = {
+    name: 'PaxHeader',
+    mode: header.mode,
+    uid: header.uid,
+    gid: header.gid,
+    size: paxHeader.length,
+    mtime: header.mtime,
+    type: 'pax-header',
+    linkname: header.linkname && 'PaxHeader',
+    uname: header.uname,
+    gname: header.gname,
+    devmajor: header.devmajor,
+    devminor: header.devminor
+  }
+
+  this.push(headers.encode(newHeader))
+  this.push(paxHeader)
+  overflow(this, paxHeader.length)
+
+  newHeader.size = header.size
+  newHeader.type = header.type
+  this.push(headers.encode(newHeader))
+}
+
+Pack.prototype._read = function (n) {
+  var drain = this._drain
+  this._drain = noop
+  drain()
+}
+
+module.exports = Pack

package/dist/node_modules/archiver/node_modules/tar-stream/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "tar-stream",
+  "version": "2.2.0",
+  "description": "tar-stream is a streaming tar parser and generator and nothing else. It is streams2 and operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
+  "author": "Mathias Buus <mathiasbuus@gmail.com>",
+  "dependencies": {
+    "bl": "^4.0.3",
+    "end-of-stream": "^1.4.1",
+    "fs-constants": "^1.0.0",
+    "inherits": "^2.0.3",
+    "readable-stream": "^3.1.1"
+  },
+  "devDependencies": {
+    "concat-stream": "^2.0.0",
+    "standard": "^12.0.1",
+    "tape": "^4.9.2"
+  },
+  "scripts": {
+    "test": "standard && tape test/extract.js test/pack.js",
+    "test-all": "standard && tape test/*.js"
+  },
+  "keywords": [
+    "tar",
+    "tarball",
+    "parse",
+    "parser",
+    "generate",
+    "generator",
+    "stream",
+    "stream2",
+    "streams",
+    "streams2",
+    "streaming",
+    "pack",
+    "extract",
+    "modify"
+  ],
+  "bugs": {
+    "url": "https://github.com/mafintosh/tar-stream/issues"
+  },
+  "homepage": "https://github.com/mafintosh/tar-stream",
+  "main": "index.js",
+  "files": [
+    "*.js",
+    "LICENSE"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mafintosh/tar-stream.git"
+  },
+  "engines": {
+    "node": ">=6"
+  }
+}

package/dist/node_modules/archiver/node_modules/tar-stream/sandbox.js

@@ -0,0 +1,11 @@
+const tar = require('tar-stream')
+const fs = require('fs')
+const path = require('path')
+const pipeline = require('pump') // eequire('stream').pipeline
+
+fs.createReadStream('test.tar')
+  .pipe(tar.extract())
+  .on('entry', function (header, stream, done) {
+    console.log(header.name)
+    pipeline(stream, fs.createWriteStream(path.join('/tmp', header.name)), done)
+  })

package/dist/node_modules/archiver/package.json

@@ -0,0 +1 @@
+{"name":"archiver","version":"5.3.2","description":"a streaming interface for archive generation","homepage":"https://github.com/archiverjs/node-archiver","author":{"name":"Chris Talkington","url":"http://christalkington.com/"},"repository":{"type":"git","url":"https://github.com/archiverjs/node-archiver.git"},"bugs":{"url":"https://github.com/archiverjs/node-archiver/issues"},"license":"MIT","main":"index.js","files":["index.js","lib"],"engines":{"node":">= 10"},"scripts":{"test":"mocha --reporter dot","bench":"node benchmark/simple/pack-zip.js"},"dependencies":{"archiver-utils":"^2.1.0","async":"^3.2.4","buffer-crc32":"^0.2.1","readable-stream":"^3.6.0","readdir-glob":"^1.1.2","tar-stream":"^2.2.0","zip-stream":"^4.1.0"},"devDependencies":{"archiver-jsdoc-theme":"^1.1.3","chai":"^4.3.7","jsdoc":"^3.6.4","mkdirp":"^2.1.5","mocha":"^9.0.2","rimraf":"^4.3.1","stream-bench":"^0.1.2","tar":"^6.1.13","yauzl":"^2.9.0"},"keywords":["archive","archiver","stream","zip","tar"],"publishConfig":{"registry":"https://registry.npmjs.org/"},"_lastModified":"2026-05-21T17:29:15.923Z"}

package/dist/node_modules/cron-parser/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+    "rules": {
+        "eol-last": ["error", "always"],
+        "quotes": ["error", "single"],
+        "semi": ["error", "always"]
+    },
+    "overrides": [
+        {
+            "files": ["test/**.js"],
+            "parserOptions": {
+                "ecmaVersion": 6
+            }
+        }
+    ]
+}

package/dist/node_modules/cron-parser/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - '12'
+  - '14'
+  - '15'
+  - '16'
+  - '17'

package/dist/node_modules/cron-parser/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2016 Harri Siirak
+
+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.

package/dist/node_modules/cron-parser/component.json

@@ -0,0 +1,11 @@
+{
+  "name": "cron-parser",
+  "repo": "harrisiirak/cron-parser",
+  "description": "Node.js library for parsing crontab instructions",
+  "version": "4.3.0",
+  "keywords": ["cron", "crontab", "parser"],
+  "dependencies": {},
+  "development": {},
+  "main": "lib/parser.js",
+  "scripts": ["lib/parser.js", "lib/expression.js", "lib/date.js", "lib/field_compactor.js", "lib/field_stringify.js"]
+}

package/dist/node_modules/cron-parser/index.d.ts

@@ -0,0 +1 @@
+export * from './types'

package/dist/node_modules/cron-parser/lib/date.js

@@ -0,0 +1,252 @@
+'use strict';
+
+var luxon = require('luxon');
+
+CronDate.prototype.addYear = function() {
+  this._date = this._date.plus({ years: 1 });
+};
+
+CronDate.prototype.addMonth = function() {
+  this._date = this._date.plus({ months: 1 }).startOf('month');
+};
+
+CronDate.prototype.addDay = function() {
+  this._date = this._date.plus({ days: 1 }).startOf('day');
+};
+
+CronDate.prototype.addHour = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ hours: 1 }).startOf('hour');
+  if (this._date <= prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.addMinute = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ minutes: 1 }).startOf('minute');
+  if (this._date < prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.addSecond = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ seconds: 1 }).startOf('second');
+  if (this._date < prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractYear = function() {
+  this._date = this._date.minus({ years: 1 });
+};
+
+CronDate.prototype.subtractMonth = function() {
+  this._date = this._date
+    .minus({ months: 1 })
+    .endOf('month')
+    .startOf('second');
+};
+
+CronDate.prototype.subtractDay = function() {
+  this._date = this._date
+    .minus({ days: 1 })
+    .endOf('day')
+    .startOf('second');
+};
+
+CronDate.prototype.subtractHour = function() {
+  var prev = this._date;
+  this._date = this._date
+    .minus({ hours: 1 })
+    .endOf('hour')
+    .startOf('second');
+  if (this._date >= prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractMinute = function() {
+  var prev = this._date;
+  this._date = this._date.minus({ minutes: 1 })
+    .endOf('minute')
+    .startOf('second');
+  if (this._date > prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractSecond = function() {
+  var prev = this._date;
+  this._date = this._date
+    .minus({ seconds: 1 })
+    .startOf('second');
+  if (this._date > prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.getDate = function() {
+  return this._date.day;
+};
+
+CronDate.prototype.getFullYear = function() {
+  return this._date.year;
+};
+
+CronDate.prototype.getDay = function() {
+  var weekday = this._date.weekday;
+  return weekday == 7 ? 0 : weekday;
+};
+
+CronDate.prototype.getMonth = function() {
+  return this._date.month - 1;
+};
+
+CronDate.prototype.getHours = function() {
+  return this._date.hour;
+};
+
+CronDate.prototype.getMinutes = function() {
+  return this._date.minute;
+};
+
+CronDate.prototype.getSeconds = function() {
+  return this._date.second;
+};
+
+CronDate.prototype.getMilliseconds = function() {
+  return this._date.millisecond;
+};
+
+CronDate.prototype.getTime = function() {
+  return this._date.valueOf();
+};
+
+CronDate.prototype.getUTCDate = function() {
+  return this._getUTC().day;
+};
+
+CronDate.prototype.getUTCFullYear = function() {
+  return this._getUTC().year;
+};
+
+CronDate.prototype.getUTCDay = function() {
+  var weekday = this._getUTC().weekday;
+  return weekday == 7 ? 0 : weekday;
+};
+
+CronDate.prototype.getUTCMonth = function() {
+  return this._getUTC().month - 1;
+};
+
+CronDate.prototype.getUTCHours = function() {
+  return this._getUTC().hour;
+};
+
+CronDate.prototype.getUTCMinutes = function() {
+  return this._getUTC().minute;
+};
+
+CronDate.prototype.getUTCSeconds = function() {
+  return this._getUTC().second;
+};
+
+CronDate.prototype.toISOString = function() {
+  return this._date.toUTC().toISO();
+};
+
+CronDate.prototype.toJSON = function() {
+  return this._date.toJSON();
+};
+
+CronDate.prototype.setDate = function(d) {
+  this._date = this._date.set({ day: d });
+};
+
+CronDate.prototype.setFullYear = function(y) {
+  this._date = this._date.set({ year: y });
+};
+
+CronDate.prototype.setDay = function(d) {
+  this._date = this._date.set({ weekday: d });
+};
+
+CronDate.prototype.setMonth = function(m) {
+  this._date = this._date.set({ month: m + 1 });
+};
+
+CronDate.prototype.setHours = function(h) {
+  this._date = this._date.set({ hour: h });
+};
+
+CronDate.prototype.setMinutes = function(m) {
+  this._date = this._date.set({ minute: m });
+};
+
+CronDate.prototype.setSeconds = function(s) {
+  this._date = this._date.set({ second: s });
+};
+
+CronDate.prototype.setMilliseconds = function(s) {
+  this._date = this._date.set({ millisecond: s });
+};
+
+CronDate.prototype._getUTC = function() {
+  return this._date.toUTC();
+};
+
+CronDate.prototype.toString = function() {
+  return this.toDate().toString();
+};
+
+CronDate.prototype.toDate = function() {
+  return this._date.toJSDate();
+};
+
+CronDate.prototype.isLastDayOfMonth = function() {
+  //next day
+  var newDate = this._date.plus({ days: 1 }).startOf('day');
+  return this._date.month !== newDate.month;
+};
+
+/**
+ * Returns true when the current weekday is the last occurrence of this weekday
+ * for the present month.
+ */
+CronDate.prototype.isLastWeekdayOfMonth = function() {
+  // Check this by adding 7 days to the current date and seeing if it's
+  // a different month
+  var newDate = this._date.plus({ days: 7 }).startOf('day');
+  return this._date.month !== newDate.month;
+};
+
+function CronDate (timestamp, tz) {
+  var dateOpts = { zone: tz };
+  if (!timestamp) {
+    this._date = luxon.DateTime.local();
+  } else if (timestamp instanceof CronDate) {
+    this._date = timestamp._date;
+  } else if (timestamp instanceof Date) {
+    this._date = luxon.DateTime.fromJSDate(timestamp, dateOpts);
+  } else if (typeof timestamp === 'number') {
+    this._date = luxon.DateTime.fromMillis(timestamp, dateOpts);
+  } else if (typeof timestamp === 'string') {
+    this._date = luxon.DateTime.fromISO(timestamp, dateOpts);
+    this._date.isValid || (this._date = luxon.DateTime.fromRFC2822(timestamp, dateOpts));
+    this._date.isValid || (this._date = luxon.DateTime.fromSQL(timestamp, dateOpts));
+    // RFC2822-like format without the required timezone offset (used in tests)
+    this._date.isValid || (this._date = luxon.DateTime.fromFormat(timestamp, 'EEE, d MMM yyyy HH:mm:ss', dateOpts));
+  }
+
+  if (!this._date || !this._date.isValid) {
+    throw new Error('CronDate: unhandled timestamp: ' + JSON.stringify(timestamp));
+  }
+  
+  if (tz && tz !== this._date.zoneName) {
+    this._date = this._date.setZone(tz);
+  }
+}
+
+module.exports = CronDate;