@uides/stepwise 2.0.0-rc.33 → 2.0.2

package/generators/node_modules/glob/dist/commonjs/processor.js

@@ -0,0 +1,214 @@
+import * as __WEBPACK_EXTERNAL_MODULE__minimatch_dist_mjs_index_js_e1dade5c__ from "../../../minimatch/dist/mjs/index.js";
+var __webpack_modules__ = {
+    minimatch: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__minimatch_dist_mjs_index_js_e1dade5c__;
+    }
+};
+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;
+}
+var __webpack_exports__ = {};
+(()=>{
+    var exports = __webpack_exports__;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.Processor = exports.SubWalks = exports.MatchRecord = exports.HasWalkedCache = void 0;
+    const minimatch_1 = __webpack_require__("minimatch");
+    class HasWalkedCache {
+        store;
+        constructor(store = new Map()){
+            this.store = store;
+        }
+        copy() {
+            return new HasWalkedCache(new Map(this.store));
+        }
+        hasWalked(target, pattern) {
+            return this.store.get(target.fullpath())?.has(pattern.globString());
+        }
+        storeWalked(target, pattern) {
+            const fullpath = target.fullpath();
+            const cached = this.store.get(fullpath);
+            if (cached) cached.add(pattern.globString());
+            else this.store.set(fullpath, new Set([
+                pattern.globString()
+            ]));
+        }
+    }
+    exports.HasWalkedCache = HasWalkedCache;
+    class MatchRecord {
+        store = new Map();
+        add(target, absolute, ifDir) {
+            const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
+            const current = this.store.get(target);
+            this.store.set(target, void 0 === current ? n : n & current);
+        }
+        entries() {
+            return [
+                ...this.store.entries()
+            ].map(([path, n])=>[
+                    path,
+                    !!(2 & n),
+                    !!(1 & n)
+                ]);
+        }
+    }
+    exports.MatchRecord = MatchRecord;
+    class SubWalks {
+        store = new Map();
+        add(target, pattern) {
+            if (!target.canReaddir()) return;
+            const subs = this.store.get(target);
+            if (subs) {
+                if (!subs.find((p)=>p.globString() === pattern.globString())) subs.push(pattern);
+            } else this.store.set(target, [
+                pattern
+            ]);
+        }
+        get(target) {
+            const subs = this.store.get(target);
+            if (!subs) throw new Error('attempting to walk unknown path');
+            return subs;
+        }
+        entries() {
+            return this.keys().map((k)=>[
+                    k,
+                    this.store.get(k)
+                ]);
+        }
+        keys() {
+            return [
+                ...this.store.keys()
+            ].filter((t)=>t.canReaddir());
+        }
+    }
+    exports.SubWalks = SubWalks;
+    class Processor {
+        hasWalkedCache;
+        matches = new MatchRecord();
+        subwalks = new SubWalks();
+        patterns;
+        follow;
+        dot;
+        opts;
+        constructor(opts, hasWalkedCache){
+            this.opts = opts;
+            this.follow = !!opts.follow;
+            this.dot = !!opts.dot;
+            this.hasWalkedCache = hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
+        }
+        processPatterns(target, patterns) {
+            this.patterns = patterns;
+            const processingSet = patterns.map((p)=>[
+                    target,
+                    p
+                ]);
+            for (let [t, pattern] of processingSet){
+                this.hasWalkedCache.storeWalked(t, pattern);
+                const root = pattern.root();
+                const absolute = pattern.isAbsolute() && false !== this.opts.absolute;
+                if (root) {
+                    t = t.resolve('/' === root && void 0 !== this.opts.root ? this.opts.root : root);
+                    const rest = pattern.rest();
+                    if (rest) pattern = rest;
+                    else {
+                        this.matches.add(t, true, false);
+                        continue;
+                    }
+                }
+                if (t.isENOENT()) continue;
+                let p;
+                let rest;
+                let changed = false;
+                while('string' == typeof (p = pattern.pattern()) && (rest = pattern.rest())){
+                    const c = t.resolve(p);
+                    t = c;
+                    pattern = rest;
+                    changed = true;
+                }
+                p = pattern.pattern();
+                rest = pattern.rest();
+                if (changed) {
+                    if (this.hasWalkedCache.hasWalked(t, pattern)) continue;
+                    this.hasWalkedCache.storeWalked(t, pattern);
+                }
+                if ('string' == typeof p) {
+                    const ifDir = '..' === p || '' === p || '.' === p;
+                    this.matches.add(t.resolve(p), absolute, ifDir);
+                    continue;
+                }
+                if (p === minimatch_1.GLOBSTAR) {
+                    if (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) this.subwalks.add(t, pattern);
+                    const rp = rest?.pattern();
+                    const rrest = rest?.rest();
+                    if (rest && ('' !== rp && '.' !== rp || rrest)) {
+                        if ('..' === rp) {
+                            const tp = t.parent || t;
+                            if (rrest) {
+                                if (!this.hasWalkedCache.hasWalked(tp, rrest)) this.subwalks.add(tp, rrest);
+                            } else this.matches.add(tp, absolute, true);
+                        }
+                    } else this.matches.add(t, absolute, '' === rp || '.' === rp);
+                } else if (p instanceof RegExp) this.subwalks.add(t, pattern);
+            }
+            return this;
+        }
+        subwalkTargets() {
+            return this.subwalks.keys();
+        }
+        child() {
+            return new Processor(this.opts, this.hasWalkedCache);
+        }
+        filterEntries(parent, entries) {
+            const patterns = this.subwalks.get(parent);
+            const results = this.child();
+            for (const e of entries)for (const pattern of patterns){
+                const absolute = pattern.isAbsolute();
+                const p = pattern.pattern();
+                const rest = pattern.rest();
+                if (p === minimatch_1.GLOBSTAR) results.testGlobstar(e, pattern, rest, absolute);
+                else if (p instanceof RegExp) results.testRegExp(e, p, rest, absolute);
+                else results.testString(e, p, rest, absolute);
+            }
+            return results;
+        }
+        testGlobstar(e, pattern, rest, absolute) {
+            if (this.dot || !e.name.startsWith('.')) {
+                if (!pattern.hasMore()) this.matches.add(e, absolute, false);
+                if (e.canReaddir()) {
+                    if (this.follow || !e.isSymbolicLink()) this.subwalks.add(e, pattern);
+                    else if (e.isSymbolicLink()) {
+                        if (rest && pattern.checkFollowGlobstar()) this.subwalks.add(e, rest);
+                        else if (pattern.markFollowGlobstar()) this.subwalks.add(e, pattern);
+                    }
+                }
+            }
+            if (rest) {
+                const rp = rest.pattern();
+                if ('string' == typeof rp && '..' !== rp && '' !== rp && '.' !== rp) this.testString(e, rp, rest.rest(), absolute);
+                else if ('..' === rp) {
+                    const ep = e.parent || e;
+                    this.subwalks.add(ep, rest);
+                } else if (rp instanceof RegExp) this.testRegExp(e, rp, rest.rest(), absolute);
+            }
+        }
+        testRegExp(e, p, rest, absolute) {
+            if (!p.test(e.name)) return;
+            if (rest) this.subwalks.add(e, rest);
+            else this.matches.add(e, absolute, false);
+        }
+        testString(e, p, rest, absolute) {
+            if (!e.isNamed(p)) return;
+            if (rest) this.subwalks.add(e, rest);
+            else this.matches.add(e, absolute, false);
+        }
+    }
+    exports.Processor = Processor;
+})();

