projen-pipelines 0.2.2 → 0.2.3

package/node_modules/resolve/lib/core.json

@@ -89,7 +89,9 @@
 	"node:readline/promises": ">= 17",
 	"repl": true,
 	"node:repl": [">= 14.18 && < 15", ">= 16"],
+	"node:sea": [">= 20.12 && < 21", ">= 21.7"],
 	"smalloc": ">= 0.11.5 && < 3",
+	"node:sqlite": ">= 23.4",
 	"_stream_duplex": ">= 0.9.4",
 	"node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
 	"_stream_transform": ">= 0.9.4",
@@ -116,6 +118,8 @@
 	"node:sys": [">= 14.18 && < 15", ">= 16"],
 	"test/reporters": ">= 19.9 && < 20.2",
 	"node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+	"test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test/mock_loader": ">= 22.3 && < 22.7",
 	"node:test": [">= 16.17 && < 17", ">= 18"],
 	"timers": true,
 	"node:timers": [">= 14.18 && < 15", ">= 16"],

package/node_modules/resolve/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "resolve",
 	"description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
-	"version": "1.22.8",
+	"version": "1.22.10",
 	"repository": {
 		"type": "git",
 		"url": "git://github.com/browserify/resolve.git"
@@ -26,26 +26,25 @@
 		"tests-only": "tape test/*.js",
 		"pretest": "npm run lint",
 		"test": "npm run --silent tests-only",
-		"posttest": "npm run test:multirepo && aud --production",
+		"posttest": "npm run test:multirepo && npx npm@'>= 10.2' audit --production",
 		"test:multirepo": "cd ./test/resolver/multirepo && npm install && npm test"
 	},
 	"devDependencies": {
-		"@ljharb/eslint-config": "^21.1.0",
-		"array.prototype.map": "^1.0.6",
-		"aud": "^2.0.3",
+		"@ljharb/eslint-config": "^21.1.1",
+		"array.prototype.map": "^1.0.7",
 		"copy-dir": "^1.3.0",
 		"eclint": "^2.8.1",
 		"eslint": "=8.8.0",
 		"in-publish": "^2.0.1",
 		"mkdirp": "^0.5.5",
 		"mv": "^2.1.1",
-		"npmignore": "^0.3.0",
+		"npmignore": "^0.3.1",
 		"object-keys": "^1.1.1",
 		"rimraf": "^2.7.1",
 		"safe-publish-latest": "^2.0.0",
 		"semver": "^6.3.1",
 		"tap": "0.4.13",
-		"tape": "^5.7.0",
+		"tape": "^5.9.0",
 		"tmp": "^0.0.31"
 	},
 	"license": "MIT",
@@ -58,7 +57,7 @@
 		"url": "https://github.com/sponsors/ljharb"
 	},
 	"dependencies": {
-		"is-core-module": "^2.13.0",
+		"is-core-module": "^2.16.0",
 		"path-parse": "^1.0.7",
 		"supports-preserve-symlinks-flag": "^1.0.0"
 	},
@@ -66,7 +65,11 @@
 		"ignore": [
 			".github/workflows",
 			"appveyor.yml",
-			"test/resolver/malformed_package_json"
+			"test/resolver/malformed_package_json",
+			"test/list-exports"
 		]
+	},
+	"engines": {
+		"node": ">= 0.4"
 	}
 }

package/node_modules/{get-pkg-repo → standard-version}/node_modules/through2/README.md

@@ -1,17 +1,17 @@
 # through2
 
