@uides/stepwise 2.0.0-rc.32 → 2.0.2

package/generators/node_modules/minimatch/dist/cjs/unescape.js

@@ -0,0 +1,10 @@
+var __webpack_exports__ = {};
+(()=>{
+    var exports = __webpack_exports__;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.unescape = void 0;
+    const unescape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+    exports.unescape = unescape;
+})();

package/generators/node_modules/minimatch/dist/mjs/assert-valid-pattern.js

@@ -0,0 +1,6 @@
+const MAX_PATTERN_LENGTH = 65536;
+const assertValidPattern = (pattern)=>{
+    if ('string' != typeof pattern) throw new TypeError('invalid pattern');
+    if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError('pattern is too long');
+};
+export { assertValidPattern };

package/generators/node_modules/minimatch/dist/mjs/ast.js

@@ -0,0 +1,361 @@
+import { parseClass } from "./brace-expressions.js";
+import * as __WEBPACK_EXTERNAL_MODULE__unescape_js_44303e22__ from "./unescape.js";
+const types = new Set([
+    '!',
+    '?',
+    '+',
+    '*',
+    '@'
+]);
+const isExtglobType = (c)=>types.has(c);
+const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
+const startNoDot = '(?!\\.)';
+const addPatternStart = new Set([
+    '[',
+    '.'
+]);
+const justDots = new Set([
+    '..',
+    '.'
+]);
+const reSpecials = new Set('().*{}+?[]^$\\!');
+const regExpEscape = (s)=>s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+const qmark = '[^/]';
+const star = qmark + '*?';
+const starNoEmpty = qmark + '+?';
+class AST {
+    type;
+    #root;
+    #hasMagic;
+    #uflag = false;
+    #parts = [];
+    #parent;
+    #parentIndex;
+    #negs;
+    #filledNegs = false;
+    #options;
+    #toString;
+    #emptyExt = false;
+    constructor(type, parent, options = {}){
+        this.type = type;
+        if (type) this.#hasMagic = true;
+        this.#parent = parent;
+        this.#root = this.#parent ? this.#parent.#root : this;
+        this.#options = this.#root === this ? options : this.#root.#options;
+        this.#negs = this.#root === this ? [] : this.#root.#negs;
+        if ('!' === type && !this.#root.#filledNegs) this.#negs.push(this);
+        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+    }
+    get hasMagic() {
+        if (void 0 !== this.#hasMagic) return this.#hasMagic;
+        for (const p of this.#parts)if ('string' != typeof p) {
+            if (p.type || p.hasMagic) return this.#hasMagic = true;
+        }
+        return this.#hasMagic;
+    }
+    toString() {
+        if (void 0 !== this.#toString) return this.#toString;
+        if (!this.type) return this.#toString = this.#parts.map((p)=>String(p)).join('');
+        return this.#toString = this.type + '(' + this.#parts.map((p)=>String(p)).join('|') + ')';
+    }
+    #fillNegs() {
+        if (this !== this.#root) throw new Error('should only call on root');
+        if (this.#filledNegs) return this;
+        this.toString();
+        this.#filledNegs = true;
+        let n;
+        while(n = this.#negs.pop()){
+            if ('!' !== n.type) continue;
+            let p = n;
+            let pp = p.#parent;
+            while(pp){
+                for(let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++)for (const part of n.#parts){
+                    if ('string' == typeof part) throw new Error('string part in extglob AST??');
+                    part.copyIn(pp.#parts[i]);
+                }
+                p = pp;
+                pp = p.#parent;
+            }
+        }
+        return this;
+    }
+    push(...parts) {
+        for (const p of parts)if ('' !== p) {
+            if ('string' != typeof p && !(p instanceof AST && p.#parent === this)) throw new Error('invalid part: ' + p);
+            this.#parts.push(p);
+        }
+    }
+    toJSON() {
+        const ret = null === this.type ? this.#parts.slice().map((p)=>'string' == typeof p ? p : p.toJSON()) : [
+            this.type,
+            ...this.#parts.map((p)=>p.toJSON())
+        ];
+        if (this.isStart() && !this.type) ret.unshift([]);
+        if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === '!')) ret.push({});
+        return ret;
+    }
+    isStart() {
+        if (this.#root === this) return true;
+        if (!this.#parent?.isStart()) return false;
+        if (0 === this.#parentIndex) return true;
+        const p = this.#parent;
+        for(let i = 0; i < this.#parentIndex; i++){
+            const pp = p.#parts[i];
+            if (!(pp instanceof AST && '!' === pp.type)) return false;
+        }
+        return true;
+    }
+    isEnd() {
+        if (this.#root === this) return true;
+        if (this.#parent?.type === '!') return true;
+        if (!this.#parent?.isEnd()) return false;
+        if (!this.type) return this.#parent?.isEnd();
+        const pl = this.#parent ? this.#parent.#parts.length : 0;
+        return this.#parentIndex === pl - 1;
+    }
+    copyIn(part) {
+        if ('string' == typeof part) this.push(part);
+        else this.push(part.clone(this));
+    }
+    clone(parent) {
+        const c = new AST(this.type, parent);
+        for (const p of this.#parts)c.copyIn(p);
+        return c;
+    }
+    static #parseAST(str, ast, pos, opt) {
+        let escaping = false;
+        let inBrace = false;
+        let braceStart = -1;
+        let braceNeg = false;
+        if (null === ast.type) {
+            let i = pos;
+            let acc = '';
+            while(i < str.length){
+                const c = str.charAt(i++);
+                if (escaping || '\\' === c) {
+                    escaping = !escaping;
+                    acc += c;
+                    continue;
+                }
+                if (inBrace) {
+                    if (i === braceStart + 1) {
+                        if ('^' === c || '!' === c) braceNeg = true;
+                    } else if (']' === c && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+                    acc += c;
+                    continue;
+                }
+                if ('[' === c) {
+                    inBrace = true;
+                    braceStart = i;
+                    braceNeg = false;
+                    acc += c;
+                    continue;
+                }
+                if (!opt.noext && isExtglobType(c) && '(' === str.charAt(i)) {
+                    ast.push(acc);
+                    acc = '';
+                    const ext = new AST(c, ast);
+                    i = AST.#parseAST(str, ext, i, opt);
+                    ast.push(ext);
+                    continue;
+                }
+                acc += c;
+            }
+            ast.push(acc);
+            return i;
+        }
+        let i = pos + 1;
+        let part = new AST(null, ast);
+        const parts = [];
+        let acc = '';
+        while(i < str.length){
+            const c = str.charAt(i++);
+            if (escaping || '\\' === c) {
+                escaping = !escaping;
+                acc += c;
+                continue;
+            }
+            if (inBrace) {
+                if (i === braceStart + 1) {
+                    if ('^' === c || '!' === c) braceNeg = true;
+                } else if (']' === c && !(i === braceStart + 2 && braceNeg)) inBrace = false;
+                acc += c;
+                continue;
+            }
+            if ('[' === c) {
+                inBrace = true;
+                braceStart = i;
+                braceNeg = false;
+                acc += c;
+                continue;
+            }
+            if (isExtglobType(c) && '(' === str.charAt(i)) {
+                part.push(acc);
+                acc = '';
+                const ext = new AST(c, part);
+                part.push(ext);
+                i = AST.#parseAST(str, ext, i, opt);
+                continue;
+            }
+            if ('|' === c) {
+                part.push(acc);
+                acc = '';
+                parts.push(part);
+                part = new AST(null, ast);
+                continue;
+            }
+            if (')' === c) {
+                if ('' === acc && 0 === ast.#parts.length) ast.#emptyExt = true;
+                part.push(acc);
+                acc = '';
+                ast.push(...parts, part);
+                return i;
+            }
+            acc += c;
+        }
+        ast.type = null;
+        ast.#hasMagic = void 0;
+        ast.#parts = [
+            str.substring(pos - 1)
+        ];
+        return i;
+    }
+    static fromGlob(pattern, options = {}) {
+        const ast = new AST(null, void 0, options);
+        AST.#parseAST(pattern, ast, 0, options);
+        return ast;
+    }
+    toMMPattern() {
+        if (this !== this.#root) return this.#root.toMMPattern();
+        const glob = this.toString();
+        const [re, body, hasMagic, uflag] = this.toRegExpSource();
+        const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
+        if (!anyMagic) return body;
+        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');
+        return Object.assign(new RegExp(`^${re}$`, flags), {
+            _src: re,
+            _glob: glob
+        });
+    }
+    toRegExpSource(allowDot) {
+        const dot = allowDot ?? !!this.#options.dot;
+        if (this.#root === this) this.#fillNegs();
+        if (!this.type) {
+            const noEmpty = this.isStart() && this.isEnd();
+            const src = this.#parts.map((p)=>{
+                const [re, _, hasMagic, uflag] = 'string' == typeof p ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+                this.#hasMagic = this.#hasMagic || hasMagic;
+                this.#uflag = this.#uflag || uflag;
+                return re;
+            }).join('');
+            let start = '';
+            if (this.isStart()) {
+                if ('string' == typeof this.#parts[0]) {
+                    const dotTravAllowed = 1 === this.#parts.length && justDots.has(this.#parts[0]);
+                    if (!dotTravAllowed) {
+                        const aps = addPatternStart;
+                        const needNoTrav = dot && aps.has(src.charAt(0)) || src.startsWith('\\.') && aps.has(src.charAt(2)) || src.startsWith('\\.\\.') && aps.has(src.charAt(4));
+                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';
+                    }
+                }
+            }
+            let end = '';
+            if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === '!') end = '(?:$|\\/)';
+            const final = start + src + end;
+            return [
+                final,
+                (0, __WEBPACK_EXTERNAL_MODULE__unescape_js_44303e22__.unescape)(src),
+                this.#hasMagic = !!this.#hasMagic,
+                this.#uflag
+            ];
+        }
+        const repeated = '*' === this.type || '+' === this.type;
+        const start = '!' === this.type ? '(?:(?!(?:' : '(?:';
+        let body = this.#partsToRegExp(dot);
+        if (this.isStart() && this.isEnd() && !body && '!' !== this.type) {
+            const s = this.toString();
+            this.#parts = [
+                s
+            ];
+            this.type = null;
+            this.#hasMagic = void 0;
+            return [
+                s,
+                (0, __WEBPACK_EXTERNAL_MODULE__unescape_js_44303e22__.unescape)(this.toString()),
+                false,
+                false
+            ];
+        }
+        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? '' : this.#partsToRegExp(true);
+        if (bodyDotAllowed === body) bodyDotAllowed = '';
+        if (bodyDotAllowed) body = `(?:${body})(?:${bodyDotAllowed})*?`;
+        let final = '';
+        if ('!' === this.type && this.#emptyExt) final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
+        else {
+            const close = '!' === this.type ? '))' + (!this.isStart() || dot || allowDot ? '' : startNoDot) + star + ')' : '@' === this.type ? ')' : '?' === this.type ? ')?' : '+' === this.type && bodyDotAllowed ? ')' : '*' === this.type && bodyDotAllowed ? ")?" : `)${this.type}`;
+            final = start + body + close;
+        }
+        return [
+            final,
+            (0, __WEBPACK_EXTERNAL_MODULE__unescape_js_44303e22__.unescape)(body),
+            this.#hasMagic = !!this.#hasMagic,
+            this.#uflag
+        ];
+    }
+    #partsToRegExp(dot) {
+        return this.#parts.map((p)=>{
+            if ('string' == typeof p) throw new Error('string type in extglob ast??');
+            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+            this.#uflag = this.#uflag || uflag;
+            return re;
+        }).filter((p)=>!(this.isStart() && this.isEnd()) || !!p).join('|');
+    }
+    static #parseGlob(glob, hasMagic, noEmpty = false) {
+        let escaping = false;
+        let re = '';
+        let uflag = false;
+        for(let i = 0; i < glob.length; i++){
+            const c = glob.charAt(i);
+            if (escaping) {
+                escaping = false;
+                re += (reSpecials.has(c) ? '\\' : '') + c;
+                continue;
+            }
+            if ('\\' === c) {
+                if (i === glob.length - 1) re += '\\\\';
+                else escaping = true;
+                continue;
+            }
+            if ('[' === c) {
+                const [src, needUflag, consumed, magic] = parseClass(glob, i);
+                if (consumed) {
+                    re += src;
+                    uflag = uflag || needUflag;
+                    i += consumed - 1;
+                    hasMagic = hasMagic || magic;
+                    continue;
+                }
+            }
+            if ('*' === c) {
+                if (noEmpty && '*' === glob) re += starNoEmpty;
+                else re += star;
+                hasMagic = true;
+                continue;
+            }
+            if ('?' === c) {
+                re += qmark;
+                hasMagic = true;
+                continue;
+            }
+            re += regExpEscape(c);
+        }
+        return [
+            re,
+            (0, __WEBPACK_EXTERNAL_MODULE__unescape_js_44303e22__.unescape)(glob),
+            !!hasMagic,
+            uflag
+        ];
+    }
+}
+export { AST };

package/generators/node_modules/minimatch/dist/mjs/brace-expressions.js

@@ -0,0 +1,161 @@
+const posixClasses = {
+    '[:alnum:]': [
+        '\\p{L}\\p{Nl}\\p{Nd}',
+        true
+    ],
+    '[:alpha:]': [
+        '\\p{L}\\p{Nl}',
+        true
+    ],
+    '[:ascii:]': [
+        "\\x00-\\x7f",
+        false
+    ],
+    '[:blank:]': [
+        '\\p{Zs}\\t',
+        true
+    ],
+    '[:cntrl:]': [
+        '\\p{Cc}',
+        true
+    ],
+    '[:digit:]': [
+        '\\p{Nd}',
+        true
+    ],
+    '[:graph:]': [
+        '\\p{Z}\\p{C}',
+        true,
+        true
+    ],
+    '[:lower:]': [
+        '\\p{Ll}',
+        true
+    ],
+    '[:print:]': [
+        '\\p{C}',
+        true
+    ],
+    '[:punct:]': [
+        '\\p{P}',
+        true
+    ],
+    '[:space:]': [
+        '\\p{Z}\\t\\r\\n\\v\\f',
+        true
+    ],
+    '[:upper:]': [
+        '\\p{Lu}',
+        true
+    ],
+    '[:word:]': [
+        '\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}',
+        true
+    ],
+    '[:xdigit:]': [
+        'A-Fa-f0-9',
+        false
+    ]
+};
+const braceEscape = (s)=>s.replace(/[[\]\\-]/g, '\\$&');
+const regexpEscape = (s)=>s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+const rangesToString = (ranges)=>ranges.join('');
+const parseClass = (glob, position)=>{
+    const pos = position;
+    if ('[' !== glob.charAt(pos)) throw new Error('not in a brace expression');
+    const ranges = [];
+    const negs = [];
+    let i = pos + 1;
+    let sawStart = false;
+    let uflag = false;
+    let escaping = false;
+    let negate = false;
+    let endPos = pos;
+    let rangeStart = '';
+    WHILE: while(i < glob.length){
+        const c = glob.charAt(i);
+        if (('!' === c || '^' === c) && i === pos + 1) {
+            negate = true;
+            i++;
+            continue;
+        }
+        if (']' === c && sawStart && !escaping) {
+            endPos = i + 1;
+            break;
+        }
+        sawStart = true;
+        if ('\\' === c) {
+            if (!escaping) {
+                escaping = true;
+                i++;
+                continue;
+            }
+        }
+        if ('[' === c && !escaping) {
+            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses))if (glob.startsWith(cls, i)) {
+                if (rangeStart) return [
+                    '$.',
+                    false,
+                    glob.length - pos,
+                    true
+                ];
+                i += cls.length;
+                if (neg) negs.push(unip);
+                else ranges.push(unip);
+                uflag = uflag || u;
+                continue WHILE;
+            }
+        }
+        escaping = false;
+        if (rangeStart) {
+            if (c > rangeStart) ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
+            else if (c === rangeStart) ranges.push(braceEscape(c));
+            rangeStart = '';
+            i++;
+            continue;
+        }
+        if (glob.startsWith('-]', i + 1)) {
+            ranges.push(braceEscape(c + '-'));
+            i += 2;
+            continue;
+        }
+        if (glob.startsWith('-', i + 1)) {
+            rangeStart = c;
+            i += 2;
+            continue;
+        }
+        ranges.push(braceEscape(c));
+        i++;
+    }
+    if (endPos < i) return [
+        '',
+        false,
+        0,
+        false
+    ];
+    if (!ranges.length && !negs.length) return [
+        '$.',
+        false,
+        glob.length - pos,
+        true
+    ];
+    if (0 === negs.length && 1 === ranges.length && /^\\?.$/.test(ranges[0]) && !negate) {
+        const r = 2 === ranges[0].length ? ranges[0].slice(-1) : ranges[0];
+        return [
+            regexpEscape(r),
+            false,
+            endPos - pos,
+            false
+        ];
+    }
+    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
+    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
+    const comb = ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')' : ranges.length ? sranges : snegs;
+    return [
+        comb,
+        uflag,
+        endPos - pos,
+        true
+    ];
+};
+export { parseClass };

package/generators/node_modules/minimatch/dist/mjs/escape.js

@@ -0,0 +1,2 @@
+const escape_escape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, '[$&]') : s.replace(/[?*()[\]\\]/g, '\\$&');
+export { escape_escape as escape };