KI

KJ

unified-ai-platform/node_modules/jackspeak/dist/esm/index.d.ts

@@ -0,0 +1,315 @@
+/// <reference types="node" resolution-mode="require"/>
+export type ConfigType = 'number' | 'string' | 'boolean';
+/**
+ * Given a Jack object, get the typeof its ConfigSet
+ */
+export type Unwrap<J> = J extends Jack<infer C> ? C : never;
+import { inspect, InspectOptions } from 'node:util';
+/**
+ * Defines the type of value that is valid, given a config definition's
+ * {@link ConfigType} and boolean multiple setting
+ */
+export type ValidValue<T extends ConfigType = ConfigType, M extends boolean = boolean> = [
+    T,
+    M
+] extends ['number', true] ? number[] : [T, M] extends ['string', true] ? string[] : [T, M] extends ['boolean', true] ? boolean[] : [T, M] extends ['number', false] ? number : [T, M] extends ['string', false] ? string : [T, M] extends ['boolean', false] ? boolean : [T, M] extends ['string', boolean] ? string | string[] : [T, M] extends ['boolean', boolean] ? boolean | boolean[] : [T, M] extends ['number', boolean] ? number | number[] : [T, M] extends [ConfigType, false] ? string | number | boolean : [T, M] extends [ConfigType, true] ? string[] | number[] | boolean[] : string | number | boolean | string[] | number[] | boolean[];
+/**
+ * The meta information for a config option definition, when the
+ * type and multiple values can be inferred by the method being used
+ */
+export type ConfigOptionMeta<T extends ConfigType, M extends boolean = boolean, O extends undefined | (T extends 'boolean' ? never : T extends 'string' ? readonly string[] : T extends 'number' ? readonly number[] : readonly number[] | readonly string[]) = undefined | (T extends 'boolean' ? never : T extends 'string' ? readonly string[] : T extends 'number' ? readonly number[] : readonly number[] | readonly string[])> = {
+    default?: undefined | (ValidValue<T, M> & (O extends number[] | string[] ? M extends false ? O[number] : O[number][] : unknown));
+    validOptions?: O;
+    description?: string;
+    validate?: ((v: unknown) => v is ValidValue<T, M>) | ((v: unknown) => boolean);
+    short?: string | undefined;
+    type?: T;
+    hint?: T extends 'boolean' ? never : string;
+    delim?: M extends true ? string : never;
+} & (M extends false ? {
+    multiple?: false | undefined;
+} : M extends true ? {
+    multiple: true;
+} : {
+    multiple?: boolean;
+});
+/**
+ * A set of {@link ConfigOptionMeta} fields, referenced by their longOption
+ * string values.
+ */
+export type ConfigMetaSet<T extends ConfigType, M extends boolean = boolean> = {
+    [longOption: string]: ConfigOptionMeta<T, M>;
+};
+/**
+ * Infer {@link ConfigSet} fields from a given {@link ConfigMetaSet}
+ */
+export type ConfigSetFromMetaSet<T extends ConfigType, M extends boolean, S extends ConfigMetaSet<T, M>> = {
+    [longOption in keyof S]: ConfigOptionBase<T, M>;
+};
+/**
+ * Fields that can be set on a {@link ConfigOptionBase} or
+ * {@link ConfigOptionMeta} based on whether or not the field is known to be
+ * multiple.
+ */
+export type MultiType<M extends boolean> = M extends true ? {
+    multiple: true;
+    delim?: string | undefined;
+} : M extends false ? {
+    multiple?: false | undefined;
+    delim?: undefined;
+} : {
+    multiple?: boolean | undefined;
+    delim?: string | undefined;
+};
+/**
+ * A config field definition, in its full representation.
+ */
+export type ConfigOptionBase<T extends ConfigType, M extends boolean = boolean> = {
+    type: T;
+    short?: string | undefined;
+    default?: ValidValue<T, M> | undefined;
+    description?: string;
+    hint?: T extends 'boolean' ? undefined : string | undefined;
+    validate?: (v: unknown) => v is ValidValue<T, M>;
+    validOptions?: T extends 'boolean' ? undefined : T extends 'string' ? readonly string[] : T extends 'number' ? readonly number[] : readonly number[] | readonly string[];
+} & MultiType<M>;
+export declare const isConfigType: (t: string) => t is ConfigType;
+export declare const isConfigOption: <T extends ConfigType, M extends boolean>(o: any, type: T, multi: M) => o is ConfigOptionBase<T, M>;
+/**
+ * A set of {@link ConfigOptionBase} objects, referenced by their longOption
+ * string values.
+ */
+export type ConfigSet = {
+    [longOption: string]: ConfigOptionBase<ConfigType>;
+};
+/**
+ * The 'values' field returned by {@link Jack#parse}
+ */
+export type OptionsResults<T extends ConfigSet> = {
+    [k in keyof T]?: T[k]['validOptions'] extends (readonly string[] | readonly number[]) ? T[k] extends ConfigOptionBase<'string' | 'number', false> ? T[k]['validOptions'][number] : T[k] extends ConfigOptionBase<'string' | 'number', true> ? T[k]['validOptions'][number][] : never : T[k] extends ConfigOptionBase<'string', false> ? string : T[k] extends ConfigOptionBase<'string', true> ? string[] : T[k] extends ConfigOptionBase<'number', false> ? number : T[k] extends ConfigOptionBase<'number', true> ? number[] : T[k] extends ConfigOptionBase<'boolean', false> ? boolean : T[k] extends ConfigOptionBase<'boolean', true> ? boolean[] : never;
+};
+/**
+ * The object retured by {@link Jack#parse}
+ */
+export type Parsed<T extends ConfigSet> = {
+    values: OptionsResults<T>;
+    positionals: string[];
+};
+/**
+ * A row used when generating the {@link Jack#usage} string
+ */
+export interface Row {
+    left?: string;
+    text: string;
+    skipLine?: boolean;
+    type?: string;
+}
+/**
+ * A heading for a section in the usage, created by the jack.heading()
+ * method.
+ *
+ * First heading is always level 1, subsequent headings default to 2.
+ *
+ * The level of the nearest heading level sets the indentation of the
+ * description that follows.
+ */
+export interface Heading extends Row {
+    type: 'heading';
+    text: string;
+    left?: '';
+    skipLine?: boolean;
+    level: number;
+    pre?: boolean;
+}
+/**
+ * An arbitrary blob of text describing some stuff, set by the
+ * jack.description() method.
+ *
+ * Indentation determined by level of the nearest header.
+ */
+export interface Description extends Row {
+    type: 'description';
+    text: string;
+    left?: '';
+    skipLine?: boolean;
+    pre?: boolean;
+}
+/**
+ * A heading or description row used when generating the {@link Jack#usage}
+ * string
+ */
+export type TextRow = Heading | Description;
+/**
+ * Either a {@link TextRow} or a reference to a {@link ConfigOptionBase}
+ */
+export type UsageField = TextRow | {
+    type: 'config';
+    name: string;
+    value: ConfigOptionBase<ConfigType>;
+};
+/**
+ * Options provided to the {@link Jack} constructor
+ */
+export interface JackOptions {
+    /**
+     * Whether to allow positional arguments
+     *
+     * @default true
+     */
+    allowPositionals?: boolean;
+    /**
+     * Prefix to use when reading/writing the environment variables
+     *
+     * If not specified, environment behavior will not be available.
+     */
+    envPrefix?: string;
+    /**
+     * Environment object to read/write. Defaults `process.env`.
+     * No effect if `envPrefix` is not set.
+     */
+    env?: {
+        [k: string]: string | undefined;
+    };
+    /**
+     * A short usage string. If not provided, will be generated from the
+     * options provided, but that can of course be rather verbose if
+     * there are a lot of options.
+     */
+    usage?: string;
+    /**
+     * Stop parsing flags and opts at the first positional argument.
+     * This is to support cases like `cmd [flags] <subcmd> [options]`, where
+     * each subcommand may have different options.  This effectively treats
+     * any positional as a `--` argument.  Only relevant if `allowPositionals`
+     * is true.
+     *
+     * To do subcommands, set this option, look at the first positional, and
+     * parse the remaining positionals as appropriate.
+     *
+     * @default false
+     */
+    stopAtPositional?: boolean;
+    /**
+     * Conditional `stopAtPositional`. If set to a `(string)=>boolean` function,
+     * will be called with each positional argument encountered. If the function
+     * returns true, then parsing will stop at that point.
+     */
+    stopAtPositionalTest?: (arg: string) => boolean;
+}
+/**
+ * Class returned by the {@link jack} function and all configuration
+ * definition methods.  This is what gets chained together.
+ */
+export declare class Jack<C extends ConfigSet = {}> {
+    #private;
+    constructor(options?: JackOptions);
+    /**
+     * 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
+     * provided, will be included in error messages if a value is invalid or
+     * unknown.
+     */
+    setConfigValues(values: OptionsResults<C>, source?: string): this;
+    /**
+     * Parse a string of arguments, and return the resulting
+     * `{ values, positionals }` object.
+     *
+     * If an {@link JackOptions#envPrefix} is set, then it will read default
+     * values from the environment, and write the resulting values back
+     * to the environment as well.
+     *
+     * Environment values always take precedence over any other value, except
+     * an explicit CLI setting.
+     */
+    parse(args?: string[]): Parsed<C>;
+    loadEnvDefaults(): void;
+    applyDefaults(p: Parsed<C>): void;
+    /**
+     * 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: string[]): Parsed<C>;
+    /**
+     * Validate that any arbitrary object is a valid configuration `values`
+     * object.  Useful when loading config files or other sources.
+     */
+    validate(o: unknown): asserts o is Parsed<C>['values'];
+    writeEnv(p: Parsed<C>): void;
+    /**
+     * Add a heading to the usage output banner
+     */
+    heading(text: string, level?: 1 | 2 | 3 | 4 | 5 | 6, { pre }?: {
+        pre?: boolean;
+    }): Jack<C>;
+    /**
+     * Add a long-form description to the usage output at this position.
+     */
+    description(text: string, { pre }?: {
+        pre?: boolean;
+    }): Jack<C>;
+    /**
+     * Add one or more number fields.
+     */
+    num<F extends ConfigMetaSet<'number', false>>(fields: F): Jack<C & ConfigSetFromMetaSet<'number', false, F>>;
+    /**
+     * Add one or more multiple number fields.
+     */
+    numList<F extends ConfigMetaSet<'number'>>(fields: F): Jack<C & ConfigSetFromMetaSet<'number', true, F>>;
+    /**
+     * Add one or more string option fields.
+     */
+    opt<F extends ConfigMetaSet<'string', false>>(fields: F): Jack<C & ConfigSetFromMetaSet<'string', false, F>>;
+    /**
+     * Add one or more multiple string option fields.
+     */
+    optList<F extends ConfigMetaSet<'string'>>(fields: F): Jack<C & ConfigSetFromMetaSet<'string', true, F>>;
+    /**
+     * Add one or more flag fields.
+     */
+    flag<F extends ConfigMetaSet<'boolean', false>>(fields: F): Jack<C & ConfigSetFromMetaSet<'boolean', false, F>>;
+    /**
+     * Add one or more multiple flag fields.
+     */
+    flagList<F extends ConfigMetaSet<'boolean'>>(fields: F): Jack<C & ConfigSetFromMetaSet<'boolean', true, F>>;
+    /**
+     * Generic field definition method. Similar to flag/flagList/number/etc,
+     * but you must specify the `type` (and optionally `multiple` and `delim`)
+     * fields on each one, or Jack won't know how to define them.
+     */
+    addFields<F extends ConfigSet>(fields: F): Jack<C & F>;
+    /**
+     * Return the usage banner for the given configuration
+     */
+    usage(): string;
+    /**
+     * Return the usage banner markdown for the given configuration
+     */
+    usageMarkdown(): string;
+    /**
+     * Return the configuration options as a plain object
+     */
+    toJSON(): {
+        [k: string]: {
+            hint?: string | undefined;
+            default?: string | number | boolean | string[] | number[] | boolean[] | undefined;
+            validOptions?: readonly number[] | readonly string[] | undefined;
+            validate?: ((v: unknown) => v is string | number | boolean | string[] | number[] | boolean[]) | undefined;
+            description?: string | undefined;
+            short?: string | undefined;
+            delim?: string | undefined;
+            multiple?: boolean | undefined;
+            type: ConfigType;
+        };
+    };
+    /**
+     * Custom printer for `util.inspect`
+     */
+    [inspect.custom](_: number, options: InspectOptions): string;
+}
+/**
+ * Main entry point. Create and return a {@link Jack} object.
+ */
+export declare const jack: (options?: JackOptions) => Jack<{}>;
+//# sourceMappingURL=index.d.ts.map

