@uides/stepwise 2.0.0-rc.32 → 2.0.2

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

@@ -0,0 +1,59 @@
+import { Minimatch } from "../../../minimatch/dist/mjs/index.js";
+import { Pattern } from "./pattern.js";
+const defaultPlatform = 'object' == typeof process && process && 'string' == typeof process.platform ? process.platform : 'linux';
+class Ignore {
+    relative;
+    relativeChildren;
+    absolute;
+    absoluteChildren;
+    constructor(ignored, { nobrace, nocase, noext, noglobstar, platform = defaultPlatform }){
+        this.relative = [];
+        this.absolute = [];
+        this.relativeChildren = [];
+        this.absoluteChildren = [];
+        const mmopts = {
+            dot: true,
+            nobrace,
+            nocase,
+            noext,
+            noglobstar,
+            optimizationLevel: 2,
+            platform,
+            nocomment: true,
+            nonegate: true
+        };
+        for (const ign of ignored){
+            const mm = new Minimatch(ign, mmopts);
+            for(let i = 0; i < mm.set.length; i++){
+                const parsed = mm.set[i];
+                const globParts = mm.globParts[i];
+                if (!parsed || !globParts) throw new Error('invalid pattern object');
+                const p = new Pattern(parsed, globParts, 0, platform);
+                const m = new Minimatch(p.globString(), mmopts);
+                const children = '**' === globParts[globParts.length - 1];
+                const absolute = p.isAbsolute();
+                if (absolute) this.absolute.push(m);
+                else this.relative.push(m);
+                if (children) if (absolute) this.absoluteChildren.push(m);
+                else this.relativeChildren.push(m);
+            }
+        }
+    }
+    ignored(p) {
+        const fullpath = p.fullpath();
+        const fullpaths = `${fullpath}/`;
+        const relative = p.relative() || '.';
+        const relatives = `${relative}/`;
+        for (const m of this.relative)if (m.match(relative) || m.match(relatives)) return true;
+        for (const m of this.absolute)if (m.match(fullpath) || m.match(fullpaths)) return true;
+        return false;
+    }
+    childrenIgnored(p) {
+        const fullpath = p.fullpath() + '/';
+        const relative = (p.relative() || '.') + '/';
+        for (const m of this.relativeChildren)if (m.match(relative)) return true;
+        for (const m of this.absoluteChildren)if (m.match(fullpath)) return true;
+        return false;
+    }
+}
+export { Ignore };

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

@@ -0,0 +1,52 @@
+import { escape as index_js_escape, unescape as index_js_unescape } from "../../../minimatch/dist/mjs/index.js";
+import { Glob } from "./glob.js";
+import { hasMagic } from "./has-magic.js";
+function globStreamSync(pattern, options = {}) {
+    return new Glob(pattern, options).streamSync();
+}
+function globStream(pattern, options = {}) {
+    return new Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+    return new Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+    return new Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+    return new Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+    return new Glob(pattern, options).iterate();
+}
+const streamSync = globStreamSync;
+const stream = Object.assign(globStream, {
+    sync: globStreamSync
+});
+const iterateSync = globIterateSync;
+const iterate = Object.assign(globIterate, {
+    sync: globIterateSync
+});
+const sync = Object.assign(globSync, {
+    stream: globStreamSync,
+    iterate: globIterateSync
+});
+const glob = Object.assign(glob_, {
+    glob: glob_,
+    globSync,
+    sync,
+    globStream,
+    stream,
+    globStreamSync,
+    streamSync,
+    globIterate,
+    iterate,
+    globIterateSync,
+    iterateSync,
+    Glob: Glob,
+    hasMagic: hasMagic,
+    escape: index_js_escape,
+    unescape: index_js_unescape
+});
+glob.glob = glob;
+export { Glob, index_js_escape as escape, glob, globIterate, globIterateSync, globStream, globStreamSync, globSync, hasMagic, iterate, iterateSync, stream, streamSync, sync, index_js_unescape as unescape };

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

