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

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

@@ -1,263 +0,0 @@
-import * as __WEBPACK_EXTERNAL_MODULE__internal_errors_js_3010d20a__ from "./internal/errors.js";
-import * as __WEBPACK_EXTERNAL_MODULE__internal_primordials_js_eca2175f__ from "./internal/primordials.js";
-import * as __WEBPACK_EXTERNAL_MODULE__internal_util_js_d2b0f213__ from "./internal/util.js";
-import * as __WEBPACK_EXTERNAL_MODULE__internal_validators_js_4f764b15__ from "./internal/validators.js";
-import * as __WEBPACK_EXTERNAL_MODULE__utils_js_d88b7fe1__ from "./utils.js";
-var __webpack_modules__ = {
-    "./src/generators/node_modules/@pkgjs/parseargs/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
-        const { ArrayPrototypeForEach, ArrayPrototypeIncludes, ArrayPrototypeMap, ArrayPrototypePush, ArrayPrototypePushApply, ArrayPrototypeShift, ArrayPrototypeSlice, ArrayPrototypeUnshiftApply, ObjectEntries, ObjectPrototypeHasOwnProperty: ObjectHasOwn, StringPrototypeCharAt, StringPrototypeIndexOf, StringPrototypeSlice, StringPrototypeStartsWith } = __webpack_require__("./internal/primordials");
-        const { validateArray, validateBoolean, validateBooleanArray, validateObject, validateString, validateStringArray, validateUnion } = __webpack_require__("./internal/validators");
-        const { kEmptyObject } = __webpack_require__("./internal/util");
-        const { findLongOptionForShort, isLoneLongOption, isLoneShortOption, isLongOptionAndValue, isOptionValue, isOptionLikeValue, isShortOptionAndValue, isShortOptionGroup, useDefaultValueOption, objectGetOwn, optionsGetOwn } = __webpack_require__("./utils");
-        const { codes: { ERR_INVALID_ARG_VALUE, ERR_PARSE_ARGS_INVALID_OPTION_VALUE, ERR_PARSE_ARGS_UNKNOWN_OPTION, ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL } } = __webpack_require__("./internal/errors");
-        function getMainArgs() {
-            const execArgv = process.execArgv;
-            if (ArrayPrototypeIncludes(execArgv, '-e') || ArrayPrototypeIncludes(execArgv, '--eval') || ArrayPrototypeIncludes(execArgv, '-p') || ArrayPrototypeIncludes(execArgv, '--print')) return ArrayPrototypeSlice(process.argv, 1);
-            return ArrayPrototypeSlice(process.argv, 2);
-        }
-        function checkOptionLikeValue(token) {
-            if (!token.inlineValue && isOptionLikeValue(token.value)) {
-                const example = StringPrototypeStartsWith(token.rawName, '--') ? `'${token.rawName}=-XYZ'` : `'--${token.name}=-XYZ' or '${token.rawName}-XYZ'`;
-                const errorMessage = `Option '${token.rawName}' argument is ambiguous.
-Did you forget to specify the option argument for '${token.rawName}'?
-To specify an option argument starting with a dash use ${example}.`;
-                throw new ERR_PARSE_ARGS_INVALID_OPTION_VALUE(errorMessage);
-            }
-        }
-        function checkOptionUsage(config, token) {
-            if (!ObjectHasOwn(config.options, token.name)) throw new ERR_PARSE_ARGS_UNKNOWN_OPTION(token.rawName, config.allowPositionals);
-            const short = optionsGetOwn(config.options, token.name, 'short');
-            const shortAndLong = `${short ? `-${short}, ` : ''}--${token.name}`;
-            const type = optionsGetOwn(config.options, token.name, 'type');
-            if ('string' === type && 'string' != typeof token.value) throw new ERR_PARSE_ARGS_INVALID_OPTION_VALUE(`Option '${shortAndLong} <value>' argument missing`);
-            if ('boolean' === type && null != token.value) throw new ERR_PARSE_ARGS_INVALID_OPTION_VALUE(`Option '${shortAndLong}' does not take an argument`);
-        }
-        function storeOption(longOption, optionValue, options, values) {
-            if ('__proto__' === longOption) return;
-            const newValue = optionValue ?? true;
-            if (optionsGetOwn(options, longOption, 'multiple')) if (values[longOption]) ArrayPrototypePush(values[longOption], newValue);
-            else values[longOption] = [
-                newValue
-            ];
-            else values[longOption] = newValue;
-        }
-        function storeDefaultOption(longOption, optionValue, values) {
-            if ('__proto__' === longOption) return;
-            values[longOption] = optionValue;
-        }
-        function argsToTokens(args, options) {
-            const tokens = [];
-            let index = -1;
-            let groupCount = 0;
-            const remainingArgs = ArrayPrototypeSlice(args);
-            while(remainingArgs.length > 0){
-                const arg = ArrayPrototypeShift(remainingArgs);
-                const nextArg = remainingArgs[0];
-                if (groupCount > 0) groupCount--;
-                else index++;
-                if ('--' === arg) {
-                    ArrayPrototypePush(tokens, {
-                        kind: 'option-terminator',
-                        index
-                    });
-                    ArrayPrototypePushApply(tokens, ArrayPrototypeMap(remainingArgs, (arg)=>({
-                            kind: 'positional',
-                            index: ++index,
-                            value: arg
-                        })));
-                    break;
-                }
-                if (isLoneShortOption(arg)) {
-                    const shortOption = StringPrototypeCharAt(arg, 1);
-                    const longOption = findLongOptionForShort(shortOption, options);
-                    let value;
-                    let inlineValue;
-                    if ('string' === optionsGetOwn(options, longOption, 'type') && isOptionValue(nextArg)) {
-                        value = ArrayPrototypeShift(remainingArgs);
-                        inlineValue = false;
-                    }
-                    ArrayPrototypePush(tokens, {
-                        kind: 'option',
-                        name: longOption,
-                        rawName: arg,
-                        index,
-                        value,
-                        inlineValue
-                    });
-                    if (null != value) ++index;
-                    continue;
-                }
-                if (isShortOptionGroup(arg, options)) {
-                    const expanded = [];
-                    for(let index = 1; index < arg.length; index++){
-                        const shortOption = StringPrototypeCharAt(arg, index);
-                        const longOption = findLongOptionForShort(shortOption, options);
-                        if ('string' !== optionsGetOwn(options, longOption, 'type') || index === arg.length - 1) ArrayPrototypePush(expanded, `-${shortOption}`);
-                        else {
-                            ArrayPrototypePush(expanded, `-${StringPrototypeSlice(arg, index)}`);
-                            break;
-                        }
-                    }
-                    ArrayPrototypeUnshiftApply(remainingArgs, expanded);
-                    groupCount = expanded.length;
-                    continue;
-                }
-                if (isShortOptionAndValue(arg, options)) {
-                    const shortOption = StringPrototypeCharAt(arg, 1);
-                    const longOption = findLongOptionForShort(shortOption, options);
-                    const value = StringPrototypeSlice(arg, 2);
-                    ArrayPrototypePush(tokens, {
-                        kind: 'option',
-                        name: longOption,
-                        rawName: `-${shortOption}`,
-                        index,
-                        value,
-                        inlineValue: true
-                    });
-                    continue;
-                }
-                if (isLoneLongOption(arg)) {
-                    const longOption = StringPrototypeSlice(arg, 2);
-                    let value;
-                    let inlineValue;
-                    if ('string' === optionsGetOwn(options, longOption, 'type') && isOptionValue(nextArg)) {
-                        value = ArrayPrototypeShift(remainingArgs);
-                        inlineValue = false;
-                    }
-                    ArrayPrototypePush(tokens, {
-                        kind: 'option',
-                        name: longOption,
-                        rawName: arg,
-                        index,
-                        value,
-                        inlineValue
-                    });
-                    if (null != value) ++index;
-                    continue;
-                }
-                if (isLongOptionAndValue(arg)) {
-                    const equalIndex = StringPrototypeIndexOf(arg, '=');
-                    const longOption = StringPrototypeSlice(arg, 2, equalIndex);
-                    const value = StringPrototypeSlice(arg, equalIndex + 1);
-                    ArrayPrototypePush(tokens, {
-                        kind: 'option',
-                        name: longOption,
-                        rawName: `--${longOption}`,
-                        index,
-                        value,
-                        inlineValue: true
-                    });
-                    continue;
-                }
-                ArrayPrototypePush(tokens, {
-                    kind: 'positional',
-                    index,
-                    value: arg
-                });
-            }
-            return tokens;
-        }
-        const parseArgs = (config = kEmptyObject)=>{
-            const args = objectGetOwn(config, 'args') ?? getMainArgs();
-            const strict = objectGetOwn(config, 'strict') ?? true;
-            const allowPositionals = objectGetOwn(config, 'allowPositionals') ?? !strict;
-            const returnTokens = objectGetOwn(config, 'tokens') ?? false;
-            const options = objectGetOwn(config, 'options') ?? {
-                __proto__: null
-            };
-            const parseConfig = {
-                args,
-                strict,
-                options,
-                allowPositionals
-            };
-            validateArray(args, 'args');
-            validateBoolean(strict, 'strict');
-            validateBoolean(allowPositionals, 'allowPositionals');
-            validateBoolean(returnTokens, 'tokens');
-            validateObject(options, 'options');
-            ArrayPrototypeForEach(ObjectEntries(options), ({ 0: longOption, 1: optionConfig })=>{
-                validateObject(optionConfig, `options.${longOption}`);
-                const optionType = objectGetOwn(optionConfig, 'type');
-                validateUnion(optionType, `options.${longOption}.type`, [
-                    'string',
-                    'boolean'
-                ]);
-                if (ObjectHasOwn(optionConfig, 'short')) {
-                    const shortOption = optionConfig.short;
-                    validateString(shortOption, `options.${longOption}.short`);
-                    if (1 !== shortOption.length) throw new ERR_INVALID_ARG_VALUE(`options.${longOption}.short`, shortOption, 'must be a single character');
-                }
-                const multipleOption = objectGetOwn(optionConfig, 'multiple');
-                if (ObjectHasOwn(optionConfig, 'multiple')) validateBoolean(multipleOption, `options.${longOption}.multiple`);
-                const defaultValue = objectGetOwn(optionConfig, 'default');
-                if (void 0 !== defaultValue) {
-                    let validator;
-                    switch(optionType){
-                        case 'string':
-                            validator = multipleOption ? validateStringArray : validateString;
-                            break;
-                        case 'boolean':
-                            validator = multipleOption ? validateBooleanArray : validateBoolean;
-                            break;
-                    }
-                    validator(defaultValue, `options.${longOption}.default`);
-                }
-            });
-            const tokens = argsToTokens(args, options);
-            const result = {
-                values: {
-                    __proto__: null
-                },
-                positionals: []
-            };
-            if (returnTokens) result.tokens = tokens;
-            ArrayPrototypeForEach(tokens, (token)=>{
-                if ('option' === token.kind) {
-                    if (strict) {
-                        checkOptionUsage(parseConfig, token);
-                        checkOptionLikeValue(token);
-                    }
-                    storeOption(token.name, token.value, options, result.values);
-                } else if ('positional' === token.kind) {
-                    if (!allowPositionals) throw new ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL(token.value);
-                    ArrayPrototypePush(result.positionals, token.value);
-                }
-            });
-            ArrayPrototypeForEach(ObjectEntries(options), ({ 0: longOption, 1: optionConfig })=>{
-                const mustSetDefault = useDefaultValueOption(longOption, optionConfig, result.values);
-                if (mustSetDefault) storeDefaultOption(longOption, objectGetOwn(optionConfig, 'default'), result.values);
-            });
-            return result;
-        };
-        module.exports = {
-            parseArgs
-        };
-    },
-    "./internal/errors": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_errors_js_3010d20a__;
-    },
-    "./internal/primordials": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_primordials_js_eca2175f__;
-    },
-    "./internal/util": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_util_js_d2b0f213__;
-    },
-    "./internal/validators": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__internal_validators_js_4f764b15__;
-    },
-    "./utils": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_js_d88b7fe1__;
-    }
-};
-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/index.js");

