@uides/stepwise 2.0.0-rc.32 → 2.0.2

package/generators/node_modules/minipass/dist/commonjs/index.js

@@ -0,0 +1,623 @@
+import * as __WEBPACK_EXTERNAL_MODULE_events__ from "events";
+import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+import * as __WEBPACK_EXTERNAL_MODULE_string_decoder__ from "string_decoder";
+var __webpack_modules__ = {
+    events: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_events__;
+    },
+    stream: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_stream__;
+    },
+    string_decoder: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_string_decoder__;
+    },
+    "./src/generators/node_modules/minipass/dist/commonjs/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Minipass = exports.isWritable = exports.isReadable = exports.isStream = void 0;
+        const proc = 'object' == typeof process && process ? process : {
+            stdout: null,
+            stderr: null
+        };
+        const events_1 = __webpack_require__("events");
+        const stream_1 = __importDefault(__webpack_require__("stream"));
+        const string_decoder_1 = __webpack_require__("string_decoder");
+        const isStream = (s)=>!!s && 'object' == typeof s && (s instanceof Minipass || s instanceof stream_1.default || (0, exports.isReadable)(s) || (0, exports.isWritable)(s));
+        exports.isStream = isStream;
+        const isReadable = (s)=>!!s && 'object' == typeof s && s instanceof events_1.EventEmitter && 'function' == typeof s.pipe && s.pipe !== stream_1.default.Writable.prototype.pipe;
+        exports.isReadable = isReadable;
+        const isWritable = (s)=>!!s && 'object' == typeof s && s instanceof events_1.EventEmitter && 'function' == typeof s.write && 'function' == typeof s.end;
+        exports.isWritable = isWritable;
+        const EOF = Symbol('EOF');
+        const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
+        const EMITTED_END = Symbol('emittedEnd');
+        const EMITTING_END = Symbol('emittingEnd');
+        const EMITTED_ERROR = Symbol('emittedError');
+        const CLOSED = Symbol('closed');
+        const READ = Symbol('read');
+        const FLUSH = Symbol('flush');
+        const FLUSHCHUNK = Symbol('flushChunk');
+        const ENCODING = Symbol('encoding');
+        const DECODER = Symbol('decoder');
+        const FLOWING = Symbol('flowing');
+        const PAUSED = Symbol('paused');
+        const RESUME = Symbol('resume');
+        const BUFFER = Symbol('buffer');
+        const PIPES = Symbol('pipes');
+        const BUFFERLENGTH = Symbol('bufferLength');
+        const BUFFERPUSH = Symbol('bufferPush');
+        const BUFFERSHIFT = Symbol('bufferShift');
+        const OBJECTMODE = Symbol('objectMode');
+        const DESTROYED = Symbol('destroyed');
+        const ERROR = Symbol('error');
+        const EMITDATA = Symbol('emitData');
+        const EMITEND = Symbol('emitEnd');
+        const EMITEND2 = Symbol('emitEnd2');
+        const ASYNC = Symbol('async');
+        const ABORT = Symbol('abort');
+        const ABORTED = Symbol('aborted');
+        const SIGNAL = Symbol('signal');
+        const DATALISTENERS = Symbol('dataListeners');
+        const DISCARDED = Symbol('discarded');
+        const defer = (fn)=>Promise.resolve().then(fn);
+        const nodefer = (fn)=>fn();
+        const isEndish = (ev)=>'end' === ev || 'finish' === ev || 'prefinish' === ev;
+        const isArrayBufferLike = (b)=>b instanceof ArrayBuffer || !!b && 'object' == typeof b && b.constructor && 'ArrayBuffer' === b.constructor.name && b.byteLength >= 0;
+        const isArrayBufferView = (b)=>!Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+        class Pipe {
+            src;
+            dest;
+            opts;
+            ondrain;
+            constructor(src, dest, opts){
+                this.src = src;
+                this.dest = dest;
+                this.opts = opts;
+                this.ondrain = ()=>src[RESUME]();
+                this.dest.on('drain', this.ondrain);
+            }
+            unpipe() {
+                this.dest.removeListener('drain', this.ondrain);
+            }
+            proxyErrors(_er) {}
+            end() {
+                this.unpipe();
+                if (this.opts.end) this.dest.end();
+            }
+        }
+        class PipeProxyErrors extends Pipe {
+            unpipe() {
+                this.src.removeListener('error', this.proxyErrors);
+                super.unpipe();
+            }
+            constructor(src, dest, opts){
+                super(src, dest, opts);
+                this.proxyErrors = (er)=>dest.emit('error', er);
+                src.on('error', this.proxyErrors);
+            }
+        }
+        const isObjectModeOptions = (o)=>!!o.objectMode;
+        const isEncodingOptions = (o)=>!o.objectMode && !!o.encoding && 'buffer' !== o.encoding;
+        class Minipass extends events_1.EventEmitter {
+            [FLOWING] = false;
+            [PAUSED] = false;
+            [PIPES] = [];
+            [BUFFER] = [];
+            [OBJECTMODE];
+            [ENCODING];
+            [ASYNC];
+            [DECODER];
+            [EOF] = false;
+            [EMITTED_END] = false;
+            [EMITTING_END] = false;
+            [CLOSED] = false;
+            [EMITTED_ERROR] = null;
+            [BUFFERLENGTH] = 0;
+            [DESTROYED] = false;
+            [SIGNAL];
+            [ABORTED] = false;
+            [DATALISTENERS] = 0;
+            [DISCARDED] = false;
+            writable = true;
+            readable = true;
+            constructor(...args){
+                const options = args[0] || {};
+                super();
+                if (options.objectMode && 'string' == typeof options.encoding) throw new TypeError('Encoding and objectMode may not be used together');
+                if (isObjectModeOptions(options)) {
+                    this[OBJECTMODE] = true;
+                    this[ENCODING] = null;
+                } else if (isEncodingOptions(options)) {
+                    this[ENCODING] = options.encoding;
+                    this[OBJECTMODE] = false;
+                } else {
+                    this[OBJECTMODE] = false;
+                    this[ENCODING] = null;
+                }
+                this[ASYNC] = !!options.async;
+                this[DECODER] = this[ENCODING] ? new string_decoder_1.StringDecoder(this[ENCODING]) : null;
+                if (options && true === options.debugExposeBuffer) Object.defineProperty(this, 'buffer', {
+                    get: ()=>this[BUFFER]
+                });
+                if (options && true === options.debugExposePipes) Object.defineProperty(this, 'pipes', {
+                    get: ()=>this[PIPES]
+                });
+                const { signal } = options;
+                if (signal) {
+                    this[SIGNAL] = signal;
+                    if (signal.aborted) this[ABORT]();
+                    else signal.addEventListener('abort', ()=>this[ABORT]());
+                }
+            }
+            get bufferLength() {
+                return this[BUFFERLENGTH];
+            }
+            get encoding() {
+                return this[ENCODING];
+            }
+            set encoding(_enc) {
+                throw new Error('Encoding must be set at instantiation time');
+            }
+            setEncoding(_enc) {
+                throw new Error('Encoding must be set at instantiation time');
+            }
+            get objectMode() {
+                return this[OBJECTMODE];
+            }
+            set objectMode(_om) {
+                throw new Error('objectMode must be set at instantiation time');
+            }
+            get ['async']() {
+                return this[ASYNC];
+            }
+            set ['async'](a) {
+                this[ASYNC] = this[ASYNC] || !!a;
+            }
+            [ABORT]() {
+                this[ABORTED] = true;
+                this.emit('abort', this[SIGNAL]?.reason);
+                this.destroy(this[SIGNAL]?.reason);
+            }
+            get aborted() {
+                return this[ABORTED];
+            }
+            set aborted(_) {}
+            write(chunk, encoding, cb) {
+                if (this[ABORTED]) return false;
+                if (this[EOF]) throw new Error('write after end');
+                if (this[DESTROYED]) {
+                    this.emit('error', Object.assign(new Error('Cannot call write after a stream was destroyed'), {
+                        code: 'ERR_STREAM_DESTROYED'
+                    }));
+                    return true;
+                }
+                if ('function' == typeof encoding) {
+                    cb = encoding;
+                    encoding = 'utf8';
+                }
+                if (!encoding) encoding = 'utf8';
+                const fn = this[ASYNC] ? defer : nodefer;
+                if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+                    if (isArrayBufferView(chunk)) chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                    else if (isArrayBufferLike(chunk)) chunk = Buffer.from(chunk);
+                    else if ('string' != typeof chunk) throw new Error('Non-contiguous data written to non-objectMode stream');
+                }
+                if (this[OBJECTMODE]) {
+                    if (this[FLOWING] && 0 !== this[BUFFERLENGTH]) this[FLUSH](true);
+                    if (this[FLOWING]) this.emit('data', chunk);
+                    else this[BUFFERPUSH](chunk);
+                    if (0 !== this[BUFFERLENGTH]) this.emit('readable');
+                    if (cb) fn(cb);
+                    return this[FLOWING];
+                }
+                if (!chunk.length) {
+                    if (0 !== this[BUFFERLENGTH]) this.emit('readable');
+                    if (cb) fn(cb);
+                    return this[FLOWING];
+                }
+                if ('string' == typeof chunk && !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) chunk = Buffer.from(chunk, encoding);
+                if (Buffer.isBuffer(chunk) && this[ENCODING]) chunk = this[DECODER].write(chunk);
+                if (this[FLOWING] && 0 !== this[BUFFERLENGTH]) this[FLUSH](true);
+                if (this[FLOWING]) this.emit('data', chunk);
+                else this[BUFFERPUSH](chunk);
+                if (0 !== this[BUFFERLENGTH]) this.emit('readable');
+                if (cb) fn(cb);
+                return this[FLOWING];
+            }
+            read(n) {
+                if (this[DESTROYED]) return null;
+                this[DISCARDED] = false;
+                if (0 === this[BUFFERLENGTH] || 0 === n || n && n > this[BUFFERLENGTH]) {
+                    this[MAYBE_EMIT_END]();
+                    return null;
+                }
+                if (this[OBJECTMODE]) n = null;
+                if (this[BUFFER].length > 1 && !this[OBJECTMODE]) this[BUFFER] = [
+                    this[ENCODING] ? this[BUFFER].join('') : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
+                ];
+                const ret = this[READ](n || null, this[BUFFER][0]);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [READ](n, chunk) {
+                if (this[OBJECTMODE]) this[BUFFERSHIFT]();
+                else {
+                    const c = chunk;
+                    if (n === c.length || null === n) this[BUFFERSHIFT]();
+                    else if ('string' == typeof c) {
+                        this[BUFFER][0] = c.slice(n);
+                        chunk = c.slice(0, n);
+                        this[BUFFERLENGTH] -= n;
+                    } else {
+                        this[BUFFER][0] = c.subarray(n);
+                        chunk = c.subarray(0, n);
+                        this[BUFFERLENGTH] -= n;
+                    }
+                }
+                this.emit('data', chunk);
+                if (!this[BUFFER].length && !this[EOF]) this.emit('drain');
+                return chunk;
+            }
+            end(chunk, encoding, cb) {
+                if ('function' == typeof chunk) {
+                    cb = chunk;
+                    chunk = void 0;
+                }
+                if ('function' == typeof encoding) {
+                    cb = encoding;
+                    encoding = 'utf8';
+                }
+                if (void 0 !== chunk) this.write(chunk, encoding);
+                if (cb) this.once('end', cb);
+                this[EOF] = true;
+                this.writable = false;
+                if (this[FLOWING] || !this[PAUSED]) this[MAYBE_EMIT_END]();
+                return this;
+            }
+            [RESUME]() {
+                if (this[DESTROYED]) return;
+                if (!this[DATALISTENERS] && !this[PIPES].length) this[DISCARDED] = true;
+                this[PAUSED] = false;
+                this[FLOWING] = true;
+                this.emit('resume');
+                if (this[BUFFER].length) this[FLUSH]();
+                else if (this[EOF]) this[MAYBE_EMIT_END]();
+                else this.emit('drain');
+            }
+            resume() {
+                return this[RESUME]();
+            }
+            pause() {
+                this[FLOWING] = false;
+                this[PAUSED] = true;
+                this[DISCARDED] = false;
+            }
+            get destroyed() {
+                return this[DESTROYED];
+            }
+            get flowing() {
+                return this[FLOWING];
+            }
+            get paused() {
+                return this[PAUSED];
+            }
+            [BUFFERPUSH](chunk) {
+                if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1;
+                else this[BUFFERLENGTH] += chunk.length;
+                this[BUFFER].push(chunk);
+            }
+            [BUFFERSHIFT]() {
+                if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1;
+                else this[BUFFERLENGTH] -= this[BUFFER][0].length;
+                return this[BUFFER].shift();
+            }
+            [FLUSH](noDrain = false) {
+                do ;
+                while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
+                if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit('drain');
+            }
+            [FLUSHCHUNK](chunk) {
+                this.emit('data', chunk);
+                return this[FLOWING];
+            }
+            pipe(dest, opts) {
+                if (this[DESTROYED]) return dest;
+                this[DISCARDED] = false;
+                const ended = this[EMITTED_END];
+                opts = opts || {};
+                if (dest === proc.stdout || dest === proc.stderr) opts.end = false;
+                else opts.end = false !== opts.end;
+                opts.proxyErrors = !!opts.proxyErrors;
+                if (ended) {
+                    if (opts.end) dest.end();
+                } else {
+                    this[PIPES].push(opts.proxyErrors ? new PipeProxyErrors(this, dest, opts) : new Pipe(this, dest, opts));
+                    if (this[ASYNC]) defer(()=>this[RESUME]());
+                    else this[RESUME]();
+                }
+                return dest;
+            }
+            unpipe(dest) {
+                const p = this[PIPES].find((p)=>p.dest === dest);
+                if (p) {
+                    if (1 === this[PIPES].length) {
+                        if (this[FLOWING] && 0 === this[DATALISTENERS]) this[FLOWING] = false;
+                        this[PIPES] = [];
+                    } else this[PIPES].splice(this[PIPES].indexOf(p), 1);
+                    p.unpipe();
+                }
+            }
+            addListener(ev, handler) {
+                return this.on(ev, handler);
+            }
+            on(ev, handler) {
+                const ret = super.on(ev, handler);
+                if ('data' === ev) {
+                    this[DISCARDED] = false;
+                    this[DATALISTENERS]++;
+                    if (!this[PIPES].length && !this[FLOWING]) this[RESUME]();
+                } else if ('readable' === ev && 0 !== this[BUFFERLENGTH]) super.emit('readable');
+                else if (isEndish(ev) && this[EMITTED_END]) {
+                    super.emit(ev);
+                    this.removeAllListeners(ev);
+                } else if ('error' === ev && this[EMITTED_ERROR]) {
+                    const h = handler;
+                    if (this[ASYNC]) defer(()=>h.call(this, this[EMITTED_ERROR]));
+                    else h.call(this, this[EMITTED_ERROR]);
+                }
+                return ret;
+            }
+            removeListener(ev, handler) {
+                return this.off(ev, handler);
+            }
+            off(ev, handler) {
+                const ret = super.off(ev, handler);
+                if ('data' === ev) {
+                    this[DATALISTENERS] = this.listeners('data').length;
+                    if (0 === this[DATALISTENERS] && !this[DISCARDED] && !this[PIPES].length) this[FLOWING] = false;
+                }
+                return ret;
+            }
+            removeAllListeners(ev) {
+                const ret = super.removeAllListeners(ev);
+                if ('data' === ev || void 0 === ev) {
+                    this[DATALISTENERS] = 0;
+                    if (!this[DISCARDED] && !this[PIPES].length) this[FLOWING] = false;
+                }
+                return ret;
+            }
+            get emittedEnd() {
+                return this[EMITTED_END];
+            }
+            [MAYBE_EMIT_END]() {
+                if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && 0 === this[BUFFER].length && this[EOF]) {
+                    this[EMITTING_END] = true;
+                    this.emit('end');
+                    this.emit('prefinish');
+                    this.emit('finish');
+                    if (this[CLOSED]) this.emit('close');
+                    this[EMITTING_END] = false;
+                }
+            }
+            emit(ev, ...args) {
+                const data = args[0];
+                if ('error' !== ev && 'close' !== ev && ev !== DESTROYED && this[DESTROYED]) return false;
+                if ('data' === ev) return this[OBJECTMODE] || data ? this[ASYNC] ? (defer(()=>this[EMITDATA](data)), true) : this[EMITDATA](data) : false;
+                if ('end' === ev) return this[EMITEND]();
+                if ('close' === ev) {
+                    this[CLOSED] = true;
+                    if (!this[EMITTED_END] && !this[DESTROYED]) return false;
+                    const ret = super.emit('close');
+                    this.removeAllListeners('close');
+                    return ret;
+                }
+                if ('error' === ev) {
+                    this[EMITTED_ERROR] = data;
+                    super.emit(ERROR, data);
+                    const ret = !this[SIGNAL] || this.listeners('error').length ? super.emit('error', data) : false;
+                    this[MAYBE_EMIT_END]();
+                    return ret;
+                } else if ('resume' === ev) {
+                    const ret = super.emit('resume');
+                    this[MAYBE_EMIT_END]();
+                    return ret;
+                } else if ('finish' === ev || 'prefinish' === ev) {
+                    const ret = super.emit(ev);
+                    this.removeAllListeners(ev);
+                    return ret;
+                }
+                const ret = super.emit(ev, ...args);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [EMITDATA](data) {
+                for (const p of this[PIPES])if (false === p.dest.write(data)) this.pause();
+                const ret = this[DISCARDED] ? false : super.emit('data', data);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [EMITEND]() {
+                if (this[EMITTED_END]) return false;
+                this[EMITTED_END] = true;
+                this.readable = false;
+                return this[ASYNC] ? (defer(()=>this[EMITEND2]()), true) : this[EMITEND2]();
+            }
+            [EMITEND2]() {
+                if (this[DECODER]) {
+                    const data = this[DECODER].end();
+                    if (data) {
+                        for (const p of this[PIPES])p.dest.write(data);
+                        if (!this[DISCARDED]) super.emit('data', data);
+                    }
+                }
+                for (const p of this[PIPES])p.end();
+                const ret = super.emit('end');
+                this.removeAllListeners('end');
+                return ret;
+            }
+            async collect() {
+                const buf = Object.assign([], {
+                    dataLength: 0
+                });
+                if (!this[OBJECTMODE]) buf.dataLength = 0;
+                const p = this.promise();
+                this.on('data', (c)=>{
+                    buf.push(c);
+                    if (!this[OBJECTMODE]) buf.dataLength += c.length;
+                });
+                await p;
+                return buf;
+            }
+            async concat() {
+                if (this[OBJECTMODE]) throw new Error('cannot concat in objectMode');
+                const buf = await this.collect();
+                return this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength);
+            }
+            async promise() {
+                return new Promise((resolve, reject)=>{
+                    this.on(DESTROYED, ()=>reject(new Error('stream destroyed')));
+                    this.on('error', (er)=>reject(er));
+                    this.on('end', ()=>resolve());
+                });
+            }
+            [Symbol.asyncIterator]() {
+                this[DISCARDED] = false;
+                let stopped = false;
+                const stop = async ()=>{
+                    this.pause();
+                    stopped = true;
+                    return {
+                        value: void 0,
+                        done: true
+                    };
+                };
+                const next = ()=>{
+                    if (stopped) return stop();
+                    const res = this.read();
+                    if (null !== res) return Promise.resolve({
+                        done: false,
+                        value: res
+                    });
+                    if (this[EOF]) return stop();
+                    let resolve;
+                    let reject;
+                    const onerr = (er)=>{
+                        this.off('data', ondata);
+                        this.off('end', onend);
+                        this.off(DESTROYED, ondestroy);
+                        stop();
+                        reject(er);
+                    };
+                    const ondata = (value)=>{
+                        this.off('error', onerr);
+                        this.off('end', onend);
+                        this.off(DESTROYED, ondestroy);
+                        this.pause();
+                        resolve({
+                            value,
+                            done: !!this[EOF]
+                        });
+                    };
+                    const onend = ()=>{
+                        this.off('error', onerr);
+                        this.off('data', ondata);
+                        this.off(DESTROYED, ondestroy);
+                        stop();
+                        resolve({
+                            done: true,
+                            value: void 0
+                        });
+                    };
+                    const ondestroy = ()=>onerr(new Error('stream destroyed'));
+                    return new Promise((res, rej)=>{
+                        reject = rej;
+                        resolve = res;
+                        this.once(DESTROYED, ondestroy);
+                        this.once('error', onerr);
+                        this.once('end', onend);
+                        this.once('data', ondata);
+                    });
+                };
+                return {
+                    next,
+                    throw: stop,
+                    return: stop,
+                    [Symbol.asyncIterator] () {
+                        return this;
+                    }
+                };
+            }
+            [Symbol.iterator]() {
+                this[DISCARDED] = false;
+                let stopped = false;
+                const stop = ()=>{
+                    this.pause();
+                    this.off(ERROR, stop);
+                    this.off(DESTROYED, stop);
+                    this.off('end', stop);
+                    stopped = true;
+                    return {
+                        done: true,
+                        value: void 0
+                    };
+                };
+                const next = ()=>{
+                    if (stopped) return stop();
+                    const value = this.read();
+                    return null === value ? stop() : {
+                        done: false,
+                        value
+                    };
+                };
+                this.once('end', stop);
+                this.once(ERROR, stop);
+                this.once(DESTROYED, stop);
+                return {
+                    next,
+                    throw: stop,
+                    return: stop,
+                    [Symbol.iterator] () {
+                        return this;
+                    }
+                };
+            }
+            destroy(er) {
+                if (this[DESTROYED]) {
+                    if (er) this.emit('error', er);
+                    else this.emit(DESTROYED);
+                    return this;
+                }
+                this[DESTROYED] = true;
+                this[DISCARDED] = true;
+                this[BUFFER].length = 0;
+                this[BUFFERLENGTH] = 0;
+                const wc = this;
+                if ('function' == typeof wc.close && !this[CLOSED]) wc.close();
+                if (er) this.emit('error', er);
+                else this.emit(DESTROYED);
+                return this;
+            }
+            static get isStream() {
+                return exports.isStream;
+            }
+        }
+        exports.Minipass = Minipass;
+    }
+};
+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].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__("./src/generators/node_modules/minipass/dist/commonjs/index.js");