@@ -0,0 +1,130 @@
+import { GLOBSTAR } from "../../../minimatch/dist/mjs/index.js";
+const isPatternList = (pl)=>pl.length >= 1;
+const isGlobList = (gl)=>gl.length >= 1;
+class Pattern {
+    #patternList;
+    #globList;
+    #index;
+    length;
+    #platform;
+    #rest;
+    #globString;
+    #isDrive;
+    #isUNC;
+    #isAbsolute;
+    #followGlobstar = true;
+    constructor(patternList, globList, index, platform){
+        if (!isPatternList(patternList)) throw new TypeError('empty pattern list');
+        if (!isGlobList(globList)) throw new TypeError('empty glob list');
+        if (globList.length !== patternList.length) throw new TypeError('mismatched pattern list and glob list lengths');
+        this.length = patternList.length;
+        if (index < 0 || index >= this.length) throw new TypeError('index out of range');
+        this.#patternList = patternList;
+        this.#globList = globList;
+        this.#index = index;
+        this.#platform = platform;
+        if (0 === this.#index) {
+            if (this.isUNC()) {
+                const [p0, p1, p2, p3, ...prest] = this.#patternList;
+                const [g0, g1, g2, g3, ...grest] = this.#globList;
+                if ('' === prest[0]) {
+                    prest.shift();
+                    grest.shift();
+                }
+                const p = [
+                    p0,
+                    p1,
+                    p2,
+                    p3,
+                    ''
+                ].join('/');
+                const g = [
+                    g0,
+                    g1,
+                    g2,
+                    g3,
+                    ''
+                ].join('/');
+                this.#patternList = [
+                    p,
+                    ...prest
+                ];
+                this.#globList = [
+                    g,
+                    ...grest
+                ];
+                this.length = this.#patternList.length;
+            } else if (this.isDrive() || this.isAbsolute()) {
+                const [p1, ...prest] = this.#patternList;
+                const [g1, ...grest] = this.#globList;
+                if ('' === prest[0]) {
+                    prest.shift();
+                    grest.shift();
+                }
+                const p = p1 + '/';
+                const g = g1 + '/';
+                this.#patternList = [
+                    p,
+                    ...prest
+                ];
+                this.#globList = [
+                    g,
+                    ...grest
+                ];
+                this.length = this.#patternList.length;
+            }
+        }
+    }
+    pattern() {
+        return this.#patternList[this.#index];
+    }
+    isString() {
+        return 'string' == typeof this.#patternList[this.#index];
+    }
+    isGlobstar() {
+        return this.#patternList[this.#index] === GLOBSTAR;
+    }
+    isRegExp() {
+        return this.#patternList[this.#index] instanceof RegExp;
+    }
+    globString() {
+        return this.#globString = this.#globString || (0 === this.#index ? this.isAbsolute() ? this.#globList[0] + this.#globList.slice(1).join('/') : this.#globList.join('/') : this.#globList.slice(this.#index).join('/'));
+    }
+    hasMore() {
+        return this.length > this.#index + 1;
+    }
+    rest() {
+        if (void 0 !== this.#rest) return this.#rest;
+        if (!this.hasMore()) return this.#rest = null;
+        this.#rest = new Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
+        this.#rest.#isAbsolute = this.#isAbsolute;
+        this.#rest.#isUNC = this.#isUNC;
+        this.#rest.#isDrive = this.#isDrive;
+        return this.#rest;
+    }
+    isUNC() {
+        const pl = this.#patternList;
+        return void 0 !== this.#isUNC ? this.#isUNC : this.#isUNC = 'win32' === this.#platform && 0 === this.#index && '' === pl[0] && '' === pl[1] && 'string' == typeof pl[2] && !!pl[2] && 'string' == typeof pl[3] && !!pl[3];
+    }
+    isDrive() {
+        const pl = this.#patternList;
+        return void 0 !== this.#isDrive ? this.#isDrive : this.#isDrive = 'win32' === this.#platform && 0 === this.#index && this.length > 1 && 'string' == typeof pl[0] && /^[a-z]:$/i.test(pl[0]);
+    }
+    isAbsolute() {
+        const pl = this.#patternList;
+        return void 0 !== this.#isAbsolute ? this.#isAbsolute : this.#isAbsolute = '' === pl[0] && pl.length > 1 || this.isDrive() || this.isUNC();
+    }
+    root() {
+        const p = this.#patternList[0];
+        return 'string' == typeof p && this.isAbsolute() && 0 === this.#index ? p : '';
+    }
+    checkFollowGlobstar() {
+        return !(0 === this.#index || !this.isGlobstar() || !this.#followGlobstar);
+    }
+    markFollowGlobstar() {
+        if (0 === this.#index || !this.isGlobstar() || !this.#followGlobstar) return false;
+        this.#followGlobstar = false;
+        return true;
+    }
+}
+export { Pattern };

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

@@ -0,0 +1,187 @@
+import { GLOBSTAR } from "../../../minimatch/dist/mjs/index.js";
+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()
+        ]));
+    }
+}
+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)
+            ]);
+    }
+}
+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());
+    }
+}
+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 === 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 === 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);
+    }
+}
+export { HasWalkedCache, MatchRecord, Processor, SubWalks };

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

