@uides/stepwise 2.0.0-rc.33 → 2.0.3

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

@@ -0,0 +1,584 @@
+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";
+const proc = 'object' == typeof process && process ? process : {
+    stdout: null,
+    stderr: null
+};
+const isStream = (s)=>!!s && 'object' == typeof s && (s instanceof Minipass || s instanceof __WEBPACK_EXTERNAL_MODULE_stream__["default"] || isReadable(s) || isWritable(s));
+const isReadable = (s)=>!!s && 'object' == typeof s && s instanceof __WEBPACK_EXTERNAL_MODULE_events__.EventEmitter && 'function' == typeof s.pipe && s.pipe !== __WEBPACK_EXTERNAL_MODULE_stream__["default"].Writable.prototype.pipe;
+const isWritable = (s)=>!!s && 'object' == typeof s && s instanceof __WEBPACK_EXTERNAL_MODULE_events__.EventEmitter && 'function' == typeof s.write && 'function' == typeof s.end;
+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 __WEBPACK_EXTERNAL_MODULE_events__.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 __WEBPACK_EXTERNAL_MODULE_string_decoder__.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 isStream;
+    }
+}
+export { Minipass, isReadable, isStream, isWritable };

package/generators/node_modules/path-key/index.js

@@ -0,0 +1,23 @@
+var __webpack_modules__ = {
+    "./src/generators/node_modules/path-key/index.js": function(module) {
+        const pathKey = (options = {})=>{
+            const environment = options.env || process.env;
+            const platform = options.platform || process.platform;
+            if ('win32' !== platform) return 'PATH';
+            return Object.keys(environment).reverse().find((key)=>'PATH' === key.toUpperCase()) || 'Path';
+        };
+        module.exports = pathKey;
+        module.exports["default"] = pathKey;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__("./src/generators/node_modules/path-key/index.js");