@uides/stepwise 2.0.0-rc.32 → 2.0.2

package/generators/node_modules/jackspeak/dist/commonjs/index.js

@@ -0,0 +1,683 @@
+import * as __WEBPACK_EXTERNAL_MODULE__isaacs_cliui_index_js_1d378291__ from "../../../@isaacs/cliui/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__parse_args_js_f91a2c64__ from "./parse-args.js";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__ from "node:util";
+var __webpack_modules__ = {
+    "@isaacs/cliui": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__isaacs_cliui_index_js_1d378291__;
+    },
+    "./parse-args.js": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__parse_args_js_f91a2c64__;
+    },
+    "node:path": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
+    },
+    "node:util": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__;
+    },
+    "./src/generators/node_modules/jackspeak/dist/commonjs/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.jack = exports.Jack = exports.isConfigOption = exports.isConfigType = void 0;
+        const node_util_1 = __webpack_require__("node:util");
+        const parse_args_js_1 = __webpack_require__("./parse-args.js");
+        const cliui_1 = __importDefault(__webpack_require__("@isaacs/cliui"));
+        const node_path_1 = __webpack_require__("node:path");
+        const width = Math.min(process && process.stdout && process.stdout.columns || 80, 80);
+        const indent = (n)=>(n - 1) * 2;
+        const toEnvKey = (pref, key)=>[
+                pref,
+                key.replace(/[^a-zA-Z0-9]+/g, ' ')
+            ].join(' ').trim().toUpperCase().replace(/ /g, '_');
+        const toEnvVal = (value, delim = '\n')=>{
+            const str = 'string' == typeof value ? value : 'boolean' == typeof value ? value ? '1' : '0' : 'number' == typeof value ? String(value) : Array.isArray(value) ? value.map((v)=>toEnvVal(v)).join(delim) : void 0;
+            if ('string' != typeof str) throw new Error(`could not serialize value to environment: ${JSON.stringify(value)}`);
+            return str;
+        };
+        const fromEnvVal = (env, type, multiple, delim = '\n')=>multiple ? env ? env.split(delim).map((v)=>fromEnvVal(v, type, false)) : [] : 'string' === type ? env : 'boolean' === type ? '1' === env : +env.trim();
+        const isConfigType = (t)=>'string' == typeof t && ('string' === t || 'number' === t || 'boolean' === t);
+        exports.isConfigType = isConfigType;
+        const undefOrType = (v, t)=>void 0 === v || typeof v === t;
+        const valueType = (v)=>'string' == typeof v ? 'string' : 'boolean' == typeof v ? 'boolean' : 'number' == typeof v ? 'number' : Array.isArray(v) ? joinTypes([
+                ...new Set(v.map((v)=>valueType(v)))
+            ]) + '[]' : `${v.type}${v.multiple ? '[]' : ''}`;
+        const joinTypes = (types)=>1 === types.length && 'string' == typeof types[0] ? types[0] : `(${types.join('|')})`;
+        const isValidValue = (v, type, multi)=>{
+            if (multi) {
+                if (!Array.isArray(v)) return false;
+                return !v.some((v)=>!isValidValue(v, type, false));
+            }
+            if (Array.isArray(v)) return false;
+            return typeof v === type;
+        };
+        const isConfigOption = (o, type, multi)=>!!o && 'object' == typeof o && (0, exports.isConfigType)(o.type) && o.type === type && undefOrType(o.short, 'string') && undefOrType(o.description, 'string') && undefOrType(o.hint, 'string') && undefOrType(o.validate, 'function') && (void 0 === o.default || isValidValue(o.default, type, multi)) && !!o.multiple === multi;
+        exports.isConfigOption = isConfigOption;
+        function num(o = {}) {
+            const { default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'number', false)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'number',
+                multiple: false
+            };
+        }
+        function numList(o = {}) {
+            const { default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'number', true)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'number',
+                multiple: true
+            };
+        }
+        function opt(o = {}) {
+            const { default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'string', false)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'string',
+                multiple: false
+            };
+        }
+        function optList(o = {}) {
+            const { default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'string', true)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'string',
+                multiple: true
+            };
+        }
+        function flag(o = {}) {
+            const { hint, default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'boolean', false)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            if (void 0 !== hint) throw new TypeError('cannot provide hint for flag');
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'boolean',
+                multiple: false
+            };
+        }
+        function flagList(o = {}) {
+            const { hint, default: def, validate: val, ...rest } = o;
+            if (void 0 !== def && !isValidValue(def, 'boolean', true)) throw new TypeError('invalid default value');
+            const validate = val ? val : void 0;
+            if (void 0 !== hint) throw new TypeError('cannot provide hint for flag list');
+            return {
+                ...rest,
+                default: def,
+                validate,
+                type: 'boolean',
+                multiple: true
+            };
+        }
+        const toParseArgsOptionsConfig = (options)=>{
+            const c = {};
+            for(const longOption in options){
+                const config = options[longOption];
+                if (!config) throw new Error('config must be an object: ' + longOption);
+                if ((0, exports.isConfigOption)(config, 'number', true)) c[longOption] = {
+                    type: 'string',
+                    multiple: true,
+                    default: config.default?.map((c)=>String(c))
+                };
+                else if ((0, exports.isConfigOption)(config, 'number', false)) c[longOption] = {
+                    type: 'string',
+                    multiple: false,
+                    default: void 0 === config.default ? void 0 : String(config.default)
+                };
+                else {
+                    const conf = config;
+                    c[longOption] = {
+                        type: conf.type,
+                        multiple: conf.multiple,
+                        default: conf.default
+                    };
+                }
+                const clo = c[longOption];
+                if ('string' == typeof config.short) clo.short = config.short;
+                if ('boolean' === config.type && !longOption.startsWith('no-') && !options[`no-${longOption}`]) c[`no-${longOption}`] = {
+                    type: 'boolean',
+                    multiple: config.multiple
+                };
+            }
+            return c;
+        };
+        const isHeading = (r)=>'heading' === r.type;
+        const isDescription = (r)=>"description" === r.type;
+        class Jack {
+            #configSet;
+            #shorts;
+            #options;
+            #fields = [];
+            #env;
+            #envPrefix;
+            #allowPositionals;
+            #usage;
+            #usageMarkdown;
+            constructor(options = {}){
+                this.#options = options;
+                this.#allowPositionals = false !== options.allowPositionals;
+                this.#env = void 0 === this.#options.env ? process.env : this.#options.env;
+                this.#envPrefix = options.envPrefix;
+                this.#configSet = Object.create(null);
+                this.#shorts = Object.create(null);
+            }
+            setConfigValues(values, source = '') {
+                try {
+                    this.validate(values);
+                } catch (er) {
+                    throw Object.assign(er, source ? {
+                        source
+                    } : {});
+                }
+                for (const [field, value] of Object.entries(values)){
+                    const my = this.#configSet[field];
+                    if (!my) throw new Error('unexpected field in config set: ' + field);
+                    my.default = value;
+                }
+                return this;
+            }
+            parse(args = process.argv) {
+                if (args === process.argv) args = args.slice(void 0 !== process._eval ? 1 : 2);
+                if (this.#envPrefix) for (const [field, my] of Object.entries(this.#configSet)){
+                    const ek = toEnvKey(this.#envPrefix, field);
+                    const env = this.#env[ek];
+                    if (void 0 !== env) my.default = fromEnvVal(env, my.type, !!my.multiple, my.delim);
+                }
+                const options = toParseArgsOptionsConfig(this.#configSet);
+                const result = (0, parse_args_js_1.parseArgs)({
+                    args,
+                    options,
+                    strict: false,
+                    allowPositionals: this.#allowPositionals,
+                    tokens: true
+                });
+                const p = {
+                    values: {},
+                    positionals: []
+                };
+                for (const token of result.tokens)if ('positional' === token.kind) {
+                    p.positionals.push(token.value);
+                    if (this.#options.stopAtPositional) {
+                        p.positionals.push(...args.slice(token.index + 1));
+                        return p;
+                    }
+                } else if ('option' === token.kind) {
+                    let value;
+                    if (token.name.startsWith('no-')) {
+                        const my = this.#configSet[token.name];
+                        const pname = token.name.substring(3);
+                        const pos = this.#configSet[pname];
+                        if (pos && 'boolean' === pos.type && (!my || 'boolean' === my.type && !!my.multiple === !!pos.multiple)) {
+                            value = false;
+                            token.name = pname;
+                        }
+                    }
+                    const my = this.#configSet[token.name];
+                    if (!my) throw new Error(`Unknown option '${token.rawName}'. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- ${token.rawName}'`);
+                    if (void 0 === value) if (void 0 === token.value) {
+                        if ('boolean' !== my.type) throw new Error(`No value provided for ${token.rawName}, expected ${my.type}`);
+                        value = true;
+                    } else {
+                        if ('boolean' === my.type) throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`);
+                        if ('string' === my.type) value = token.value;
+                        else {
+                            value = +token.value;
+                            if (value !== value) throw new Error(`Invalid value '${token.value}' provided for '${token.rawName}' option, expected number`);
+                        }
+                    }
+                    if (my.multiple) {
+                        const pv = p.values;
+                        const tn = pv[token.name] ?? [];
+                        pv[token.name] = tn;
+                        tn.push(value);
+                    } else {
+                        const pv = p.values;
+                        pv[token.name] = value;
+                    }
+                }
+                for (const [field, c] of Object.entries(this.#configSet))if (void 0 !== c.default && !(field in p.values)) p.values[field] = c.default;
+                for (const [field, value] of Object.entries(p.values)){
+                    const valid = this.#configSet[field]?.validate;
+                    if (valid && !valid(value)) throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`);
+                }
+                this.#writeEnv(p);
+                return p;
+            }
+            #noNoFields(f, val, s = f) {
+                if (!f.startsWith('no-') || 'boolean' != typeof val) return;
+                const yes = f.substring(3);
+                this.#noNoFields(yes, val, s);
+                if (this.#configSet[yes]?.type === 'boolean') throw new Error(`do not set '${s}', instead set '${yes}' as desired.`);
+            }
+            validate(o) {
+                if (!o || 'object' != typeof o) throw new Error('Invalid config: not an object');
+                for(const field in o){
+                    this.#noNoFields(field, o[field]);
+                    const config = this.#configSet[field];
+                    if (!config) throw new Error(`Unknown config option: ${field}`);
+                    if (!isValidValue(o[field], config.type, !!config.multiple)) throw Object.assign(new Error(`Invalid value ${valueType(o[field])} for ${field}, expected ${valueType(config)}`), {
+                        field,
+                        value: o[field]
+                    });
+                    if (config.validate && !config.validate(o[field])) throw new Error(`Invalid config value for ${field}: ${o[field]}`);
+                }
+            }
+            #writeEnv(p) {
+                if (!this.#env || !this.#envPrefix) return;
+                for (const [field, value] of Object.entries(p.values)){
+                    const my = this.#configSet[field];
+                    this.#env[toEnvKey(this.#envPrefix, field)] = toEnvVal(value, my?.delim);
+                }
+            }
+            heading(text, level, { pre = false } = {}) {
+                if (void 0 === level) level = this.#fields.some((r)=>isHeading(r)) ? 2 : 1;
+                this.#fields.push({
+                    type: 'heading',
+                    text,
+                    level,
+                    pre
+                });
+                return this;
+            }
+            description(text, { pre } = {}) {
+                this.#fields.push({
+                    type: "description",
+                    text,
+                    pre
+                });
+                return this;
+            }
+            num(fields) {
+                return this.#addFields(fields, num);
+            }
+            numList(fields) {
+                return this.#addFields(fields, numList);
+            }
+            opt(fields) {
+                return this.#addFields(fields, opt);
+            }
+            optList(fields) {
+                return this.#addFields(fields, optList);
+            }
+            flag(fields) {
+                return this.#addFields(fields, flag);
+            }
+            flagList(fields) {
+                return this.#addFields(fields, flagList);
+            }
+            addFields(fields) {
+                const next = this;
+                for (const [name, field] of Object.entries(fields)){
+                    this.#validateName(name, field);
+                    next.#fields.push({
+                        type: 'config',
+                        name,
+                        value: field
+                    });
+                }
+                Object.assign(next.#configSet, fields);
+                return next;
+            }
+            #addFields(fields, fn) {
+                const next = this;
+                Object.assign(next.#configSet, Object.fromEntries(Object.entries(fields).map(([name, field])=>{
+                    this.#validateName(name, field);
+                    const option = fn(field);
+                    next.#fields.push({
+                        type: 'config',
+                        name,
+                        value: option
+                    });
+                    return [
+                        name,
+                        option
+                    ];
+                })));
+                return next;
+            }
+            #validateName(name, field) {
+                if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(name)) throw new TypeError(`Invalid option name: ${name}, must be '-' delimited ASCII alphanumeric`);
+                if (this.#configSet[name]) throw new TypeError(`Cannot redefine option ${field}`);
+                if (this.#shorts[name]) throw new TypeError(`Cannot redefine option ${name}, already in use for ${this.#shorts[name]}`);
+                if (field.short) {
+                    if (!/^[a-zA-Z0-9]$/.test(field.short)) throw new TypeError(`Invalid ${name} short option: ${field.short}, must be 1 ASCII alphanumeric character`);
+                    if (this.#shorts[field.short]) throw new TypeError(`Invalid ${name} short option: ${field.short}, already in use for ${this.#shorts[field.short]}`);
+                    this.#shorts[field.short] = name;
+                    this.#shorts[name] = name;
+                }
+            }
+            usage() {
+                if (this.#usage) return this.#usage;
+                let headingLevel = 1;
+                const ui = (0, cliui_1.default)({
+                    width
+                });
+                const first = this.#fields[0];
+                let start = first?.type === 'heading' ? 1 : 0;
+                if (first?.type === 'heading') ui.div({
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        0
+                    ],
+                    text: normalize(first.text)
+                });
+                ui.div({
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        0
+                    ],
+                    text: 'Usage:'
+                });
+                if (this.#options.usage) ui.div({
+                    text: this.#options.usage,
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        2
+                    ]
+                });
+                else {
+                    const cmd = (0, node_path_1.basename)(String(process.argv[1]));
+                    const shortFlags = [];
+                    const shorts = [];
+                    const flags = [];
+                    const opts = [];
+                    for (const [field, config] of Object.entries(this.#configSet))if (config.short) if ('boolean' === config.type) shortFlags.push(config.short);
+                    else shorts.push([
+                        config.short,
+                        config.hint || field
+                    ]);
+                    else if ('boolean' === config.type) flags.push(field);
+                    else opts.push([
+                        field,
+                        config.hint || field
+                    ]);
+                    const sf = shortFlags.length ? ' -' + shortFlags.join('') : '';
+                    const so = shorts.map(([k, v])=>` --${k}=<${v}>`).join('');
+                    const lf = flags.map((k)=>` --${k}`).join('');
+                    const lo = opts.map(([k, v])=>` --${k}=<${v}>`).join('');
+                    const usage = `${cmd}${sf}${so}${lf}${lo}`.trim();
+                    ui.div({
+                        text: usage,
+                        padding: [
+                            0,
+                            0,
+                            0,
+                            2
+                        ]
+                    });
+                }
+                ui.div({
+                    padding: [
+                        0,
+                        0,
+                        0,
+                        0
+                    ],
+                    text: ''
+                });
+                const maybeDesc = this.#fields[start];
+                if (maybeDesc && isDescription(maybeDesc)) {
+                    const print = normalize(maybeDesc.text, maybeDesc.pre);
+                    start++;
+                    ui.div({
+                        padding: [
+                            0,
+                            0,
+                            0,
+                            0
+                        ],
+                        text: print
+                    });
+                    ui.div({
+                        padding: [
+                            0,
+                            0,
+                            0,
+                            0
+                        ],
+                        text: ''
+                    });
+                }
+                const { rows, maxWidth } = this.#usageRows(start);
+                for (const row of rows)if (row.left) {
+                    const configIndent = indent(Math.max(headingLevel, 2));
+                    if (row.left.length > maxWidth - 3) {
+                        ui.div({
+                            text: row.left,
+                            padding: [
+                                0,
+                                0,
+                                0,
+                                configIndent
+                            ]
+                        });
+                        ui.div({
+                            text: row.text,
+                            padding: [
+                                0,
+                                0,
+                                0,
+                                maxWidth
+                            ]
+                        });
+                    } else ui.div({
+                        text: row.left,
+                        padding: [
+                            0,
+                            1,
+                            0,
+                            configIndent
+                        ],
+                        width: maxWidth
+                    }, {
+                        padding: [
+                            0,
+                            0,
+                            0,
+                            0
+                        ],
+                        text: row.text
+                    });
+                    if (row.skipLine) ui.div({
+                        padding: [
+                            0,
+                            0,
+                            0,
+                            0
+                        ],
+                        text: ''
+                    });
+                } else if (isHeading(row)) {
+                    const { level } = row;
+                    headingLevel = level;
+                    const b = level <= 2 ? 1 : 0;
+                    ui.div({
+                        ...row,
+                        padding: [
+                            0,
+                            0,
+                            b,
+                            indent(level)
+                        ]
+                    });
+                } else ui.div({
+                    ...row,
+                    padding: [
+                        0,
+                        0,
+                        1,
+                        indent(headingLevel + 1)
+                    ]
+                });
+                return this.#usage = ui.toString();
+            }
+            usageMarkdown() {
+                if (this.#usageMarkdown) return this.#usageMarkdown;
+                const out = [];
+                let headingLevel = 1;
+                const first = this.#fields[0];
+                let start = first?.type === 'heading' ? 1 : 0;
+                if (first?.type === 'heading') out.push(`# ${normalizeOneLine(first.text)}`);
+                out.push('Usage:');
+                if (this.#options.usage) out.push(normalizeMarkdown(this.#options.usage, true));
+                else {
+                    const cmd = (0, node_path_1.basename)(String(process.argv[1]));
+                    const shortFlags = [];
+                    const shorts = [];
+                    const flags = [];
+                    const opts = [];
+                    for (const [field, config] of Object.entries(this.#configSet))if (config.short) if ('boolean' === config.type) shortFlags.push(config.short);
+                    else shorts.push([
+                        config.short,
+                        config.hint || field
+                    ]);
+                    else if ('boolean' === config.type) flags.push(field);
+                    else opts.push([
+                        field,
+                        config.hint || field
+                    ]);
+                    const sf = shortFlags.length ? ' -' + shortFlags.join('') : '';
+                    const so = shorts.map(([k, v])=>` --${k}=<${v}>`).join('');
+                    const lf = flags.map((k)=>` --${k}`).join('');
+                    const lo = opts.map(([k, v])=>` --${k}=<${v}>`).join('');
+                    const usage = `${cmd}${sf}${so}${lf}${lo}`.trim();
+                    out.push(normalizeMarkdown(usage, true));
+                }
+                const maybeDesc = this.#fields[start];
+                if (maybeDesc && isDescription(maybeDesc)) {
+                    out.push(normalizeMarkdown(maybeDesc.text, maybeDesc.pre));
+                    start++;
+                }
+                const { rows } = this.#usageRows(start);
+                for (const row of rows)if (row.left) {
+                    out.push('#'.repeat(headingLevel + 1) + ' ' + normalizeOneLine(row.left, true));
+                    if (row.text) out.push(normalizeMarkdown(row.text));
+                } else if (isHeading(row)) {
+                    const { level } = row;
+                    headingLevel = level;
+                    out.push(`${'#'.repeat(headingLevel)} ${normalizeOneLine(row.text, row.pre)}`);
+                } else out.push(normalizeMarkdown(row.text, !!row.pre));
+                return this.#usageMarkdown = out.join('\n\n') + '\n';
+            }
+            #usageRows(start) {
+                let maxMax = Math.max(12, Math.min(26, Math.floor(width / 3)));
+                let maxWidth = 8;
+                let prev;
+                const rows = [];
+                for (const field of this.#fields.slice(start)){
+                    if ('config' !== field.type) {
+                        if (prev?.type === 'config') prev.skipLine = true;
+                        prev = void 0;
+                        field.text = normalize(field.text, !!field.pre);
+                        rows.push(field);
+                        continue;
+                    }
+                    const { value } = field;
+                    const desc = value.description || '';
+                    const mult = value.multiple ? 'Can be set multiple times' : '';
+                    const dmDelim = mult && (desc.includes('\n') ? '\n\n' : '\n');
+                    const text = normalize(desc + dmDelim + mult);
+                    const hint = value.hint || ('number' === value.type ? 'n' : 'string' === value.type ? field.name : void 0);
+                    const short = value.short ? 'boolean' === value.type ? `-${value.short} ` : `-${value.short}<${hint}> ` : '';
+                    const left = 'boolean' === value.type ? `${short}--${field.name}` : `${short}--${field.name}=<${hint}>`;
+                    const row = {
+                        text,
+                        left,
+                        type: 'config'
+                    };
+                    if (text.length > width - maxMax) row.skipLine = true;
+                    if (prev && left.length > maxMax) prev.skipLine = true;
+                    prev = row;
+                    const len = left.length + 4;
+                    if (len > maxWidth && len < maxMax) maxWidth = len;
+                    rows.push(row);
+                }
+                return {
+                    rows,
+                    maxWidth
+                };
+            }
+            toJSON() {
+                return Object.fromEntries(Object.entries(this.#configSet).map(([field, def])=>[
+                        field,
+                        {
+                            type: def.type,
+                            ...def.multiple ? {
+                                multiple: true
+                            } : {},
+                            ...def.delim ? {
+                                delim: def.delim
+                            } : {},
+                            ...def.short ? {
+                                short: def.short
+                            } : {},
+                            ...def.description ? {
+                                description: normalize(def.description)
+                            } : {},
+                            ...def.validate ? {
+                                validate: def.validate
+                            } : {},
+                            ...void 0 !== def.default ? {
+                                default: def.default
+                            } : {}
+                        }
+                    ]));
+            }
+            [node_util_1.inspect.custom](_, options) {
+                return `Jack ${(0, node_util_1.inspect)(this.toJSON(), options)}`;
+            }
+        }
+        exports.Jack = Jack;
+        const normalize = (s, pre = false)=>pre ? s.split('\n').map((l)=>`\u200b${l}`).join('\n') : s.replace(/([^\n])\n[ \t]*([^\n])/g, (_, $1, $2)=>/^[-*]/.test($2) ? `${$1}\n${$2}` : `${$1} ${$2}`).replace(/([^\n])[ \t]+([^\n])/g, '$1 $2').replace(/\n{3,}/g, '\n\n').replace(/\n[ \t]+/g, '\n').trim();
+        const normalizeMarkdown = (s, pre = false)=>{
+            const n = normalize(s, pre).replace(/\\/g, '\\\\');
+            return pre ? `\`\`\`\n${n.replace(/\u200b/g, '')}\n\`\`\`` : n.replace(/\n +/g, '\n').trim();
+        };
+        const normalizeOneLine = (s, pre = false)=>{
+            const n = normalize(s, pre).replace(/[\s\u200b]+/g, ' ').trim();
+            return pre ? `\`${n}\`` : n;
+        };
+        const jack = (options = {})=>new Jack(options);
+        exports.jack = jack;
+    }
+};
+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].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__("./src/generators/node_modules/jackspeak/dist/commonjs/index.js");