package/generators/node_modules/@pkgjs/parseargs/internal/errors.js

@@ -1,55 +0,0 @@
-var __webpack_modules__ = {
-    "./src/generators/node_modules/@pkgjs/parseargs/internal/errors.js": function(module) {
-        class ERR_INVALID_ARG_TYPE extends TypeError {
-            constructor(name, expected, actual){
-                super(`${name} must be ${expected} got ${actual}`);
-                this.code = 'ERR_INVALID_ARG_TYPE';
-            }
-        }
-        class ERR_INVALID_ARG_VALUE extends TypeError {
-            constructor(arg1, arg2, expected){
-                super(`The property ${arg1} ${expected}. Received '${arg2}'`);
-                this.code = 'ERR_INVALID_ARG_VALUE';
-            }
-        }
-        class ERR_PARSE_ARGS_INVALID_OPTION_VALUE extends Error {
-            constructor(message){
-                super(message);
-                this.code = 'ERR_PARSE_ARGS_INVALID_OPTION_VALUE';
-            }
-        }
-        class ERR_PARSE_ARGS_UNKNOWN_OPTION extends Error {
-            constructor(option, allowPositionals){
-                const suggestDashDash = allowPositionals ? `. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- ${JSON.stringify(option)}` : '';
-                super(`Unknown option '${option}'${suggestDashDash}`);
-                this.code = 'ERR_PARSE_ARGS_UNKNOWN_OPTION';
-            }
-        }
-        class ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL extends Error {
-            constructor(positional){
-                super(`Unexpected argument '${positional}'. This command does not take positional arguments`);
-                this.code = 'ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL';
-            }
-        }
-        module.exports = {
-            codes: {
-                ERR_INVALID_ARG_TYPE,
-                ERR_INVALID_ARG_VALUE,
-                ERR_PARSE_ARGS_INVALID_OPTION_VALUE,
-                ERR_PARSE_ARGS_UNKNOWN_OPTION,
-                ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL
-            }
-        };
-    }
-};
-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/internal/errors.js");