+![Build & Test](https://github.com/rvagg/through2/workflows/Build%20&%20Test/badge.svg)
+
 [![NPM](https://nodei.co/npm/through2.png?downloads&downloadRank)](https://nodei.co/npm/through2/)
 
-**A tiny wrapper around Node streams.Transform (Streams2/3) to avoid explicit subclassing noise**
+**A tiny wrapper around Node.js streams.Transform (Streams2/3) to avoid explicit subclassing noise**
 
 Inspired by [Dominic Tarr](https://github.com/dominictarr)'s [through](https://github.com/dominictarr/through) in that it's so much easier to make a stream out of a function than it is to set up the prototype chain properly: `through(function (chunk) { ... })`.
 
-Note: As 2.x.x this module starts using **Streams3** instead of Stream2. To continue using a Streams2 version use `npm install through2@0` to fetch the latest version of 0.x.x. More information about Streams2 vs Streams3 and recommendations see the article **[Why I don't use Node's core 'stream' module](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html)**.
-
 ```js
 fs.createReadStream('ex.txt')
   .pipe(through2(function (chunk, enc, callback) {
-    for (var i = 0; i < chunk.length; i++)
+    for (let i = 0; i < chunk.length; i++)
       if (chunk[i] == 97)
         chunk[i] = 122 // swap 'a' for 'z'
 
@@ -26,12 +26,12 @@ fs.createReadStream('ex.txt')
 Or object streams:
 
 ```js
-var all = []
+const all = []
 
 fs.createReadStream('data.csv')
   .pipe(csv2())
   .pipe(through2.obj(function (chunk, enc, callback) {
-    var data = {
+    const data = {
         name    : chunk[0]
       , address : chunk[3]
       , phone   : chunk[10]
@@ -50,11 +50,25 @@ fs.createReadStream('data.csv')
 
 Note that `through2.obj(fn)` is a convenience wrapper around `through2({ objectMode: true }, fn)`.
 
+## Do you need this?
+
+Since Node.js introduced [Simplified Stream Construction](https://nodejs.org/api/stream.html#stream_simplified_construction), many uses of **through2** have become redundant. Consider whether you really need to use **through2** or just want to use the `'readable-stream'` package, or the core `'stream'` package (which is derived from `'readable-stream'`):
+
+```js
+const { Transform } = require('readable-stream')
+
+const transformer = new Transform({
+  transform(chunk, enc, callback) {
+    // ...
+  }
+})
+```
+
 ## API
 
 <b><code>through2([ options, ] [ transformFunction ] [, flushFunction ])</code></b>
 
-Consult the **[stream.Transform](http://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
+Consult the **[stream.Transform](https://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
 
 ### options
 
@@ -69,7 +83,7 @@ fs.createReadStream('/tmp/important.dat')
       cb(null, 'wut?') // note we can use the second argument on the callback
                        // to provide data as an alternative to this.push('wut?')
     }
-  )
+  ))
   .pipe(fs.createWriteStream('/tmp/wut.txt'))
 ```
 
@@ -104,7 +118,7 @@ fs.createReadStream('/tmp/important.dat')
 Instead of returning a `stream.Transform` instance, `through2.ctor()` returns a **constructor** for a custom Transform. This is useful when you want to use the same transform logic in multiple instances.
 
 ```js
-var FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
+const FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
   if (record.temp != null && record.unit == "F") {
     record.temp = ( ( record.temp - 32 ) * 5 ) / 9
     record.unit = "C"
@@ -114,21 +128,13 @@ var FToC = through2.ctor({objectMode: true}, function (record, encoding, callbac
 })
 
 // Create instances of FToC like so:
-var converter = new FToC()
+const converter = new FToC()
 // Or:
-var converter = FToC()
+const converter = FToC()
 // Or specify/override options when you instantiate, if you prefer:
-var converter = FToC({objectMode: true})
+const converter = FToC({objectMode: true})
 ```
 
-## See Also
-
-  - [through2-map](https://github.com/brycebaril/through2-map) - Array.prototype.map analog for streams.
-  - [through2-filter](https://github.com/brycebaril/through2-filter) - Array.prototype.filter analog for streams.
-  - [through2-reduce](https://github.com/brycebaril/through2-reduce) - Array.prototype.reduce analog for streams.
-  - [through2-spy](https://github.com/brycebaril/through2-spy) - Wrapper for simple stream.PassThrough spies.
-  - the [mississippi stream utility collection](https://github.com/maxogden/mississippi) includes `through2` as well as many more useful stream modules similar to this one
-
 ## License
 
-**through2** is Copyright (c) Rod Vagg [@rvagg](https://twitter.com/rvagg) and additional contributors and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
+**through2** is Copyright &copy; Rod Vagg and additional contributors and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

package/node_modules/standard-version/node_modules/through2/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "through2",
+  "version": "4.0.2",
+  "description": "A tiny wrapper around Node.js streams.Transform (Streams2/3) to avoid explicit subclassing noise",
+  "main": "through2.js",
+  "scripts": {
+    "test:node": "hundreds mocha test/test.js",
+    "test:browser": "node -e 'process.exit(process.version.startsWith(\"v8.\") ? 0 : 1)' || polendina --cleanup --runner=mocha test/test.js",
+    "test": "npm run lint && npm run test:node && npm run test:browser",
+    "lint": "standard",
+    "coverage": "c8 --reporter=text --reporter=html mocha test/test.js && npx st -d coverage -p 8888"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rvagg/through2.git"
+  },
+  "keywords": [
+    "stream",
+    "streams2",
+    "through",
+    "transform"
+  ],
+  "author": "Rod Vagg <r@va.gg> (https://github.com/rvagg)",
+  "license": "MIT",
+  "dependencies": {
+    "readable-stream": "3"
+  },
+  "devDependencies": {
+    "bl": "^4.0.2",
+    "buffer": "^5.6.0",
+    "chai": "^4.2.0",
+    "hundreds": "~0.0.7",
+    "mocha": "^7.2.0",
+    "polendina": "^1.0.0",
+    "standard": "^14.3.4",
+    "stream-spigot": "^3.0.6"
+  }
+}

package/node_modules/standard-version/node_modules/through2/through2.js

@@ -0,0 +1,83 @@
+const { Transform } = require('readable-stream')
+
+function inherits (fn, sup) {
+  fn.super_ = sup
+  fn.prototype = Object.create(sup.prototype, {
+    constructor: { value: fn, enumerable: false, writable: true, configurable: true }
+  })
+}
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+  return (options, transform, flush) => {
+    if (typeof options === 'function') {
+      flush = transform
+      transform = options
+      options = {}
+    }
+
+    if (typeof transform !== 'function') {
+      // noop
+      transform = (chunk, enc, cb) => cb(null, chunk)
+    }
+
+    if (typeof flush !== 'function') {
+      flush = null
+    }
+
+    return construct(options, transform, flush)
+  }
+}
+
+// main export, just make me a transform stream!
+const make = through2((options, transform, flush) => {
+  const t2 = new Transform(options)
+
+  t2._transform = transform
+
+  if (flush) {
+    t2._flush = flush
+  }
+
+  return t2
+})
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+const ctor = through2((options, transform, flush) => {
+  function Through2 (override) {
+    if (!(this instanceof Through2)) {
+      return new Through2(override)
+    }
+
+    this.options = Object.assign({}, options, override)
+
+    Transform.call(this, this.options)
+
+    this._transform = transform
+    if (flush) {
+      this._flush = flush
+    }
+  }
+
+  inherits(Through2, Transform)
+
+  return Through2
+})
+
+const obj = through2(function (options, transform, flush) {
+  const t2 = new Transform(Object.assign({ objectMode: true, highWaterMark: 16 }, options))
+
+  t2._transform = transform
+
+  if (flush) {
+    t2._flush = flush
+  }
+
+  return t2
+})
+
+module.exports = make
+module.exports.ctor = ctor
+module.exports.obj = obj

package/node_modules/through2/README.md

@@ -1,17 +1,17 @@
 # through2
 
-![Build & Test](https://github.com/rvagg/through2/workflows/Build%20&%20Test/badge.svg)
-
 [![NPM](https://nodei.co/npm/through2.png?downloads&downloadRank)](https://nodei.co/npm/through2/)
 
-**A tiny wrapper around Node.js streams.Transform (Streams2/3) to avoid explicit subclassing noise**
+**A tiny wrapper around Node streams.Transform (Streams2/3) to avoid explicit subclassing noise**
 
 Inspired by [Dominic Tarr](https://github.com/dominictarr)'s [through](https://github.com/dominictarr/through) in that it's so much easier to make a stream out of a function than it is to set up the prototype chain properly: `through(function (chunk) { ... })`.
 
+Note: As 2.x.x this module starts using **Streams3** instead of Stream2. To continue using a Streams2 version use `npm install through2@0` to fetch the latest version of 0.x.x. More information about Streams2 vs Streams3 and recommendations see the article **[Why I don't use Node's core 'stream' module](http://r.va.gg/2014/06/why-i-dont-use-nodes-core-stream-module.html)**.
+
 ```js
 fs.createReadStream('ex.txt')
   .pipe(through2(function (chunk, enc, callback) {
-    for (let i = 0; i < chunk.length; i++)
+    for (var i = 0; i < chunk.length; i++)
       if (chunk[i] == 97)
         chunk[i] = 122 // swap 'a' for 'z'
 
@@ -26,12 +26,12 @@ fs.createReadStream('ex.txt')
 Or object streams:
 
 ```js
-const all = []
+var all = []
 
 fs.createReadStream('data.csv')
   .pipe(csv2())
   .pipe(through2.obj(function (chunk, enc, callback) {
-    const data = {
+    var data = {
         name    : chunk[0]
       , address : chunk[3]
       , phone   : chunk[10]
@@ -50,25 +50,11 @@ fs.createReadStream('data.csv')
 
 Note that `through2.obj(fn)` is a convenience wrapper around `through2({ objectMode: true }, fn)`.
 
-## Do you need this?
-
-Since Node.js introduced [Simplified Stream Construction](https://nodejs.org/api/stream.html#stream_simplified_construction), many uses of **through2** have become redundant. Consider whether you really need to use **through2** or just want to use the `'readable-stream'` package, or the core `'stream'` package (which is derived from `'readable-stream'`):
-
-```js
-const { Transform } = require('readable-stream')
-
-const transformer = new Transform({
-  transform(chunk, enc, callback) {
-    // ...
-  }
-})
-```
-
 ## API
 
 <b><code>through2([ options, ] [ transformFunction ] [, flushFunction ])</code></b>
 
-Consult the **[stream.Transform](https://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
+Consult the **[stream.Transform](http://nodejs.org/docs/latest/api/stream.html#stream_class_stream_transform)** documentation for the exact rules of the `transformFunction` (i.e. `this._transform`) and the optional `flushFunction` (i.e. `this._flush`).
 
 ### options
 
@@ -83,7 +69,7 @@ fs.createReadStream('/tmp/important.dat')
       cb(null, 'wut?') // note we can use the second argument on the callback
                        // to provide data as an alternative to this.push('wut?')
     }
-  ))
+  )
   .pipe(fs.createWriteStream('/tmp/wut.txt'))
 ```
 
@@ -118,7 +104,7 @@ fs.createReadStream('/tmp/important.dat')
 Instead of returning a `stream.Transform` instance, `through2.ctor()` returns a **constructor** for a custom Transform. This is useful when you want to use the same transform logic in multiple instances.
 
 ```js
-const FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
+var FToC = through2.ctor({objectMode: true}, function (record, encoding, callback) {
   if (record.temp != null && record.unit == "F") {
     record.temp = ( ( record.temp - 32 ) * 5 ) / 9
     record.unit = "C"
@@ -128,13 +114,21 @@ const FToC = through2.ctor({objectMode: true}, function (record, encoding, callb
 })
 
 // Create instances of FToC like so:
-const converter = new FToC()
+var converter = new FToC()
 // Or:
-const converter = FToC()
+var converter = FToC()
 // Or specify/override options when you instantiate, if you prefer:
-const converter = FToC({objectMode: true})
+var converter = FToC({objectMode: true})
 ```
 
+## See Also
+
+  - [through2-map](https://github.com/brycebaril/through2-map) - Array.prototype.map analog for streams.
+  - [through2-filter](https://github.com/brycebaril/through2-filter) - Array.prototype.filter analog for streams.
+  - [through2-reduce](https://github.com/brycebaril/through2-reduce) - Array.prototype.reduce analog for streams.
+  - [through2-spy](https://github.com/brycebaril/through2-spy) - Wrapper for simple stream.PassThrough spies.
+  - the [mississippi stream utility collection](https://github.com/maxogden/mississippi) includes `through2` as well as many more useful stream modules similar to this one
+
 ## License
 
-**through2** is Copyright &copy; Rod Vagg and additional contributors and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
+**through2** is Copyright (c) Rod Vagg [@rvagg](https://twitter.com/rvagg) and additional contributors and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

package/node_modules/through2/package.json

@@ -1,14 +1,10 @@
 {
   "name": "through2",
-  "version": "4.0.2",
-  "description": "A tiny wrapper around Node.js streams.Transform (Streams2/3) to avoid explicit subclassing noise",
+  "version": "2.0.5",
+  "description": "A tiny wrapper around Node streams2 Transform to avoid explicit subclassing noise",
   "main": "through2.js",
   "scripts": {
-    "test:node": "hundreds mocha test/test.js",
-    "test:browser": "node -e 'process.exit(process.version.startsWith(\"v8.\") ? 0 : 1)' || polendina --cleanup --runner=mocha test/test.js",
-    "test": "npm run lint && npm run test:node && npm run test:browser",
-    "lint": "standard",
-    "coverage": "c8 --reporter=text --reporter=html mocha test/test.js && npx st -d coverage -p 8888"
+    "test": "node test/test.js | faucet"
   },
   "repository": {
     "type": "git",
@@ -23,16 +19,15 @@
   "author": "Rod Vagg <r@va.gg> (https://github.com/rvagg)",
   "license": "MIT",
   "dependencies": {
-    "readable-stream": "3"
+    "readable-stream": "~2.3.6",
+    "xtend": "~4.0.1"
   },
   "devDependencies": {
-    "bl": "^4.0.2",
-    "buffer": "^5.6.0",
-    "chai": "^4.2.0",
-    "hundreds": "~0.0.7",
-    "mocha": "^7.2.0",
-    "polendina": "^1.0.0",
-    "standard": "^14.3.4",
-    "stream-spigot": "^3.0.6"
+    "bl": "~2.0.1",
+    "faucet": "0.0.1",
+    "nyc": "~13.1.0",
+    "safe-buffer": "~5.1.2",
+    "stream-spigot": "~3.0.6",
+    "tape": "~4.9.1"
   }
 }

package/node_modules/through2/through2.js

@@ -1,83 +1,96 @@
-const { Transform } = require('readable-stream')
+var Transform = require('readable-stream').Transform
+  , inherits  = require('util').inherits
+  , xtend     = require('xtend')
 
-function inherits (fn, sup) {
-  fn.super_ = sup
-  fn.prototype = Object.create(sup.prototype, {
-    constructor: { value: fn, enumerable: false, writable: true, configurable: true }
+function DestroyableTransform(opts) {
+  Transform.call(this, opts)
+  this._destroyed = false
+}
+
+inherits(DestroyableTransform, Transform)
+
+DestroyableTransform.prototype.destroy = function(err) {
+  if (this._destroyed) return
+  this._destroyed = true
+  
+  var self = this
+  process.nextTick(function() {
+    if (err)
+      self.emit('error', err)
+    self.emit('close')
   })
 }
 
+// a noop _transform function
+function noop (chunk, enc, callback) {
+  callback(null, chunk)
+}
+
+
 // create a new export function, used by both the main export and
 // the .ctor export, contains common logic for dealing with arguments
 function through2 (construct) {
-  return (options, transform, flush) => {
-    if (typeof options === 'function') {
-      flush = transform
+  return function (options, transform, flush) {
+    if (typeof options == 'function') {
+      flush     = transform
       transform = options
-      options = {}
+      options   = {}
     }
 
-    if (typeof transform !== 'function') {
-      // noop
-      transform = (chunk, enc, cb) => cb(null, chunk)
-    }
+    if (typeof transform != 'function')
+      transform = noop
 
-    if (typeof flush !== 'function') {
+    if (typeof flush != 'function')
       flush = null
-    }
 
     return construct(options, transform, flush)
   }
 }
 
+
 // main export, just make me a transform stream!
-const make = through2((options, transform, flush) => {
-  const t2 = new Transform(options)
+module.exports = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(options)
 
   t2._transform = transform
 
-  if (flush) {
+  if (flush)
     t2._flush = flush
-  }
 
   return t2
 })
 
+
 // make me a reusable prototype that I can `new`, or implicitly `new`
 // with a constructor call
-const ctor = through2((options, transform, flush) => {
+module.exports.ctor = through2(function (options, transform, flush) {
   function Through2 (override) {
-    if (!(this instanceof Through2)) {
+    if (!(this instanceof Through2))
       return new Through2(override)
-    }
-
-    this.options = Object.assign({}, options, override)
 
-    Transform.call(this, this.options)
+    this.options = xtend(options, override)
 
-    this._transform = transform
-    if (flush) {
-      this._flush = flush
-    }
+    DestroyableTransform.call(this, this.options)
   }
 
-  inherits(Through2, Transform)
+  inherits(Through2, DestroyableTransform)
+
+  Through2.prototype._transform = transform
+
+  if (flush)
+    Through2.prototype._flush = flush
 
   return Through2
 })
 
-const obj = through2(function (options, transform, flush) {
-  const t2 = new Transform(Object.assign({ objectMode: true, highWaterMark: 16 }, options))
+
+module.exports.obj = through2(function (options, transform, flush) {
+  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))
 
   t2._transform = transform
 
-  if (flush) {
+  if (flush)
     t2._flush = flush
-  }
 
   return t2
 })
-
-module.exports = make
-module.exports.ctor = ctor
-module.exports.obj = obj