@ndlib/ndlib-cdk2 1.0.30 → 1.0.32

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/jackspeak/dist/commonjs/index.js

@@ -3,23 +3,61 @@ 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;
+exports.jack = exports.Jack = exports.isConfigOption = exports.isConfigOptionOfType = exports.isConfigType = void 0;
 const node_util_1 = require("node:util");
-const parse_args_js_1 = require("./parse-args.js");
 // it's a tiny API, just cast it inline, it's fine
 //@ts-ignore
 const cliui_1 = __importDefault(require("@isaacs/cliui"));
 const node_path_1 = require("node:path");
-const width = Math.min((process && process.stdout && process.stdout.columns) || 80, 80);
+const isConfigType = (t) => typeof t === 'string' &&
+    (t === 'string' || t === 'number' || t === 'boolean');
+exports.isConfigType = isConfigType;
+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 isValidOption = (v, vo) => !!vo &&
+    (Array.isArray(v) ? v.every(x => isValidOption(x, vo)) : vo.includes(v));
+/**
+ * Determine whether an unknown object is a {@link ConfigOption} based only
+ * on its `type` and `multiple` property
+ */
+const isConfigOptionOfType = (o, type, multi) => !!o &&
+    typeof o === 'object' &&
+    (0, exports.isConfigType)(o.type) &&
+    o.type === type &&
+    !!o.multiple === multi;
+exports.isConfigOptionOfType = isConfigOptionOfType;
+/**
+ * Determine whether an unknown object is a {@link ConfigOption} based on
+ * it having all valid properties
+ */
+const isConfigOption = (o, type, multi) => (0, exports.isConfigOptionOfType)(o, type, multi) &&
+    undefOrType(o.short, 'string') &&
+    undefOrType(o.description, 'string') &&
+    undefOrType(o.hint, 'string') &&
+    undefOrType(o.validate, 'function') &&
+    (o.type === 'boolean' ?
+        o.validOptions === undefined
+        : undefOrTypeArray(o.validOptions, o.type)) &&
+    (o.default === undefined || isValidValue(o.default, type, multi));
+exports.isConfigOption = isConfigOption;
+const isHeading = (r) => r.type === 'heading';
+const isDescription = (r) => r.type === 'description';
+const width = Math.min(process?.stdout?.columns ?? 80, 80);
 // indentation spaces from heading level
 const indent = (n) => (n - 1) * 2;
