@uides/stepwise 2.0.2 → 2.0.4-platform-162.23-01-26-13-03

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

@@ -1,10 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,361 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

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