package/generators/node_modules/glob/dist/commonjs/walker.js

@@ -0,0 +1,271 @@
+import * as __WEBPACK_EXTERNAL_MODULE__minipass_dist_esm_index_js_a8962f61__ from "../../../minipass/dist/esm/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__ignore_js_51ee403a__ from "./ignore.js";
+import * as __WEBPACK_EXTERNAL_MODULE__processor_js_bb8a3ff7__ from "./processor.js";
+var __webpack_modules__ = {
+    minipass: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__minipass_dist_esm_index_js_a8962f61__;
+    },
+    "./ignore.js": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__ignore_js_51ee403a__;
+    },
+    "./processor.js": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__processor_js_bb8a3ff7__;
+    }
+};
+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;
+}
+var __webpack_exports__ = {};
+(()=>{
+    var exports = __webpack_exports__;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.GlobStream = exports.GlobWalker = exports.GlobUtil = void 0;
+    const minipass_1 = __webpack_require__("minipass");
+    const ignore_js_1 = __webpack_require__("./ignore.js");
+    const processor_js_1 = __webpack_require__("./processor.js");
+    const makeIgnore = (ignore, opts)=>'string' == typeof ignore ? new ignore_js_1.Ignore([
+            ignore
+        ], opts) : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts) : ignore;
+    class GlobUtil {
+        path;
+        patterns;
+        opts;
+        seen = new Set();
+        paused = false;
+        aborted = false;
+        #onResume = [];
+        #ignore;
+        #sep;
+        signal;
+        maxDepth;
+        constructor(patterns, path, opts){
+            this.patterns = patterns;
+            this.path = path;
+            this.opts = opts;
+            this.#sep = opts.posix || 'win32' !== opts.platform ? '/' : '\\';
+            if (opts.ignore) this.#ignore = makeIgnore(opts.ignore, opts);
+            this.maxDepth = opts.maxDepth || 1 / 0;
+            if (opts.signal) {
+                this.signal = opts.signal;
+                this.signal.addEventListener('abort', ()=>{
+                    this.#onResume.length = 0;
+                });
+            }
+        }
+        #ignored(path) {
+            return this.seen.has(path) || !!this.#ignore?.ignored?.(path);
+        }
+        #childrenIgnored(path) {
+            return !!this.#ignore?.childrenIgnored?.(path);
+        }
+        pause() {
+            this.paused = true;
+        }
+        resume() {
+            if (this.signal?.aborted) return;
+            this.paused = false;
+            let fn;
+            while(!this.paused && (fn = this.#onResume.shift()))fn();
+        }
+        onResume(fn) {
+            if (this.signal?.aborted) return;
+            if (this.paused) this.#onResume.push(fn);
+            else fn();
+        }
+        async matchCheck(e, ifDir) {
+            if (ifDir && this.opts.nodir) return;
+            let rpc;
+            if (this.opts.realpath) {
+                rpc = e.realpathCached() || await e.realpath();
+                if (!rpc) return;
+                e = rpc;
+            }
+            const needStat = e.isUnknown() || this.opts.stat;
+            return this.matchCheckTest(needStat ? await e.lstat() : e, ifDir);
+        }
+        matchCheckTest(e, ifDir) {
+            return e && (this.maxDepth === 1 / 0 || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && !this.#ignored(e) ? e : void 0;
+        }
+        matchCheckSync(e, ifDir) {
+            if (ifDir && this.opts.nodir) return;
+            let rpc;
+            if (this.opts.realpath) {
+                rpc = e.realpathCached() || e.realpathSync();
+                if (!rpc) return;
+                e = rpc;
+            }
+            const needStat = e.isUnknown() || this.opts.stat;
+            return this.matchCheckTest(needStat ? e.lstatSync() : e, ifDir);
+        }
+        matchFinish(e, absolute) {
+            if (this.#ignored(e)) return;
+            const abs = void 0 === this.opts.absolute ? absolute : this.opts.absolute;
+            this.seen.add(e);
+            const mark = this.opts.mark && e.isDirectory() ? this.#sep : '';
+            if (this.opts.withFileTypes) this.matchEmit(e);
+            else if (abs) {
+                const abs = this.opts.posix ? e.fullpathPosix() : e.fullpath();
+                this.matchEmit(abs + mark);
+            } else {
+                const rel = this.opts.posix ? e.relativePosix() : e.relative();
+                const pre = this.opts.dotRelative && !rel.startsWith('..' + this.#sep) ? '.' + this.#sep : '';
+                this.matchEmit(rel ? pre + rel + mark : '.' + mark);
+            }
+        }
+        async match(e, absolute, ifDir) {
+            const p = await this.matchCheck(e, ifDir);
+            if (p) this.matchFinish(p, absolute);
+        }
+        matchSync(e, absolute, ifDir) {
+            const p = this.matchCheckSync(e, ifDir);
+            if (p) this.matchFinish(p, absolute);
+        }
+        walkCB(target, patterns, cb) {
+            if (this.signal?.aborted) cb();
+            this.walkCB2(target, patterns, new processor_js_1.Processor(this.opts), cb);
+        }
+        walkCB2(target, patterns, processor, cb) {
+            if (this.#childrenIgnored(target)) return cb();
+            if (this.signal?.aborted) cb();
+            if (this.paused) return void this.onResume(()=>this.walkCB2(target, patterns, processor, cb));
+            processor.processPatterns(target, patterns);
+            let tasks = 1;
+            const next = ()=>{
+                if (0 === --tasks) cb();
+            };
+            for (const [m, absolute, ifDir] of processor.matches.entries())if (!this.#ignored(m)) {
+                tasks++;
+                this.match(m, absolute, ifDir).then(()=>next());
+            }
+            for (const t of processor.subwalkTargets()){
+                if (this.maxDepth !== 1 / 0 && t.depth() >= this.maxDepth) continue;
+                tasks++;
+                const childrenCached = t.readdirCached();
+                if (t.calledReaddir()) this.walkCB3(t, childrenCached, processor, next);
+                else t.readdirCB((_, entries)=>this.walkCB3(t, entries, processor, next), true);
+            }
+            next();
+        }
+        walkCB3(target, entries, processor, cb) {
+            processor = processor.filterEntries(target, entries);
+            let tasks = 1;
+            const next = ()=>{
+                if (0 === --tasks) cb();
+            };
+            for (const [m, absolute, ifDir] of processor.matches.entries())if (!this.#ignored(m)) {
+                tasks++;
+                this.match(m, absolute, ifDir).then(()=>next());
+            }
+            for (const [target, patterns] of processor.subwalks.entries()){
+                tasks++;
+                this.walkCB2(target, patterns, processor.child(), next);
+            }
+            next();
+        }
+        walkCBSync(target, patterns, cb) {
+            if (this.signal?.aborted) cb();
+            this.walkCB2Sync(target, patterns, new processor_js_1.Processor(this.opts), cb);
+        }
+        walkCB2Sync(target, patterns, processor, cb) {
+            if (this.#childrenIgnored(target)) return cb();
+            if (this.signal?.aborted) cb();
+            if (this.paused) return void this.onResume(()=>this.walkCB2Sync(target, patterns, processor, cb));
+            processor.processPatterns(target, patterns);
+            let tasks = 1;
+            const next = ()=>{
+                if (0 === --tasks) cb();
+            };
+            for (const [m, absolute, ifDir] of processor.matches.entries())if (!this.#ignored(m)) this.matchSync(m, absolute, ifDir);
+            for (const t of processor.subwalkTargets()){
+                if (this.maxDepth !== 1 / 0 && t.depth() >= this.maxDepth) continue;
+                tasks++;
+                const children = t.readdirSync();
+                this.walkCB3Sync(t, children, processor, next);
+            }
+            next();
+        }
+        walkCB3Sync(target, entries, processor, cb) {
+            processor = processor.filterEntries(target, entries);
+            let tasks = 1;
+            const next = ()=>{
+                if (0 === --tasks) cb();
+            };
+            for (const [m, absolute, ifDir] of processor.matches.entries())if (!this.#ignored(m)) this.matchSync(m, absolute, ifDir);
+            for (const [target, patterns] of processor.subwalks.entries()){
+                tasks++;
+                this.walkCB2Sync(target, patterns, processor.child(), next);
+            }
+            next();
+        }
+    }
+    exports.GlobUtil = GlobUtil;
+    class GlobWalker extends GlobUtil {
+        matches;
+        constructor(patterns, path, opts){
+            super(patterns, path, opts);
+            this.matches = new Set();
+        }
+        matchEmit(e) {
+            this.matches.add(e);
+        }
+        async walk() {
+            if (this.signal?.aborted) throw this.signal.reason;
+            if (this.path.isUnknown()) await this.path.lstat();
+            await new Promise((res, rej)=>{
+                this.walkCB(this.path, this.patterns, ()=>{
+                    if (this.signal?.aborted) rej(this.signal.reason);
+                    else res(this.matches);
+                });
+            });
+            return this.matches;
+        }
+        walkSync() {
+            if (this.signal?.aborted) throw this.signal.reason;
+            if (this.path.isUnknown()) this.path.lstatSync();
+            this.walkCBSync(this.path, this.patterns, ()=>{
+                if (this.signal?.aborted) throw this.signal.reason;
+            });
+            return this.matches;
+        }
+    }
+    exports.GlobWalker = GlobWalker;
+    class GlobStream extends GlobUtil {
+        results;
+        constructor(patterns, path, opts){
+            super(patterns, path, opts);
+            this.results = new minipass_1.Minipass({
+                signal: this.signal,
+                objectMode: true
+            });
+            this.results.on('drain', ()=>this.resume());
+            this.results.on('resume', ()=>this.resume());
+        }
+        matchEmit(e) {
+            this.results.write(e);
+            if (!this.results.flowing) this.pause();
+        }
+        stream() {
+            const target = this.path;
+            if (target.isUnknown()) target.lstat().then(()=>{
+                this.walkCB(target, this.patterns, ()=>this.results.end());
+            });
+            else this.walkCB(target, this.patterns, ()=>this.results.end());
+            return this.results;
+        }
+        streamSync() {
+            if (this.path.isUnknown()) this.path.lstatSync();
+            this.walkCBSync(this.path, this.patterns, ()=>this.results.end());
+            return this.results;
+        }
+    }
+    exports.GlobStream = GlobStream;
+})();

package/generators/node_modules/glob/dist/esm/glob.js

@@ -0,0 +1,165 @@
+import { Minimatch } from "../../../minimatch/dist/mjs/index.js";
+import { PathScurry, PathScurryDarwin, PathScurryPosix, PathScurryWin32 } from "../../../path-scurry/dist/mjs/index.js";
+import { Pattern } from "./pattern.js";
+import { GlobStream, GlobWalker } from "./walker.js";
+import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
+const defaultPlatform = 'object' == typeof process && process && 'string' == typeof process.platform ? process.platform : 'linux';
+class Glob {
+    absolute;
+    cwd;
+    root;
+    dot;
+    dotRelative;
+    follow;
+    ignore;
+    magicalBraces;
+    mark;
+    matchBase;
+    maxDepth;
+    nobrace;
+    nocase;
+    nodir;
+    noext;
+    noglobstar;
+    pattern;
+    platform;
+    realpath;
+    scurry;
+    stat;
+    signal;
+    windowsPathsNoEscape;
+    withFileTypes;
+    opts;
+    patterns;
+    constructor(pattern, opts){
+        if (!opts) throw new TypeError('glob options required');
+        this.withFileTypes = !!opts.withFileTypes;
+        this.signal = opts.signal;
+        this.follow = !!opts.follow;
+        this.dot = !!opts.dot;
+        this.dotRelative = !!opts.dotRelative;
+        this.nodir = !!opts.nodir;
+        this.mark = !!opts.mark;
+        if (opts.cwd) {
+            if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) opts.cwd = (0, __WEBPACK_EXTERNAL_MODULE_url__.fileURLToPath)(opts.cwd);
+        } else this.cwd = '';
+        this.cwd = opts.cwd || '';
+        this.root = opts.root;
+        this.magicalBraces = !!opts.magicalBraces;
+        this.nobrace = !!opts.nobrace;
+        this.noext = !!opts.noext;
+        this.realpath = !!opts.realpath;
+        this.absolute = opts.absolute;
+        this.noglobstar = !!opts.noglobstar;
+        this.matchBase = !!opts.matchBase;
+        this.maxDepth = 'number' == typeof opts.maxDepth ? opts.maxDepth : 1 / 0;
+        this.stat = !!opts.stat;
+        this.ignore = opts.ignore;
+        if (this.withFileTypes && void 0 !== this.absolute) throw new Error('cannot set absolute and withFileTypes:true');
+        if ('string' == typeof pattern) pattern = [
+            pattern
+        ];
+        this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || false === opts.allowWindowsEscape;
+        if (this.windowsPathsNoEscape) pattern = pattern.map((p)=>p.replace(/\\/g, '/'));
+        if (this.matchBase) {
+            if (opts.noglobstar) throw new TypeError('base matching requires globstar');
+            pattern = pattern.map((p)=>p.includes('/') ? p : `./**/${p}`);
+        }
+        this.pattern = pattern;
+        this.platform = opts.platform || defaultPlatform;
+        this.opts = {
+            ...opts,
+            platform: this.platform
+        };
+        if (opts.scurry) {
+            this.scurry = opts.scurry;
+            if (void 0 !== opts.nocase && opts.nocase !== opts.scurry.nocase) throw new Error('nocase option contradicts provided scurry option');
+        } else {
+            const Scurry = 'win32' === opts.platform ? PathScurryWin32 : 'darwin' === opts.platform ? PathScurryDarwin : opts.platform ? PathScurryPosix : PathScurry;
+            this.scurry = new Scurry(this.cwd, {
+                nocase: opts.nocase,
+                fs: opts.fs
+            });
+        }
+        this.nocase = this.scurry.nocase;
+        const nocaseMagicOnly = 'darwin' === this.platform || 'win32' === this.platform;
+        const mmo = {
+            ...opts,
+            dot: this.dot,
+            matchBase: this.matchBase,
+            nobrace: this.nobrace,
+            nocase: this.nocase,
+            nocaseMagicOnly,
+            nocomment: true,
+            noext: this.noext,
+            nonegate: true,
+            optimizationLevel: 2,
+            platform: this.platform,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            debug: !!this.opts.debug
+        };
+        const mms = this.pattern.map((p)=>new Minimatch(p, mmo));
+        const [matchSet, globParts] = mms.reduce((set, m)=>{
+            set[0].push(...m.set);
+            set[1].push(...m.globParts);
+            return set;
+        }, [
+            [],
+            []
+        ]);
+        this.patterns = matchSet.map((set, i)=>{
+            const g = globParts[i];
+            if (!g) throw new Error('invalid pattern object');
+            return new Pattern(set, g, 0, this.platform);
+        });
+    }
+    async walk() {
+        return [
+            ...await new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+                platform: this.platform,
+                nocase: this.nocase
+            }).walk()
+        ];
+    }
+    walkSync() {
+        return [
+            ...new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+                platform: this.platform,
+                nocase: this.nocase
+            }).walkSync()
+        ];
+    }
+    stream() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+            platform: this.platform,
+            nocase: this.nocase
+        }).stream();
+    }
+    streamSync() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+            platform: this.platform,
+            nocase: this.nocase
+        }).streamSync();
+    }
+    iterateSync() {
+        return this.streamSync()[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    iterate() {
+        return this.stream()[Symbol.asyncIterator]();
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+}
+export { Glob };

package/generators/node_modules/glob/dist/esm/has-magic.js

@@ -0,0 +1,9 @@
+import { Minimatch } from "../../../minimatch/dist/mjs/index.js";
+const hasMagic = (pattern, options = {})=>{
+    if (!Array.isArray(pattern)) pattern = [
+        pattern
+    ];
+    for (const p of pattern)if (new Minimatch(p, options).hasMagic()) return true;
+    return false;
+};
+export { hasMagic };