package/generators/node_modules/@pkgjs/parseargs/internal/primordials.js

@@ -1,258 +0,0 @@
-var __webpack_modules__ = {
-    "./src/generators/node_modules/@pkgjs/parseargs/internal/primordials.js": function(module) {
-        const primordials = {};
-        const { defineProperty: ReflectDefineProperty, getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor, ownKeys: ReflectOwnKeys } = Reflect;
-        const { apply, bind, call } = Function.prototype;
-        const uncurryThis = bind.bind(call);
-        primordials.uncurryThis = uncurryThis;
-        const applyBind = bind.bind(apply);
-        primordials.applyBind = applyBind;
-        const varargsMethods = [
-            'ArrayOf',
-            'ArrayPrototypePush',
-            'ArrayPrototypeUnshift',
-            'MathHypot',
-            'MathMax',
-            'MathMin',
-            'StringPrototypeConcat',
-            'TypedArrayOf'
-        ];
-        function getNewKey(key) {
-            return 'symbol' == typeof key ? `Symbol${key.description[7].toUpperCase()}${key.description.slice(8)}` : `${key[0].toUpperCase()}${key.slice(1)}`;
-        }
-        function copyAccessor(dest, prefix, key, { enumerable, get, set }) {
-            ReflectDefineProperty(dest, `${prefix}Get${key}`, {
-                value: uncurryThis(get),
-                enumerable
-            });
-            if (void 0 !== set) ReflectDefineProperty(dest, `${prefix}Set${key}`, {
-                value: uncurryThis(set),
-                enumerable
-            });
-        }
-        function copyPropsRenamed(src, dest, prefix) {
-            for (const key of ReflectOwnKeys(src)){
-                const newKey = getNewKey(key);
-                const desc = ReflectGetOwnPropertyDescriptor(src, key);
-                if ('get' in desc) copyAccessor(dest, prefix, newKey, desc);
-                else {
-                    const name = `${prefix}${newKey}`;
-                    ReflectDefineProperty(dest, name, desc);
-                    if (varargsMethods.includes(name)) ReflectDefineProperty(dest, `${name}Apply`, {
-                        value: applyBind(desc.value, src)
-                    });
-                }
-            }
-        }
-        function copyPropsRenamedBound(src, dest, prefix) {
-            for (const key of ReflectOwnKeys(src)){
-                const newKey = getNewKey(key);
-                const desc = ReflectGetOwnPropertyDescriptor(src, key);
-                if ('get' in desc) copyAccessor(dest, prefix, newKey, desc);
-                else {
-                    const { value } = desc;
-                    if ('function' == typeof value) desc.value = value.bind(src);
-                    const name = `${prefix}${newKey}`;
-                    ReflectDefineProperty(dest, name, desc);
-                    if (varargsMethods.includes(name)) ReflectDefineProperty(dest, `${name}Apply`, {
-                        value: applyBind(value, src)
-                    });
-                }
-            }
-        }
-        function copyPrototype(src, dest, prefix) {
-            for (const key of ReflectOwnKeys(src)){
-                const newKey = getNewKey(key);
-                const desc = ReflectGetOwnPropertyDescriptor(src, key);
-                if ('get' in desc) copyAccessor(dest, prefix, newKey, desc);
-                else {
-                    const { value } = desc;
-                    if ('function' == typeof value) desc.value = uncurryThis(value);
-                    const name = `${prefix}${newKey}`;
-                    ReflectDefineProperty(dest, name, desc);
-                    if (varargsMethods.includes(name)) ReflectDefineProperty(dest, `${name}Apply`, {
-                        value: applyBind(value)
-                    });
-                }
-            }
-        }
-        [
-            'Proxy',
-            'globalThis'
-        ].forEach((name)=>{
-            primordials[name] = globalThis[name];
-        });
-        [
-            decodeURI,
-            decodeURIComponent,
-            encodeURI,
-            encodeURIComponent
-        ].forEach((fn)=>{
-            primordials[fn.name] = fn;
-        });
-        [
-            'JSON',
-            'Math',
-            'Proxy',
-            'Reflect'
-        ].forEach((name)=>{
-            copyPropsRenamed(global[name], primordials, name);
-        });
-        [
-            'Array',
-            'ArrayBuffer',
-            'BigInt',
-            'BigInt64Array',
-            'BigUint64Array',
-            'Boolean',
-            'DataView',
-            'Date',
-            'Error',
-            'EvalError',
-            'Float32Array',
-            'Float64Array',
-            'Function',
-            'Int16Array',
-            'Int32Array',
-            'Int8Array',
-            'Map',
-            'Number',
-            'Object',
-            'RangeError',
-            'ReferenceError',
-            'RegExp',
-            'Set',
-            'String',
-            'Symbol',
-            'SyntaxError',
-            'TypeError',
-            'URIError',
-            'Uint16Array',
-            'Uint32Array',
-            'Uint8Array',
-            'Uint8ClampedArray',
-            'WeakMap',
-            'WeakSet'
-        ].forEach((name)=>{
-            const original = global[name];
-            primordials[name] = original;
-            copyPropsRenamed(original, primordials, name);
-            copyPrototype(original.prototype, primordials, `${name}Prototype`);
-        });
-        [
-            'Promise'
-        ].forEach((name)=>{
-            const original = global[name];
-            primordials[name] = original;
-            copyPropsRenamedBound(original, primordials, name);
-            copyPrototype(original.prototype, primordials, `${name}Prototype`);
-        });
-        [
-            {
-                name: 'TypedArray',
-                original: Reflect.getPrototypeOf(Uint8Array)
-            },
-            {
-                name: 'ArrayIterator',
-                original: {
-                    prototype: Reflect.getPrototypeOf(Array.prototype[Symbol.iterator]())
-                }
-            },
-            {
-                name: 'StringIterator',
-                original: {
-                    prototype: Reflect.getPrototypeOf(String.prototype[Symbol.iterator]())
-                }
-            }
-        ].forEach(({ name, original })=>{
-            primordials[name] = original;
-            copyPrototype(original, primordials, name);
-            copyPrototype(original.prototype, primordials, `${name}Prototype`);
-        });
-        const { ArrayPrototypeForEach, FunctionPrototypeCall, Map, ObjectFreeze, ObjectSetPrototypeOf, Set, SymbolIterator, WeakMap, WeakSet } = primordials;
-        const createSafeIterator = (factory, next)=>{
-            class SafeIterator {
-                constructor(iterable){
-                    this._iterator = factory(iterable);
-                }
-                next() {
-                    return next(this._iterator);
-                }
-                [SymbolIterator]() {
-                    return this;
-                }
-            }
-            ObjectSetPrototypeOf(SafeIterator.prototype, null);
-            ObjectFreeze(SafeIterator.prototype);
-            ObjectFreeze(SafeIterator);
-            return SafeIterator;
-        };
-        primordials.SafeArrayIterator = createSafeIterator(primordials.ArrayPrototypeSymbolIterator, primordials.ArrayIteratorPrototypeNext);
-        primordials.SafeStringIterator = createSafeIterator(primordials.StringPrototypeSymbolIterator, primordials.StringIteratorPrototypeNext);
-        const copyProps = (src, dest)=>{
-            ArrayPrototypeForEach(ReflectOwnKeys(src), (key)=>{
-                if (!ReflectGetOwnPropertyDescriptor(dest, key)) ReflectDefineProperty(dest, key, ReflectGetOwnPropertyDescriptor(src, key));
-            });
-        };
-        const makeSafe = (unsafe, safe)=>{
-            if (SymbolIterator in unsafe.prototype) {
-                const dummy = new unsafe();
-                let next;
-                ArrayPrototypeForEach(ReflectOwnKeys(unsafe.prototype), (key)=>{
-                    if (!ReflectGetOwnPropertyDescriptor(safe.prototype, key)) {
-                        const desc = ReflectGetOwnPropertyDescriptor(unsafe.prototype, key);
-                        if ('function' == typeof desc.value && 0 === desc.value.length && SymbolIterator in (FunctionPrototypeCall(desc.value, dummy) ?? {})) {
-                            const createIterator = uncurryThis(desc.value);
-                            next = next ?? uncurryThis(createIterator(dummy).next);
-                            const SafeIterator = createSafeIterator(createIterator, next);
-                            desc.value = function() {
-                                return new SafeIterator(this);
-                            };
-                        }
-                        ReflectDefineProperty(safe.prototype, key, desc);
-                    }
-                });
-            } else copyProps(unsafe.prototype, safe.prototype);
-            copyProps(unsafe, safe);
-            ObjectSetPrototypeOf(safe.prototype, null);
-            ObjectFreeze(safe.prototype);
-            ObjectFreeze(safe);
-            return safe;
-        };
-        primordials.makeSafe = makeSafe;
-        primordials.SafeMap = makeSafe(Map, class extends Map {
-            constructor(i){
-                super(i);
-            }
-        });
-        primordials.SafeWeakMap = makeSafe(WeakMap, class extends WeakMap {
-            constructor(i){
-                super(i);
-            }
-        });
-        primordials.SafeSet = makeSafe(Set, class extends Set {
-            constructor(i){
-                super(i);
-            }
-        });
-        primordials.SafeWeakSet = makeSafe(WeakSet, class extends WeakSet {
-            constructor(i){
-                super(i);
-            }
-        });
-        ObjectSetPrototypeOf(primordials, null);
-        ObjectFreeze(primordials);
-        module.exports = primordials;
-    }
-};
-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/internal/primordials.js");