@@ -0,0 +1,237 @@
+import { Ignore } from "./ignore.js";
+import { Processor } from "./processor.js";
+import * as __WEBPACK_EXTERNAL_MODULE__minipass_dist_esm_index_js_a8962f61__ from "../../../minipass/dist/esm/index.js";
+const makeIgnore = (ignore, opts)=>'string' == typeof ignore ? new Ignore([
+        ignore
+    ], opts) : Array.isArray(ignore) ? new 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(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(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();
+    }
+}
+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;
+    }
+}
+class GlobStream extends GlobUtil {
+    results;
+    constructor(patterns, path, opts){
+        super(patterns, path, opts);
+        this.results = new __WEBPACK_EXTERNAL_MODULE__minipass_dist_esm_index_js_a8962f61__.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;
+    }
+}
+export { GlobStream, GlobUtil, GlobWalker };

package/generators/node_modules/is-fullwidth-code-point/index.js

@@ -0,0 +1,22 @@
+var __webpack_modules__ = {
+    "./src/generators/node_modules/is-fullwidth-code-point/index.js": function(module) {
+        const isFullwidthCodePoint = (codePoint)=>{
+            if (Number.isNaN(codePoint)) return false;
+            if (codePoint >= 0x1100 && (codePoint <= 0x115F || 0x2329 === codePoint || 0x232A === codePoint || 0x2E80 <= codePoint && codePoint <= 0x3247 && 0x303F !== codePoint || 0x3250 <= codePoint && codePoint <= 0x4DBF || 0x4E00 <= codePoint && codePoint <= 0xA4C6 || 0xA960 <= codePoint && codePoint <= 0xA97C || 0xAC00 <= codePoint && codePoint <= 0xD7A3 || 0xF900 <= codePoint && codePoint <= 0xFAFF || 0xFE10 <= codePoint && codePoint <= 0xFE19 || 0xFE30 <= codePoint && codePoint <= 0xFE6B || 0xFF01 <= codePoint && codePoint <= 0xFF60 || 0xFFE0 <= codePoint && codePoint <= 0xFFE6 || 0x1B000 <= codePoint && codePoint <= 0x1B001 || 0x1F200 <= codePoint && codePoint <= 0x1F251 || 0x20000 <= codePoint && codePoint <= 0x3FFFD)) return true;
+            return false;
+        };
+        module.exports = isFullwidthCodePoint;
+        module.exports["default"] = isFullwidthCodePoint;
+    }
+};
+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/is-fullwidth-code-point/index.js");