@uides/stepwise 2.0.0-rc.32 → 2.0.2

package/generators/node_modules/@pkgjs/parseargs/utils.js

@@ -0,0 +1,86 @@
+import * as __WEBPACK_EXTERNAL_MODULE__internal_primordials_js_eca2175f__ from "./internal/primordials.js";
+import * as __WEBPACK_EXTERNAL_MODULE__internal_validators_js_4f764b15__ from "./internal/validators.js";
+var __webpack_modules__ = {
+    "./src/generators/node_modules/@pkgjs/parseargs/utils.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const { ArrayPrototypeFind, ObjectEntries, ObjectPrototypeHasOwnProperty: ObjectHasOwn, StringPrototypeCharAt, StringPrototypeIncludes, StringPrototypeStartsWith } = __webpack_require__("./internal/primordials");
+        const { validateObject } = __webpack_require__("./internal/validators");
+        function objectGetOwn(obj, prop) {
+            if (ObjectHasOwn(obj, prop)) return obj[prop];
+        }
+        function optionsGetOwn(options, longOption, prop) {
+            if (ObjectHasOwn(options, longOption)) return objectGetOwn(options[longOption], prop);
+        }
+        function isOptionValue(value) {
+            if (null == value) return false;
+            return true;
+        }
+        function isOptionLikeValue(value) {
+            if (null == value) return false;
+            return value.length > 1 && '-' === StringPrototypeCharAt(value, 0);
+        }
+        function isLoneShortOption(arg) {
+            return 2 === arg.length && '-' === StringPrototypeCharAt(arg, 0) && '-' !== StringPrototypeCharAt(arg, 1);
+        }
+        function isLoneLongOption(arg) {
+            return arg.length > 2 && StringPrototypeStartsWith(arg, '--') && !StringPrototypeIncludes(arg, '=', 3);
+        }
+        function isLongOptionAndValue(arg) {
+            return arg.length > 2 && StringPrototypeStartsWith(arg, '--') && StringPrototypeIncludes(arg, '=', 3);
+        }
+        function isShortOptionGroup(arg, options) {
+            if (arg.length <= 2) return false;
+            if ('-' !== StringPrototypeCharAt(arg, 0)) return false;
+            if ('-' === StringPrototypeCharAt(arg, 1)) return false;
+            const firstShort = StringPrototypeCharAt(arg, 1);
+            const longOption = findLongOptionForShort(firstShort, options);
+            return 'string' !== optionsGetOwn(options, longOption, 'type');
+        }
+        function isShortOptionAndValue(arg, options) {
+            validateObject(options, 'options');
+            if (arg.length <= 2) return false;
+            if ('-' !== StringPrototypeCharAt(arg, 0)) return false;
+            if ('-' === StringPrototypeCharAt(arg, 1)) return false;
+            const shortOption = StringPrototypeCharAt(arg, 1);
+            const longOption = findLongOptionForShort(shortOption, options);
+            return 'string' === optionsGetOwn(options, longOption, 'type');
+        }
+        function findLongOptionForShort(shortOption, options) {
+            validateObject(options, 'options');
+            const longOptionEntry = ArrayPrototypeFind(ObjectEntries(options), ({ 1: optionConfig })=>objectGetOwn(optionConfig, 'short') === shortOption);
+            return longOptionEntry?.[0] ?? shortOption;
+        }
+        function useDefaultValueOption(longOption, optionConfig, values) {
+            return void 0 !== objectGetOwn(optionConfig, 'default') && void 0 === values[longOption];
+        }
+        module.exports = {
+            findLongOptionForShort,
+            isLoneLongOption,
+            isLoneShortOption,
+            isLongOptionAndValue,
+            isOptionValue,
+            isOptionLikeValue,
+            isShortOptionAndValue,
+            isShortOptionGroup,
+            useDefaultValueOption,
+            objectGetOwn,
+            optionsGetOwn
+        };
+    },
+    "./internal/primordials": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_primordials_js_eca2175f__;
+    },
+    "./internal/validators": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_validators_js_4f764b15__;
+    }
+};
+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/@pkgjs/parseargs/utils.js");

package/generators/node_modules/ansi-regex/index.js

@@ -0,0 +1,5 @@
+function ansiRegex({ onlyFirst = false } = {}) {
+    const pattern = "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))";
+    return new RegExp(pattern, onlyFirst ? void 0 : 'g');
+}
+export { ansiRegex as default };