package/generators/node_modules/@pkgjs/parseargs/internal/util.js

@@ -1,24 +0,0 @@
-import * as __WEBPACK_EXTERNAL_MODULE__primordials_js_3b99cd60__ from "./primordials.js";
-var __webpack_modules__ = {
-    "./src/generators/node_modules/@pkgjs/parseargs/internal/util.js": function(module, __unused_webpack_exports, __webpack_require__) {
-        const { ObjectCreate, ObjectFreeze } = __webpack_require__("./primordials");
-        const kEmptyObject = ObjectFreeze(ObjectCreate(null));
-        module.exports = {
-            kEmptyObject
-        };
-    },
-    "./primordials": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__primordials_js_3b99cd60__;
-    }
-};
-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/internal/util.js");

package/generators/node_modules/@pkgjs/parseargs/internal/validators.js

@@ -1,61 +0,0 @@
-import * as __WEBPACK_EXTERNAL_MODULE__errors_js_5fa0851d__ from "./errors.js";
-import * as __WEBPACK_EXTERNAL_MODULE__primordials_js_3b99cd60__ from "./primordials.js";
-var __webpack_modules__ = {
-    "./src/generators/node_modules/@pkgjs/parseargs/internal/validators.js": function(module, __unused_webpack_exports, __webpack_require__) {
-        const { ArrayIsArray, ArrayPrototypeIncludes, ArrayPrototypeJoin } = __webpack_require__("./primordials");
-        const { codes: { ERR_INVALID_ARG_TYPE } } = __webpack_require__("./errors");
-        function validateString(value, name) {
-            if ('string' != typeof value) throw new ERR_INVALID_ARG_TYPE(name, 'String', value);
-        }
-        function validateUnion(value, name, union) {
-            if (!ArrayPrototypeIncludes(union, value)) throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, '|')}')`, value);
-        }
-        function validateBoolean(value, name) {
-            if ('boolean' != typeof value) throw new ERR_INVALID_ARG_TYPE(name, 'Boolean', value);
-        }
-        function validateArray(value, name) {
-            if (!ArrayIsArray(value)) throw new ERR_INVALID_ARG_TYPE(name, 'Array', value);
-        }
-        function validateStringArray(value, name) {
-            validateArray(value, name);
-            for(let i = 0; i < value.length; i++)validateString(value[i], `${name}[${i}]`);
-        }
-        function validateBooleanArray(value, name) {
-            validateArray(value, name);
-            for(let i = 0; i < value.length; i++)validateBoolean(value[i], `${name}[${i}]`);
-        }
-        function validateObject(value, name, options) {
-            const useDefaultOptions = null == options;
-            const allowArray = useDefaultOptions ? false : options.allowArray;
-            const allowFunction = useDefaultOptions ? false : options.allowFunction;
-            const nullable = useDefaultOptions ? false : options.nullable;
-            if (!nullable && null === value || !allowArray && ArrayIsArray(value) || 'object' != typeof value && (!allowFunction || 'function' != typeof value)) throw new ERR_INVALID_ARG_TYPE(name, 'Object', value);
-        }
-        module.exports = {
-            validateArray,
-            validateObject,
-            validateString,
-            validateStringArray,
-            validateUnion,
-            validateBoolean,
-            validateBooleanArray
-        };
-    },
-    "./errors": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__errors_js_5fa0851d__;
-    },
-    "./primordials": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__primordials_js_3b99cd60__;
-    }
-};
-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/internal/validators.js");