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

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

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

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

@@ -1,153 +0,0 @@
-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");

package/generators/node_modules/change-case/dist/index.js

@@ -1,135 +0,0 @@
-const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
-const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
-const SPLIT_NUMBER_LOWER_RE = /(\d)(\p{Ll})/gu;
-const SPLIT_LETTER_NUMBER_RE = /(\p{L})(\d)/gu;
-const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
-const SPLIT_REPLACE_VALUE = "$1\0$2";
-const DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
-function split(value, options) {
-    let result = value.trim();
-    result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
-    if (options?.separateNumbers) result = result.replace(SPLIT_NUMBER_LOWER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_LETTER_NUMBER_RE, SPLIT_REPLACE_VALUE);
-    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
-    let start = 0;
-    let end = result.length;
-    while("\0" === result.charAt(start))start++;
-    if (start === end) return [];
-    while("\0" === result.charAt(end - 1))end--;
-    return result.slice(start, end).split(/\0/g);
-}
-function noCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    return prefix + split(value, options).map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
-}
-function camelCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    const lower = lowerFactory(options?.locale);
-    const upper = upperFactory(options?.locale);
-    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
-    return prefix + split(value, options).map((word, index)=>{
-        if (0 === index) return lower(word);
-        return transform(word, index);
-    }).join(options?.delimiter ?? "") + suffix;
-}
-function pascalCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    const lower = lowerFactory(options?.locale);
-    const upper = upperFactory(options?.locale);
-    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
-    return prefix + split(value, options).map(transform).join(options?.delimiter ?? "") + suffix;
-}
-function pascalSnakeCase(input, options) {
-    return capitalCase(input, {
-        delimiter: "_",
-        ...options
-    });
-}
-function capitalCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    const lower = lowerFactory(options?.locale);
-    const upper = upperFactory(options?.locale);
-    return prefix + split(value, options).map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
-}
-function constantCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    return prefix + split(value, options).map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
-}
-function dotCase(input, options) {
-    return noCase(input, {
-        delimiter: ".",
-        ...options
-    });
-}
-function kebabCase(input, options) {
-    return noCase(input, {
-        delimiter: "-",
-        ...options
-    });
-}
-function pathCase(input, options) {
-    return noCase(input, {
-        delimiter: "/",
-        ...options
-    });
-}
-function sentenceCase(input, options) {
-    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
-    const lower = lowerFactory(options?.locale);
-    const upper = upperFactory(options?.locale);
-    const transform = capitalCaseTransformFactory(lower, upper);
-    return prefix + split(value, options).map((word, index)=>{
-        if (0 === index) return transform(word);
-        return lower(word);
-    }).join(options?.delimiter ?? " ") + suffix;
-}
-function snakeCase(input, options) {
-    return noCase(input, {
-        delimiter: "_",
-        ...options
-    });
-}
-function trainCase(input, options) {
-    return capitalCase(input, {
-        delimiter: "-",
-        ...options
-    });
-}
-function lowerFactory(locale) {
-    return false === locale ? (input)=>input.toLowerCase() : (input)=>input.toLocaleLowerCase(locale);
-}
-function upperFactory(locale) {
-    return false === locale ? (input)=>input.toUpperCase() : (input)=>input.toLocaleUpperCase(locale);
-}
-function capitalCaseTransformFactory(lower, upper) {
-    return (word)=>`${upper(word[0])}${lower(word.slice(1))}`;
-}
-function pascalCaseTransformFactory(lower, upper) {
-    return (word, index)=>{
-        const char0 = word[0];
-        const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
-        return initial + lower(word.slice(1));
-    };
-}
-function splitPrefixSuffix(input, options) {
-    const prefixCharacters = options?.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
-    const suffixCharacters = options?.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
-    let prefixIndex = 0;
-    let suffixIndex = input.length;
-    while(prefixIndex < input.length){
-        const char = input.charAt(prefixIndex);
-        if (!prefixCharacters.includes(char)) break;
-        prefixIndex++;
-    }
-    while(suffixIndex > prefixIndex){
-        const index = suffixIndex - 1;
-        const char = input.charAt(index);
-        if (!suffixCharacters.includes(char)) break;
-        suffixIndex = index;
-    }
-    return [
-        input.slice(0, prefixIndex),
-        input.slice(prefixIndex, suffixIndex),
-        input.slice(suffixIndex)
-    ];
-}
-export { camelCase, capitalCase, constantCase, dotCase, kebabCase, noCase, pascalCase, pascalSnakeCase, pathCase, sentenceCase, snakeCase, split, trainCase };

package/generators/node_modules/change-case/dist/keys.js

@@ -1,28 +0,0 @@
-import { camelCase, capitalCase, constantCase, dotCase, kebabCase, noCase, pascalCase, pathCase, sentenceCase, snakeCase, trainCase } from "./index.js";
-const isObject = (object)=>null !== object && "object" == typeof object;
-function changeKeysFactory(changeCase) {
-    return function changeKeys(object, depth = 1, options) {
-        if (0 === depth || !isObject(object)) return object;
-        if (Array.isArray(object)) return object.map((item)=>changeKeys(item, depth - 1));
-        const result = Object.create(Object.getPrototypeOf(object));
-        Object.keys(object).forEach((key)=>{
-            const value = object[key];
-            const changedKey = changeCase(key, options);
-            const changedValue = changeKeys(value, depth - 1);
-            result[changedKey] = changedValue;
-        });
-        return result;
-    };
-}
-const keys_camelCase = changeKeysFactory(camelCase);
-const keys_capitalCase = changeKeysFactory(capitalCase);
-const keys_constantCase = changeKeysFactory(constantCase);
-const keys_dotCase = changeKeysFactory(dotCase);
-const keys_trainCase = changeKeysFactory(trainCase);
-const keys_noCase = changeKeysFactory(noCase);
-const keys_kebabCase = changeKeysFactory(kebabCase);
-const keys_pascalCase = changeKeysFactory(pascalCase);
-const keys_pathCase = changeKeysFactory(pathCase);
-const keys_sentenceCase = changeKeysFactory(sentenceCase);
-const keys_snakeCase = changeKeysFactory(snakeCase);
-export { keys_camelCase as camelCase, keys_capitalCase as capitalCase, keys_constantCase as constantCase, keys_dotCase as dotCase, keys_kebabCase as kebabCase, keys_noCase as noCase, keys_pascalCase as pascalCase, keys_pathCase as pathCase, keys_sentenceCase as sentenceCase, keys_snakeCase as snakeCase, keys_trainCase as trainCase };