package/generators/node_modules/ansi-styles/index.js

@@ -0,0 +1,304 @@
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0)=>(code)=>`\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0)=>(code)=>`\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0)=>(red, green, blue)=>`\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+    modifier: {
+        reset: [
+            0,
+            0
+        ],
+        bold: [
+            1,
+            22
+        ],
+        dim: [
+            2,
+            22
+        ],
+        italic: [
+            3,
+            23
+        ],
+        underline: [
+            4,
+            24
+        ],
+        overline: [
+            53,
+            55
+        ],
+        inverse: [
+            7,
+            27
+        ],
+        hidden: [
+            8,
+            28
+        ],
+        strikethrough: [
+            9,
+            29
+        ]
+    },
+    color: {
+        black: [
+            30,
+            39
+        ],
+        red: [
+            31,
+            39
+        ],
+        green: [
+            32,
+            39
+        ],
+        yellow: [
+            33,
+            39
+        ],
+        blue: [
+            34,
+            39
+        ],
+        magenta: [
+            35,
+            39
+        ],
+        cyan: [
+            36,
+            39
+        ],
+        white: [
+            37,
+            39
+        ],
+        blackBright: [
+            90,
+            39
+        ],
+        gray: [
+            90,
+            39
+        ],
+        grey: [
+            90,
+            39
+        ],
+        redBright: [
+            91,
+            39
+        ],
+        greenBright: [
+            92,
+            39
+        ],
+        yellowBright: [
+            93,
+            39
+        ],
+        blueBright: [
+            94,
+            39
+        ],
+        magentaBright: [
+            95,
+            39
+        ],
+        cyanBright: [
+            96,
+            39
+        ],
+        whiteBright: [
+            97,
+            39
+        ]
+    },
+    bgColor: {
+        bgBlack: [
+            40,
+            49
+        ],
+        bgRed: [
+            41,
+            49
+        ],
+        bgGreen: [
+            42,
+            49
+        ],
+        bgYellow: [
+            43,
+            49
+        ],
+        bgBlue: [
+            44,
+            49
+        ],
+        bgMagenta: [
+            45,
+            49
+        ],
+        bgCyan: [
+            46,
+            49
+        ],
+        bgWhite: [
+            47,
+            49
+        ],
+        bgBlackBright: [
+            100,
+            49
+        ],
+        bgGray: [
+            100,
+            49
+        ],
+        bgGrey: [
+            100,
+            49
+        ],
+        bgRedBright: [
+            101,
+            49
+        ],
+        bgGreenBright: [
+            102,
+            49
+        ],
+        bgYellowBright: [
+            103,
+            49
+        ],
+        bgBlueBright: [
+            104,
+            49
+        ],
+        bgMagentaBright: [
+            105,
+            49
+        ],
+        bgCyanBright: [
+            106,
+            49
+        ],
+        bgWhiteBright: [
+            107,
+            49
+        ]
+    }
+};
+const modifierNames = Object.keys(styles.modifier);
+const foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = Object.keys(styles.bgColor);
+const colorNames = [
+    ...foregroundColorNames,
+    ...backgroundColorNames
+];
+function assembleStyles() {
+    const codes = new Map();
+    for (const [groupName, group] of Object.entries(styles)){
+        for (const [styleName, style] of Object.entries(group)){
+            styles[styleName] = {
+                open: `\u001B[${style[0]}m`,
+                close: `\u001B[${style[1]}m`
+            };
+            group[styleName] = styles[styleName];
+            codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+            value: group,
+            enumerable: false
+        });
+    }
+    Object.defineProperty(styles, 'codes', {
+        value: codes,
+        enumerable: false
+    });
+    styles.color.close = '\u001B[39m';
+    styles.bgColor.close = '\u001B[49m';
+    styles.color.ansi = wrapAnsi16();
+    styles.color.ansi256 = wrapAnsi256();
+    styles.color.ansi16m = wrapAnsi16m();
+    styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+    Object.defineProperties(styles, {
+        rgbToAnsi256: {
+            value: (red, green, blue)=>{
+                if (red === green && green === blue) {
+                    if (red < 8) return 16;
+                    if (red > 248) return 231;
+                    return Math.round((red - 8) / 247 * 24) + 232;
+                }
+                return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+            },
+            enumerable: false
+        },
+        hexToRgb: {
+            value: (hex)=>{
+                const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+                if (!matches) return [
+                    0,
+                    0,
+                    0
+                ];
+                let [colorString] = matches;
+                if (3 === colorString.length) colorString = [
+                    ...colorString
+                ].map((character)=>character + character).join('');
+                const integer = Number.parseInt(colorString, 16);
+                return [
+                    integer >> 16 & 0xFF,
+                    integer >> 8 & 0xFF,
+                    0xFF & integer
+                ];
+            },
+            enumerable: false
+        },
+        hexToAnsi256: {
+            value: (hex)=>styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+            enumerable: false
+        },
+        ansi256ToAnsi: {
+            value: (code)=>{
+                if (code < 8) return 30 + code;
+                if (code < 16) return 90 + (code - 8);
+                let red;
+                let green;
+                let blue;
+                if (code >= 232) {
+                    red = ((code - 232) * 10 + 8) / 255;
+                    green = red;
+                    blue = red;
+                } else {
+                    code -= 16;
+                    const remainder = code % 36;
+                    red = Math.floor(code / 36) / 5;
+                    green = Math.floor(remainder / 6) / 5;
+                    blue = remainder % 6 / 5;
+                }
+                const value = 2 * Math.max(red, green, blue);
+                if (0 === value) return 30;
+                let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+                if (2 === value) result += 60;
+                return result;
+            },
+            enumerable: false
+        },
+        rgbToAnsi: {
+            value: (red, green, blue)=>styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+            enumerable: false
+        },
+        hexToAnsi: {
+            value: (hex)=>styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+            enumerable: false
+        }
+    });
+    return styles;
+}
+const ansiStyles = assembleStyles();
+const ansi_styles = ansiStyles;
+export { backgroundColorNames, colorNames, ansi_styles as default, foregroundColorNames, modifierNames };

package/generators/node_modules/balanced-match/index.js

@@ -0,0 +1,70 @@
+var __webpack_modules__ = {
+    "./src/generators/node_modules/balanced-match/index.js": function(module) {
+        module.exports = balanced;
+        function balanced(a, b, str) {
+            if (a instanceof RegExp) a = maybeMatch(a, str);
+            if (b instanceof RegExp) b = maybeMatch(b, str);
+            var r = range(a, b, str);
+            return r && {
+                start: r[0],
+                end: r[1],
+                pre: str.slice(0, r[0]),
+                body: str.slice(r[0] + a.length, r[1]),
+                post: str.slice(r[1] + b.length)
+            };
+        }
+        function maybeMatch(reg, str) {
+            var m = str.match(reg);
+            return m ? m[0] : null;
+        }
+        balanced.range = range;
+        function range(a, b, str) {
+            var begs, beg, left, right, result;
+            var ai = str.indexOf(a);
+            var bi = str.indexOf(b, ai + 1);
+            var i = ai;
+            if (ai >= 0 && bi > 0) {
+                if (a === b) return [
+                    ai,
+                    bi
+                ];
+                begs = [];
+                left = str.length;
+                while(i >= 0 && !result){
+                    if (i == ai) {
+                        begs.push(i);
+                        ai = str.indexOf(a, i + 1);
+                    } else if (1 == begs.length) result = [
+                        begs.pop(),
+                        bi
+                    ];
+                    else {
+                        beg = begs.pop();
+                        if (beg < left) {
+                            left = beg;
+                            right = bi;
+                        }
+                        bi = str.indexOf(b, i + 1);
+                    }
+                    i = ai < bi && ai >= 0 ? ai : bi;
+                }
+                if (begs.length) result = [
+                    left,
+                    right
+                ];
+            }
+            return result;
+        }
+    }
+};
+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/balanced-match/index.js");

package/generators/node_modules/brace-expansion/index.js

@@ -0,0 +1,153 @@
+import * as __WEBPACK_EXTERNAL_MODULE__balanced_match_index_js_ff613dc1__ from "../balanced-match/index.js";
+var __webpack_modules__ = {
+    "./src/generators/node_modules/brace-expansion/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var balanced = __webpack_require__("balanced-match");
+        module.exports = expandTop;
+        var escSlash = '\0SLASH' + Math.random() + '\0';
+        var escOpen = '\0OPEN' + Math.random() + '\0';
+        var escClose = '\0CLOSE' + Math.random() + '\0';
+        var escComma = '\0COMMA' + Math.random() + '\0';
+        var escPeriod = '\0PERIOD' + Math.random() + '\0';
+        function numeric(str) {
+            return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+        }
+        function escapeBraces(str) {
+            return str.split('\\\\').join(escSlash).split('\\{').join(escOpen).split('\\}').join(escClose).split('\\,').join(escComma).split('\\.').join(escPeriod);
+        }
+        function unescapeBraces(str) {
+            return str.split(escSlash).join('\\').split(escOpen).join('{').split(escClose).join('}').split(escComma).join(',').split(escPeriod).join('.');
+        }
+        function parseCommaParts(str) {
+            if (!str) return [
+                ''
+            ];
+            var parts = [];
+            var m = balanced('{', '}', str);
+            if (!m) return str.split(',');
+            var pre = m.pre;
+            var body = m.body;
+            var post = m.post;
+            var p = pre.split(',');
+            p[p.length - 1] += '{' + body + '}';
+            var postParts = parseCommaParts(post);
+            if (post.length) {
+                p[p.length - 1] += postParts.shift();
+                p.push.apply(p, postParts);
+            }
+            parts.push.apply(parts, p);
+            return parts;
+        }
+        function expandTop(str) {
+            if (!str) return [];
+            if ('{}' === str.substr(0, 2)) str = '\\{\\}' + str.substr(2);
+            return expand(escapeBraces(str), true).map(unescapeBraces);
+        }
+        function embrace(str) {
+            return '{' + str + '}';
+        }
+        function isPadded(el) {
+            return /^-?0\d/.test(el);
+        }
+        function lte(i, y) {
+            return i <= y;
+        }
+        function gte(i, y) {
+            return i >= y;
+        }
+        function expand(str, isTop) {
+            var expansions = [];
+            var m = balanced('{', '}', str);
+            if (!m) return [
+                str
+            ];
+            var pre = m.pre;
+            var post = m.post.length ? expand(m.post, false) : [
+                ''
+            ];
+            if (/\$$/.test(m.pre)) for(var k = 0; k < post.length; k++){
+                var expansion = pre + '{' + m.body + '}' + post[k];
+                expansions.push(expansion);
+            }
+            else {
+                var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+                var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+                var isSequence = isNumericSequence || isAlphaSequence;
+                var isOptions = m.body.indexOf(',') >= 0;
+                if (!isSequence && !isOptions) {
+                    if (m.post.match(/,.*\}/)) {
+                        str = m.pre + '{' + m.body + escClose + m.post;
+                        return expand(str);
+                    }
+                    return [
+                        str
+                    ];
+                }
+                var n;
+                if (isSequence) n = m.body.split(/\.\./);
+                else {
+                    n = parseCommaParts(m.body);
+                    if (1 === n.length) {
+                        n = expand(n[0], false).map(embrace);
+                        if (1 === n.length) return post.map(function(p) {
+                            return m.pre + n[0] + p;
+                        });
+                    }
+                }
+                var N;
+                if (isSequence) {
+                    var x = numeric(n[0]);
+                    var y = numeric(n[1]);
+                    var width = Math.max(n[0].length, n[1].length);
+                    var incr = 3 == n.length ? Math.abs(numeric(n[2])) : 1;
+                    var test = lte;
+                    var reverse = y < x;
+                    if (reverse) {
+                        incr *= -1;
+                        test = gte;
+                    }
+                    var pad = n.some(isPadded);
+                    N = [];
+                    for(var i = x; test(i, y); i += incr){
+                        var c;
+                        if (isAlphaSequence) {
+                            c = String.fromCharCode(i);
+                            if ('\\' === c) c = '';
+                        } else {
+                            c = String(i);
+                            if (pad) {
+                                var need = width - c.length;
+                                if (need > 0) {
+                                    var z = new Array(need + 1).join('0');
+                                    c = i < 0 ? '-' + z + c.slice(1) : z + c;
+                                }
+                            }
+                        }
+                        N.push(c);
+                    }
+                } else {
+                    N = [];
+                    for(var j = 0; j < n.length; j++)N.push.apply(N, expand(n[j], false));
+                }
+                for(var j = 0; j < N.length; j++)for(var k = 0; k < post.length; k++){
+                    var expansion = pre + N[j] + post[k];
+                    if (!isTop || isSequence || expansion) expansions.push(expansion);
+                }
+            }
+            return expansions;
+        }
+    },
+    "balanced-match": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__balanced_match_index_js_ff613dc1__;
+    }
+};
+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/brace-expansion/index.js");