-const toEnvKey = (pref, key) => {
-    return [pref, key.replace(/[^a-zA-Z0-9]+/g, ' ')]
-        .join(' ')
-        .trim()
-        .toUpperCase()
-        .replace(/ /g, '_');
-};
+const toEnvKey = (pref, key) => [pref, key.replace(/[^a-zA-Z0-9]+/g, ' ')]
+    .join(' ')
+    .trim()
+    .toUpperCase()
+    .replace(/ /g, '_');
 const toEnvVal = (value, delim = '\n') => {
     const str = typeof value === 'string' ? value
         : typeof value === 'boolean' ?
@@ -30,7 +68,7 @@ const toEnvVal = (value, delim = '\n') => {
                     value.map((v) => toEnvVal(v)).join(delim)
                     : /* c8 ignore start */ undefined;
     if (typeof str !== 'string') {
-        throw new Error(`could not serialize value to environment: ${JSON.stringify(value)}`);
+        throw new Error(`could not serialize value to environment: ${JSON.stringify(value)}`, { cause: { code: 'JACKSPEAK' } });
     }
     /* c8 ignore stop */
     return str;
@@ -41,256 +79,144 @@ const fromEnvVal = (env, type, multiple, delim = '\n') => (multiple ?
     : type === 'string' ? env
         : type === 'boolean' ? env === '1'
             : +env.trim());
-const isConfigType = (t) => typeof t === 'string' &&
-    (t === 'string' || t === 'number' || t === 'boolean');
-exports.isConfigType = isConfigType;
 const undefOrType = (v, t) => v === undefined || typeof v === t;
 const undefOrTypeArray = (v, t) => v === undefined || (Array.isArray(v) && v.every(x => typeof x === t));
-const isValidOption = (v, vo) => Array.isArray(v) ? v.every(x => isValidOption(x, vo)) : vo.includes(v);
 // print the value type, for error message reporting
 const valueType = (v) => typeof v === 'string' ? 'string'
     : typeof v === 'boolean' ? 'boolean'
         : typeof v === 'number' ? 'number'
             : Array.isArray(v) ?
-                joinTypes([...new Set(v.map(v => valueType(v)))]) + '[]'
+                `${joinTypes([...new Set(v.map(v => valueType(v)))])}[]`
                 : `${v.type}${v.multiple ? '[]' : ''}`;
 const joinTypes = (types) => types.length === 1 && typeof types[0] === 'string' ?
     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 &&
-    typeof o === 'object' &&
-    (0, exports.isConfigType)(o.type) &&
-    o.type === type &&
-    undefOrType(o.short, 'string') &&
-    undefOrType(o.description, 'string') &&
-    undefOrType(o.hint, 'string') &&
-    undefOrType(o.validate, 'function') &&
-    (o.type === 'boolean' ?
-        o.validOptions === undefined
-        : undefOrTypeArray(o.validOptions, o.type)) &&
-    (o.default === undefined || isValidValue(o.default, type, multi)) &&
-    !!o.multiple === multi;
-exports.isConfigOption = isConfigOption;
-function num(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'number', false)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'number',
-            },
-        });
-    }
-    if (!undefOrTypeArray(validOptions, 'number')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'number[]',
-            },
-        });
-    }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'number',
-        multiple: false,
-    };
-}
-function numList(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'number', true)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'number[]',
-            },
-        });
+const validateFieldMeta = (field, fieldMeta) => {
+    if (fieldMeta) {
+        if (field.type !== undefined && field.type !== fieldMeta.type) {
+            throw new TypeError(`invalid type`, {
+                cause: {
+                    found: field.type,
+                    wanted: [fieldMeta.type, undefined],
+                },
+            });
+        }
+        if (field.multiple !== undefined &&
+            !!field.multiple !== fieldMeta.multiple) {
+            throw new TypeError(`invalid multiple`, {
+                cause: {
+                    found: field.multiple,
+                    wanted: [fieldMeta.multiple, undefined],
+                },
+            });
+        }
+        return fieldMeta;
     }
-    if (!undefOrTypeArray(validOptions, 'number')) {
-        throw new TypeError('invalid validOptions', {
+    if (!(0, exports.isConfigType)(field.type)) {
+        throw new TypeError(`invalid type`, {
             cause: {
-                found: validOptions,
-                wanted: 'number[]',
+                found: field.type,
+                wanted: ['string', 'number', 'boolean'],
             },
         });
     }
-    const validate = val ?
-        val
-        : undefined;
     return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'number',
-        multiple: true,
+        type: field.type,
+        multiple: !!field.multiple,
     };
-}
-function opt(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'string', false)) {
-        throw new TypeError('invalid default value', {
-            cause: {
-                found: def,
-                wanted: 'string',
-            },
-        });
-    }
-    if (!undefOrTypeArray(validOptions, 'string')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'string[]',
-            },
-        });
-    }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'string',
-        multiple: false,
+};
+const validateField = (o, type, multiple) => {
+    const validateValidOptions = (def, validOptions) => {
+        if (!undefOrTypeArray(validOptions, type)) {
+            throw new TypeError('invalid validOptions', {
+                cause: {
+                    found: validOptions,
+                    wanted: valueType({ type, multiple: true }),
+                },
+            });
+        }
+        if (def !== undefined && validOptions !== undefined) {
+            const valid = Array.isArray(def) ?
+                def.every(v => validOptions.includes(v))
+                : validOptions.includes(def);
+            if (!valid) {
+                throw new TypeError('invalid default value not in validOptions', {
+                    cause: {
+                        found: def,
+                        wanted: validOptions,
+                    },
+                });
+            }
+        }
     };
-}
-function optList(o = {}) {
-    const { default: def, validate: val, validOptions, ...rest } = o;
-    if (def !== undefined && !isValidValue(def, 'string', true)) {
+    if (o.default !== undefined &&
+        !isValidValue(o.default, type, multiple)) {
         throw new TypeError('invalid default value', {
             cause: {
-                found: def,
-                wanted: 'string[]',
+                found: o.default,
+                wanted: valueType({ type, multiple }),
             },
         });
     }
-    if (!undefOrTypeArray(validOptions, 'string')) {
-        throw new TypeError('invalid validOptions', {
-            cause: {
-                found: validOptions,
-                wanted: 'string[]',
-            },
-        });
+    if ((0, exports.isConfigOptionOfType)(o, 'number', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'number', true)) {
+        validateValidOptions(o.default, o.validOptions);
     }
-    const validate = val ?
-        val
-        : undefined;
-    return {
-        ...rest,
-        default: def,
-        validate,
-        validOptions,
-        type: 'string',
-        multiple: true,
-    };
-}
-function flag(o = {}) {
-    const { hint, default: def, validate: val, ...rest } = o;
-    delete rest.validOptions;
-    if (def !== undefined && !isValidValue(def, 'boolean', false)) {
-        throw new TypeError('invalid default value');
-    }
-    const validate = val ?
-        val
-        : undefined;
-    if (hint !== undefined) {
-        throw new TypeError('cannot provide hint for flag');
+    else if ((0, exports.isConfigOptionOfType)(o, 'string', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'string', true)) {
+        validateValidOptions(o.default, o.validOptions);
     }
-    return {
-        ...rest,
-        default: def,
-        validate,
-        type: 'boolean',
-        multiple: false,
-    };
-}
-function flagList(o = {}) {
-    const { hint, default: def, validate: val, ...rest } = o;
-    delete rest.validOptions;
-    if (def !== undefined && !isValidValue(def, 'boolean', true)) {
-        throw new TypeError('invalid default value');
-    }
-    const validate = val ?
-        val
-        : undefined;
-    if (hint !== undefined) {
-        throw new TypeError('cannot provide hint for flag list');
+    else if ((0, exports.isConfigOptionOfType)(o, 'boolean', false) ||
+        (0, exports.isConfigOptionOfType)(o, 'boolean', true)) {
+        if (o.hint !== undefined) {
+            throw new TypeError('cannot provide hint for flag');
+        }
+        if (o.validOptions !== undefined) {
+            throw new TypeError('cannot provide validOptions for flag');
+        }
     }
-    return {
-        ...rest,
-        default: def,
-        validate,
-        type: 'boolean',
-        multiple: true,
-    };
-}
+    return o;
+};
 const toParseArgsOptionsConfig = (options) => {
-    const c = {};
-    for (const longOption in options) {
-        const config = options[longOption];
-        /* c8 ignore start */
-        if (!config) {
-            throw new Error('config must be an object: ' + longOption);
-        }
-        /* c8 ignore start */
-        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: config.default === undefined ?
-                    undefined
-                    : String(config.default),
-            };
+    return Object.entries(options).reduce((acc, [longOption, o]) => {
+        const p = {
+            type: 'string',
+            multiple: !!o.multiple,
+            ...(typeof o.short === 'string' ? { short: o.short } : undefined),
+        };
+        const setNoBool = () => {
+            if (!longOption.startsWith('no-') && !options[`no-${longOption}`]) {
+                acc[`no-${longOption}`] = {
+                    type: 'boolean',
+                    multiple: !!o.multiple,
+                };
+            }
+        };
+        const setDefault = (def, fn) => {
+            if (def !== undefined) {
+                p.default = fn(def);
+            }
+        };
+        if ((0, exports.isConfigOption)(o, 'number', false)) {
+            setDefault(o.default, String);
         }
-        else {
-            const conf = config;
-            c[longOption] = {
-                type: conf.type,
-                multiple: !!conf.multiple,
-                default: conf.default,
-            };
-        }
-        const clo = c[longOption];
-        if (typeof config.short === 'string') {
-            clo.short = config.short;
-        }
-        if (config.type === 'boolean' &&
-            !longOption.startsWith('no-') &&
-            !options[`no-${longOption}`]) {
-            c[`no-${longOption}`] = {
-                type: 'boolean',
-                multiple: config.multiple,
-            };
-        }
-    }
-    return c;
+        else if ((0, exports.isConfigOption)(o, 'number', true)) {
+            setDefault(o.default, d => d.map(v => String(v)));
+        }
+        else if ((0, exports.isConfigOption)(o, 'string', false) ||
+            (0, exports.isConfigOption)(o, 'string', true)) {
+            setDefault(o.default, v => v);
+        }
+        else if ((0, exports.isConfigOption)(o, 'boolean', false) ||
+            (0, exports.isConfigOption)(o, 'boolean', true)) {
+            p.type = 'boolean';
+            setDefault(o.default, v => v);
+            setNoBool();
+        }
+        acc[longOption] = p;
+        return acc;
+    }, {});
 };
-const isHeading = (r) => r.type === 'heading';
-const isDescription = (r) => r.type === 'description';
 /**
  * Class returned by the {@link jack} function and all configuration
  * definition methods.  This is what gets chained together.
@@ -317,6 +243,18 @@ class Jack {
         this.#configSet = Object.create(null);
         this.#shorts = Object.create(null);
     }
+    get definitions() {
+        return this.#configSet;
+    }
+    get shorts() {
+        return this.#shorts;
+    }
+    get jackOptions() {
+        return this.#options;
+    }
+    get usageFields() {
+        return this.#fields;
+    }
     /**
      * Set the default value (which will still be overridden by env or cli)
      * as if from a parsed config file. The optional `source` param, if
@@ -328,16 +266,12 @@ class Jack {
             this.validate(values);
         }
         catch (er) {
-            const e = er;
-            if (source && e && typeof e === 'object') {
-                if (e.cause && typeof e.cause === 'object') {
-                    Object.assign(e.cause, { path: source });
-                }
-                else {
-                    e.cause = { path: source };
-                }
+            if (source && er instanceof Error) {
+                /* c8 ignore next */
+                const cause = typeof er.cause === 'object' ? er.cause : {};
+                er.cause = { ...cause, path: source };
             }
-            throw e;
+            throw er;
         }
         for (const [field, value] of Object.entries(values)) {
             const my = this.#configSet[field];
@@ -345,7 +279,10 @@ class Jack {
             /* c8 ignore start */
             if (!my) {
                 throw new Error('unexpected field in config set: ' + field, {
-                    cause: { found: field },
+                    cause: {
+                        code: 'JACKSPEAK',
+                        found: field,
+                    },
                 });
             }
             /* c8 ignore stop */
@@ -365,9 +302,13 @@ class Jack {
      * an explicit CLI setting.
      */
     parse(args = process.argv) {
-        if (args === process.argv) {
-            args = args.slice(process._eval !== undefined ? 1 : 2);
-        }
+        this.loadEnvDefaults();
+        const p = this.parseRaw(args);
+        this.applyDefaults(p);
+        this.writeEnv(p);
+        return p;
+    }
+    loadEnvDefaults() {
         if (this.#envPrefix) {
             for (const [field, my] of Object.entries(this.#configSet)) {
                 const ek = toEnvKey(this.#envPrefix, field);
@@ -377,10 +318,28 @@ class Jack {
                 }
             }
         }
-        const options = toParseArgsOptionsConfig(this.#configSet);
-        const result = (0, parse_args_js_1.parseArgs)({
+    }
+    applyDefaults(p) {
+        for (const [field, c] of Object.entries(this.#configSet)) {
+            if (c.default !== undefined && !(field in p.values)) {
+                //@ts-ignore
+                p.values[field] = c.default;
+            }
+        }
+    }
+    /**
+     * Only parse the command line arguments passed in.
+     * Does not strip off the `node script.js` bits, so it must be just the
+     * arguments you wish to have parsed.
+     * Does not read from or write to the environment, or set defaults.
+     */
+    parseRaw(args) {
+        if (args === process.argv) {
+            args = args.slice(process._eval !== undefined ? 1 : 2);
+        }
+        const result = (0, node_util_1.parseArgs)({
             args,
-            options,
+            options: toParseArgsOptionsConfig(this.#configSet),
             // always strict, but using our own logic
             strict: false,
             allowPositionals: this.#allowPositionals,
@@ -393,9 +352,10 @@ class Jack {
         for (const token of result.tokens) {
             if (token.kind === 'positional') {
                 p.positionals.push(token.value);
-                if (this.#options.stopAtPositional) {
+                if (this.#options.stopAtPositional ||
+                    this.#options.stopAtPositionalTest?.(token.value)) {
                     p.positionals.push(...args.slice(token.index + 1));
-                    return p;
+                    break;
                 }
             }
             else if (token.kind === 'option') {
@@ -419,6 +379,7 @@ class Jack {
                         `place it at the end of the command after '--', as in ` +
                         `'-- ${token.rawName}'`, {
                         cause: {
+                            code: 'JACKSPEAK',
                             found: token.rawName + (token.value ? `=${token.value}` : ''),
                         },
                     });
@@ -428,6 +389,7 @@ class Jack {
                         if (my.type !== 'boolean') {
                             throw new Error(`No value provided for ${token.rawName}, expected ${my.type}`, {
                                 cause: {
+                                    code: 'JACKSPEAK',
                                     name: token.rawName,
                                     wanted: valueType(my),
                                 },
@@ -437,7 +399,7 @@ class Jack {
                     }
                     else {
                         if (my.type === 'boolean') {
-                            throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`, { cause: { found: token } });
+                            throw new Error(`Flag ${token.rawName} does not take a value, received '${token.value}'`, { cause: { code: 'JACKSPEAK', found: token } });
                         }
                         if (my.type === 'string') {
                             value = token.value;
@@ -448,6 +410,7 @@ class Jack {
                                 throw new Error(`Invalid value '${token.value}' provided for ` +
                                     `'${token.rawName}' option, expected number`, {
                                     cause: {
+                                        code: 'JACKSPEAK',
                                         name: token.rawName,
                                         found: token.value,
                                         wanted: 'number',
@@ -469,27 +432,17 @@ class Jack {
                 }
             }
         }
-        for (const [field, c] of Object.entries(this.#configSet)) {
-            if (c.default !== undefined && !(field in p.values)) {
-                //@ts-ignore
-                p.values[field] = c.default;
-            }
-        }
         for (const [field, value] of Object.entries(p.values)) {
             const valid = this.#configSet[field]?.validate;
             const validOptions = this.#configSet[field]?.validOptions;
-            let cause;
-            if (validOptions && !isValidOption(value, validOptions)) {
-                cause = { name: field, found: value, validOptions: validOptions };
-            }
-            if (valid && !valid(value)) {
-                cause ??= { name: field, found: value };
-            }
+            const cause = validOptions && !isValidOption(value, validOptions) ?
+                { name: field, found: value, validOptions }
+                : valid && !valid(value) ? { name: field, found: value }
+                    : undefined;
             if (cause) {
-                throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`, { cause });
+                throw new Error(`Invalid value provided for --${field}: ${JSON.stringify(value)}`, { cause: { ...cause, code: 'JACKSPEAK' } });
             }
         }
-        this.#writeEnv(p);
         return p;
     }
     /**
@@ -503,7 +456,7 @@ class Jack {
         // recurse so we get the core config key we care about.
         this.#noNoFields(yes, val, s);
         if (this.#configSet[yes]?.type === 'boolean') {
-            throw new Error(`do not set '${s}', instead set '${yes}' as desired.`, { cause: { found: s, wanted: yes } });
+            throw new Error(`do not set '${s}', instead set '${yes}' as desired.`, { cause: { code: 'JACKSPEAK', found: s, wanted: yes } });
         }
     }
     /**
@@ -513,7 +466,7 @@ class Jack {
     validate(o) {
         if (!o || typeof o !== 'object') {
             throw new Error('Invalid config: not an object', {
-                cause: { found: o },
+                cause: { code: 'JACKSPEAK', found: o },
             });
         }
         const opts = o;
@@ -526,38 +479,32 @@ class Jack {
             const config = this.#configSet[field];
             if (!config) {
                 throw new Error(`Unknown config option: ${field}`, {
-                    cause: { found: field },
+                    cause: { code: 'JACKSPEAK', found: field },
                 });
             }
             if (!isValidValue(value, config.type, !!config.multiple)) {
                 throw new Error(`Invalid value ${valueType(value)} for ${field}, expected ${valueType(config)}`, {
                     cause: {
+                        code: 'JACKSPEAK',
                         name: field,
                         found: value,
                         wanted: valueType(config),
                     },
                 });
             }
-            let cause;
-            if (config.validOptions &&
-                !isValidOption(value, config.validOptions)) {
-                cause = {
-                    name: field,
-                    found: value,
-                    validOptions: config.validOptions,
-                };
-            }
-            if (config.validate && !config.validate(value)) {
-                cause ??= { name: field, found: value };
-            }
+            const cause = config.validOptions && !isValidOption(value, config.validOptions) ?
+                { name: field, found: value, validOptions: config.validOptions }
+                : config.validate && !config.validate(value) ?
+                    { name: field, found: value }
+                    : undefined;
             if (cause) {
                 throw new Error(`Invalid config value for ${field}: ${value}`, {
-                    cause,
+                    cause: { ...cause, code: 'JACKSPEAK' },
                 });
             }
         }
     }
-    #writeEnv(p) {
+    writeEnv(p) {
         if (!this.#env || !this.#envPrefix)
             return;
         for (const [field, value] of Object.entries(p.values)) {
@@ -586,37 +533,37 @@ class Jack {
      * Add one or more number fields.
      */
     num(fields) {
-        return this.#addFields(fields, num);
+        return this.#addFieldsWith(fields, 'number', false);
     }
     /**
      * Add one or more multiple number fields.
      */
     numList(fields) {
-        return this.#addFields(fields, numList);
+        return this.#addFieldsWith(fields, 'number', true);
     }
     /**
      * Add one or more string option fields.
      */
     opt(fields) {
-        return this.#addFields(fields, opt);
+        return this.#addFieldsWith(fields, 'string', false);
     }
     /**
      * Add one or more multiple string option fields.
      */
     optList(fields) {
-        return this.#addFields(fields, optList);
+        return this.#addFieldsWith(fields, 'string', true);
     }
     /**
      * Add one or more flag fields.
      */
     flag(fields) {
-        return this.#addFields(fields, flag);
+        return this.#addFieldsWith(fields, 'boolean', false);
     }
     /**
      * Add one or more multiple flag fields.
      */
     flagList(fields) {
-        return this.#addFields(fields, flagList);
+        return this.#addFieldsWith(fields, 'boolean', true);
     }
     /**
      * Generic field definition method. Similar to flag/flagList/number/etc,
@@ -624,29 +571,22 @@ class Jack {
      * fields on each one, or Jack won't know how to define them.
      */
     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;
+        return this.#addFields(this, fields);
     }
-    #addFields(fields, fn) {
-        const next = this;
+    #addFieldsWith(fields, type, multiple) {
+        return this.#addFields(this, fields, {
+            type,
+            multiple,
+        });
+    }
+    #addFields(next, fields, opt) {
         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];
+            const { type, multiple } = validateFieldMeta(field, opt);
+            const value = { ...field, type, multiple };
+            validateField(value, type, multiple);
+            next.#fields.push({ type: 'config', name, value });
+            return [name, value];
         })));
         return next;
     }
@@ -682,6 +622,7 @@ class Jack {
         if (this.#usage)
             return this.#usage;
         let headingLevel = 1;
+        //@ts-ignore
         const ui = (0, cliui_1.default)({ width });
         const first = this.#fields[0];
         let start = first?.type === 'heading' ? 1 : 0;
@@ -912,6 +853,7 @@ class Jack {
                 ...(def.validate ? { validate: def.validate } : {}),
                 ...(def.validOptions ? { validOptions: def.validOptions } : {}),
                 ...(def.default !== undefined ? { default: def.default } : {}),
+                ...(def.hint ? { hint: def.hint } : {}),
             },
         ]));
     }
@@ -923,24 +865,59 @@ class Jack {
     }
 }
 exports.Jack = Jack;
+/**
+ * Main entry point. Create and return a {@link Jack} object.
+ */
+const jack = (options = {}) => new Jack(options);
+exports.jack = jack;
 // Unwrap and un-indent, so we can wrap description
 // strings however makes them look nice in the code.
-const normalize = (s, pre = false) => pre ?
-    // prepend a ZWSP to each line so cliui doesn't strip it.
-    s
-        .split('\n')
-        .map(l => `\u200b${l}`)
-        .join('\n')
-    : s
-        // remove single line breaks, except for lists
-        .replace(/([^\n])\n[ \t]*([^\n])/g, (_, $1, $2) => !/^[-*]/.test($2) ? `${$1} ${$2}` : `${$1}\n${$2}`)
-        // normalize mid-line whitespace
-        .replace(/([^\n])[ \t]+([^\n])/g, '$1 $2')
-        // two line breaks are enough
-        .replace(/\n{3,}/g, '\n\n')
-        // remove any spaces at the start of a line
-        .replace(/\n[ \t]+/g, '\n')
-        .trim();
+const normalize = (s, pre = false) => {
+    if (pre)
+        // prepend a ZWSP to each line so cliui doesn't strip it.
+        return s
+            .split('\n')
+            .map(l => `\u200b${l}`)
+            .join('\n');
+    return s
+        .split(/^\s*```\s*$/gm)
+        .map((s, i) => {
+        if (i % 2 === 1) {
+            if (!s.trim()) {
+                return `\`\`\`\n\`\`\`\n`;
+            }
+            // outdent the ``` blocks, but preserve whitespace otherwise.
+            const split = s.split('\n');
+            // throw out the \n at the start and end
+            split.pop();
+            split.shift();
+            const si = split.reduce((shortest, l) => {
+                /* c8 ignore next */
+                const ind = l.match(/^\s*/)?.[0] ?? '';
+                if (ind.length)
+                    return Math.min(ind.length, shortest);
+                else
+                    return shortest;
+            }, Infinity);
+            /* c8 ignore next */
+            const i = isFinite(si) ? si : 0;
+            return ('\n```\n' +
+                split.map(s => `\u200b${s.substring(i)}`).join('\n') +
+                '\n```\n');
+        }
+        return (s
+            // remove single line breaks, except for lists
+            .replace(/([^\n])\n[ \t]*([^\n])/g, (_, $1, $2) => !/^[-*]/.test($2) ? `${$1} ${$2}` : `${$1}\n${$2}`)
+            // normalize mid-line whitespace
+            .replace(/([^\n])[ \t]+([^\n])/g, '$1 $2')
+            // two line breaks are enough
+            .replace(/\n{3,}/g, '\n\n')
+            // remove any spaces at the start of a line
+            .replace(/\n[ \t]+/g, '\n')
+            .trim());
+    })
+        .join('\n');
+};
 // normalize for markdown printing, remove leading spaces on lines
 const normalizeMarkdown = (s, pre = false) => {
     const n = normalize(s, pre).replace(/\\/g, '\\\\');
@@ -954,9 +931,4 @@ const normalizeOneLine = (s, pre = false) => {
         .trim();
     return pre ? `\`${n}\`` : n;
 };
-/**
- * Main entry point. Create and return a {@link Jack} object.
- */
-const jack = (options = {}) => new Jack(options);
-exports.jack = jack;
 //# sourceMappingURL=index.js.map