unified-ai-platform/node_modules/jackspeak/dist/esm/index.js

@@ -788,4 +788,213 @@ export class Jack {
      * Return the usage banner markdown for the given configuration
      */
     usageMarkdown() {
-        if (this.#usageM
+        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 = 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 (config.type === 'boolean')
+                        shortFlags.push(config.short);
+                    else
+                        shorts.push([config.short, config.hint || field]);
+                }
+                else {
+                    if (config.type === 'boolean')
+                        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);
+        // heading level in markdown is number of # ahead of text
+        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) {
+        // turn each config type into a row, and figure out the width of the
+        // left hand indentation for the option descriptions.
+        let maxMax = Math.max(12, Math.min(26, Math.floor(width / 3)));
+        let maxWidth = 8;
+        let prev = undefined;
+        const rows = [];
+        for (const field of this.#fields.slice(start)) {
+            if (field.type !== 'config') {
+                if (prev?.type === 'config')
+                    prev.skipLine = true;
+                prev = undefined;
+                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 opts = value.validOptions?.length ?
+                `Valid options:${value.validOptions.map(v => ` ${JSON.stringify(v)}`)}`
+                : '';
+            const dmDelim = desc.includes('\n') ? '\n\n' : '\n';
+            const extra = [opts, mult].join(dmDelim).trim();
+            const text = (normalize(desc) + dmDelim + extra).trim();
+            const hint = value.hint ||
+                (value.type === 'number' ? 'n'
+                    : value.type === 'string' ? field.name
+                        : undefined);
+            const short = !value.short ? ''
+                : value.type === 'boolean' ? `-${value.short} `
+                    : `-${value.short}<${hint}> `;
+            const left = value.type === 'boolean' ?
+                `${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 };
+    }
+    /**
+     * Return the configuration options as a plain object
+     */
+    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 } : {}),
+                ...(def.validOptions ? { validOptions: def.validOptions } : {}),
+                ...(def.default !== undefined ? { default: def.default } : {}),
+                ...(def.hint ? { hint: def.hint } : {}),
+            },
+        ]));
+    }
+    /**
+     * Custom printer for `util.inspect`
+     */
+    [inspect.custom](_, options) {
+        return `Jack ${inspect(this.toJSON(), options)}`;
+    }
+}
+// Unwrap and un-indent, so we can wrap description
+// strings however makes them look nice in the code.
+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, '\\\\');
+    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;
+};
+/**
+ * Main entry point. Create and return a {@link Jack} object.
+ */
+export const jack = (options = {}) => new Jack(options);
+//# sourceMappingURL=index.js.map

unified-ai-platform/node_modules/jackspeak/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

unified-ai-platform/node_modules/jackspeak/dist/esm/parse-args.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as util from 'util';
+export declare const parseArgs: typeof util.parseArgs;
+//# sourceMappingURL=parse-args.d.ts.map

unified-ai-platform/node_modules/jackspeak/dist/esm/parse-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-args.d.ts","sourceRoot":"","sources":["../../src/parse-args.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAoC5B,eAAO,MAAM,SAAS,uBAA6C,CAAA"}

unified-ai-platform/node_modules/jackspeak/dist/esm/parse-args.js

@@ -0,0 +1,26 @@
+import * as util from 'util';
+const pv = (typeof process === 'object' &&
+    !!process &&
+    typeof process.version === 'string') ?
+    process.version
+    : 'v0.0.0';
+const pvs = pv
+    .replace(/^v/, '')
+    .split('.')
+    .map(s => parseInt(s, 10));
+/* c8 ignore start */
+const [major = 0, minor = 0] = pvs;
+/* c8 ignore stop */
+let { parseArgs: pa, } = util;
+/* c8 ignore start - version specific */
+if (!pa ||
+    major < 16 ||
+    (major === 18 && minor < 11) ||
+    (major === 16 && minor < 19)) {
+    // Ignore because we will clobber it for commonjs
+    //@ts-ignore
+    pa = (await import('@pkgjs/parseargs')).parseArgs;
+}
+/* c8 ignore stop */
+export const parseArgs = pa;
+//# sourceMappingURL=parse-args.js.map

unified-ai-platform/node_modules/jackspeak/dist/esm/parse-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-args.js","sourceRoot":"","sources":["../../src/parse-args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAE5B,MAAM,EAAE,GACN,CACE,OAAO,OAAO,KAAK,QAAQ;IAC3B,CAAC,CAAC,OAAO;IACT,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,CACpC,CAAC,CAAC;IACD,OAAO,CAAC,OAAO;IACjB,CAAC,CAAC,QAAQ,CAAA;AACZ,MAAM,GAAG,GAAG,EAAE;KACX,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;KACjB,KAAK,CAAC,GAAG,CAAC;KACV,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;AAE5B,qBAAqB;AACrB,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,GAAG,CAAA;AAClC,oBAAoB;AAEpB,IAAI,EACF,SAAS,EAAE,EAAE,GACd,GAA8D,IAAI,CAAA;AAEnE,wCAAwC;AACxC,IACE,CAAC,EAAE;IACH,KAAK,GAAG,EAAE;IACV,CAAC,KAAK,KAAK,EAAE,IAAI,KAAK,GAAG,EAAE,CAAC;IAC5B,CAAC,KAAK,KAAK,EAAE,IAAI,KAAK,GAAG,EAAE,CAAC,EAC5B,CAAC;IACD,iDAAiD;IACjD,YAAY;IACZ,EAAE,GAAG,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAA;AACnD,CAAC;AACD,oBAAoB;AAEpB,MAAM,CAAC,MAAM,SAAS,GAAG,EAA0C,CAAA","sourcesContent":["import * as util from 'util'\n\nconst pv =\n  (\n    typeof process === 'object' &&\n    !!process &&\n    typeof process.version === 'string'\n  ) ?\n    process.version\n  : 'v0.0.0'\nconst pvs = pv\n  .replace(/^v/, '')\n  .split('.')\n  .map(s => parseInt(s, 10))\n\n/* c8 ignore start */\nconst [major = 0, minor = 0] = pvs\n/* c8 ignore stop */\n\nlet {\n  parseArgs: pa,\n}: typeof import('util') | typeof import('@pkgjs/parseargs') = util\n\n/* c8 ignore start - version specific */\nif (\n  !pa ||\n  major < 16 ||\n  (major === 18 && minor < 11) ||\n  (major === 16 && minor < 19)\n) {\n  // Ignore because we will clobber it for commonjs\n  //@ts-ignore\n  pa = (await import('@pkgjs/parseargs')).parseArgs\n}\n/* c8 ignore stop */\n\nexport const parseArgs = pa as (typeof import('util'))['parseArgs']\n"]}