@thi.ng/args 2.2.45 → 2.2.46

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -69,7 +69,7 @@ For Node.js REPL:
 const args = await import("@thi.ng/args");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 2.39 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 2.31 KB
 
 ## Dependencies
 

package/api.js

@@ -1,19 +1,19 @@
-export const DEFAULT_THEME = {
-    default: 95,
-    hint: 90,
-    multi: 90,
-    param: 96,
-    required: 33,
+const DEFAULT_THEME = {
+  default: 95,
+  hint: 90,
+  multi: 90,
+  param: 96,
+  required: 33
 };
-/**
- * Wrapper for fixed size tuple values produced by {@link tuple}.
- */
-export class Tuple {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    deref() {
-        return this.value;
-    }
+class Tuple {
+  constructor(value) {
+    this.value = value;
+  }
+  deref() {
+    return this.value;
+  }
 }
+export {
+  DEFAULT_THEME,
+  Tuple
+};

package/args.js

@@ -1,214 +1,105 @@
 import { identity } from "@thi.ng/api/fn";
 import { repeat } from "@thi.ng/strings/repeat";
-import { coerceFloat, coerceFloats, coerceHexInt, coerceHexInts, coerceInt, coerceInts, coerceJson, coerceKV, coerceOneOf, coerceTuple, } from "./coerce.js";
+import {
+  coerceFloat,
+  coerceFloats,
+  coerceHexInt,
+  coerceHexInts,
+  coerceInt,
+  coerceInts,
+  coerceJson,
+  coerceKV,
+  coerceOneOf,
+  coerceTuple
+} from "./coerce.js";
 const $single = (coerce, hint) => (spec) => ({
-    coerce,
-    hint,
-    group: "main",
-    ...spec,
+  coerce,
+  hint,
+  group: "main",
+  ...spec
 });
 const $multi = (coerce, hint) => (spec) => ({
-    hint: $hint(hint, spec.delim),
-    multi: true,
-    coerce,
-    group: "main",
-    ...spec,
+  hint: $hint(hint, spec.delim),
+  multi: true,
+  coerce,
+  group: "main",
+  ...spec
 });
 const $hint = (hint, delim) => hint + (delim ? `[${delim}..]` : "");
-/**
- * Returns a full {@link ArgSpec} for a boolean flag. The mere presence of this
- * arg will enable the flag.
- *
- * @param spec -
- */
-export const flag = (spec) => ({
-    flag: true,
-    default: false,
-    group: "flags",
-    ...spec,
+const flag = (spec) => ({
+  flag: true,
+  default: false,
+  group: "flags",
+  ...spec
 });
-/**
- * Returns a full {@link ArgSpec} for a string value arg.
- *
- * @param spec -
- */
-export const string = $single(identity, "STR");
-/**
- * Multi-arg version of {@link string}. Returns a full {@link ArgSpec} for a
- * multi string value arg. This argument can be provided mutiple times with
- * values collected into an array.
- *
- * @param spec -
- */
-export const strings = $multi(identity, "STR");
-/**
- * Returns a full {@link ArgSpec} for a floating point value arg. The value
- * will be autoatically coerced into a number using {@link coerceFloat}.
- *
- * @param spec -
- */
-export const float = $single(coerceFloat, "NUM");
-/**
- * Returns a full {@link ArgSpec} for a single hex integer value arg. The value
- * will be autoatically coerced into a number using {@link coerceHexInt}.
- *
- * @param spec -
- */
-export const hex = $single(coerceHexInt, "HEX");
-/**
- * Returns a full {@link ArgSpec} for a single integer value arg. The value
- * will be autoatically coerced into a number using {@link coerceInt}.
- *
- * @param spec -
- */
-export const int = $single(coerceInt, "INT");
-/**
- * Multi-arg version of {@link float}. Returns a full {@link ArgSpec} for a
- * multi floating point value arg. This argument can be provided mutiple times
- * with values being coerced into numbers and collected into an array.
- *
- * @param spec -
- */
-export const floats = $multi(coerceFloats, "NUM");
-/**
- * Multi-arg version of {@link hex}. Returns a full {@link ArgSpec} for a multi
- * hex integer value arg. This argument can be provided mutiple times with
- * values being coerced into numbers and collected into an array.
- *
- * @param spec -
- */
-export const hexes = $multi(coerceHexInts, "HEX");
-/**
- * Multi-arg version of {@link int}. Returns a full {@link ArgSpec} for a multi
- * integer value arg. This argument can be provided mutiple times with values
- * being coerced into numbers and collected into an array.
- *
- * @param spec -
- */
-export const ints = $multi(coerceInts, "INT");
-/**
- * Returns full {@link ArgSpec} for a JSON value arg. The raw CLI value string
- * will be automcatically coerced using {@link coerceJson}.
- *
- * @param spec -
- */
-export const json = (spec) => ({
-    coerce: coerceJson,
-    hint: "JSON",
-    group: "main",
-    ...spec,
+const string = $single(identity, "STR");
+const strings = $multi(identity, "STR");
+const float = $single(coerceFloat, "NUM");
+const hex = $single(coerceHexInt, "HEX");
+const int = $single(coerceInt, "INT");
+const floats = $multi(coerceFloats, "NUM");
+const hexes = $multi(coerceHexInts, "HEX");
+const ints = $multi(coerceInts, "INT");
+const json = (spec) => ({
+  coerce: coerceJson,
+  hint: "JSON",
+  group: "main",
+  ...spec
 });
 const $desc = (opts, prefix) => `${prefix ? prefix + ": " : ""}${opts.map((x) => `"${x}"`).join(", ")}`;
-/**
- * Returns full {@link ArgSpec} for an enum-like string value arg. The raw CLI
- * value string will be automcatically validated using {@link coerceOneOf}.
- *
- * @param opts -
- * @param spec -
- */
-export const oneOf = (opts, spec) => ({
-    coerce: coerceOneOf(opts),
-    hint: "ID",
-    group: "main",
-    ...spec,
-    desc: $desc(opts, spec.desc),
+const oneOf = (opts, spec) => ({
+  coerce: coerceOneOf(opts),
+  hint: "ID",
+  group: "main",
+  ...spec,
+  desc: $desc(opts, spec.desc)
 });
-/**
- * Multi-arg version of {@link oneOf}. Returns full {@link ArgSpec} for multiple
- * enum-like string value args. The raw CLI value strings will be automcatically
- * validated using {@link coerceOneOf} and collected into an array.
- *
- * @param opts -
- * @param spec -
- */
-export const oneOfMulti = (opts, spec) => ({
-    coerce: (xs) => xs.map(coerceOneOf(opts)),
-    hint: $hint("ID", spec.delim),
-    multi: true,
-    group: "main",
-    ...spec,
-    desc: $desc(opts, spec.desc),
+const oneOfMulti = (opts, spec) => ({
+  coerce: (xs) => xs.map(coerceOneOf(opts)),
+  hint: $hint("ID", spec.delim),
+  multi: true,
+  group: "main",
+  ...spec,
+  desc: $desc(opts, spec.desc)
 });
-/**
- * Returns a full {@link ArgSpec} for multiple `key=value` pair args, coerced
- * into a result object.
- *
- * @remarks
- * The default delimiter (`=`) can be overridden. Also by default, key-only args
- * are allowed and will receive a `"true"` as their value. However, if `strict`
- * is true, only full KV pairs are allowed.
- *
- * @param spec -
- * @param delim -
- */
-export const kvPairs = (spec, delim = "=", strict) => ({
-    coerce: coerceKV(delim, strict),
-    hint: `key${delim}val`,
-    multi: true,
-    group: "main",
-    ...spec,
+const kvPairs = (spec, delim = "=", strict) => ({
+  coerce: coerceKV(delim, strict),
+  hint: `key${delim}val`,
+  multi: true,
+  group: "main",
+  ...spec
 });
-/**
- * Like {@link kvPairs}, but coerces KV pairs into a result {@link KVMultiDict}
- * which supports multiple values per given key (each key's values are collected
- * into arrays).
- *
- * @param spec -
- * @param delim -
- * @param strict -
- */
-export const kvPairsMulti = (spec, delim = "=", strict) => ({
-    coerce: coerceKV(delim, strict, true),
-    hint: `key${delim}val(s)`,
-    multi: true,
-    group: "main",
-    ...spec,
+const kvPairsMulti = (spec, delim = "=", strict) => ({
+  coerce: coerceKV(delim, strict, true),
+  hint: `key${delim}val(s)`,
+  multi: true,
+  group: "main",
+  ...spec
 });
-/**
- * Returns a full {@link ArgSpec} for a fixed `size` tuple extracted from a
- * single value string. The individual values are delimited by `delim` and will
- * be coerced into their target type via `coerce`. The result tuple will be
- * wrapped in a {@link Tuple} instance.
- *
- * @remarks
- * An error will be thrown if the number of extracted values differs from the
- * specified tuple size or any value coercion fails.
- *
- * @example
- * ```ts
- * parse({ a: tuple(coerceInt, 2, {})}, ["--a", "1,2"])
- * // {
- * //   result: { a: Tuple { value: [1, 2] } },
- * //   index: 2,
- * //   rest: [],
- * //   done: true
- * // }
- * ```
- *
- * @param coerce -
- * @param size -
- * @param spec -
- * @param delim -
- */
-export const tuple = (coerce, size, spec, delim = ",") => ({
-    coerce: coerceTuple(coerce, size, delim),
-    hint: [...repeat("N", size)].join(delim),
-    group: "main",
-    ...spec,
+const tuple = (coerce, size2, spec, delim = ",") => ({
+  coerce: coerceTuple(coerce, size2, delim),
+  hint: [...repeat("N", size2)].join(delim),
+  group: "main",
+  ...spec
 });
-/**
- * Syntax sugar for `tuple(coerceInt, size, {...}, delim)`.
- *
- * @param size -
- * @param spec -
- * @param delim -
- */
-export const size = (size, spec, delim = "x") => tuple(coerceInt, size, spec, delim);
-/**
- * Syntax sugar for `tuple(coerceFloat, size, {...}, delim)`.
- *
- * @param size -
- * @param spec -
- * @param delim -
- */
-export const vec = (size, spec, delim = ",") => tuple(coerceFloat, size, spec, delim);
+const size = (size2, spec, delim = "x") => tuple(coerceInt, size2, spec, delim);
+const vec = (size2, spec, delim = ",") => tuple(coerceFloat, size2, spec, delim);
+export {
+  flag,
+  float,
+  floats,
+  hex,
+  hexes,
+  int,
+  ints,
+  json,
+  kvPairs,
+  kvPairsMulti,
+  oneOf,
+  oneOfMulti,
+  size,
+  string,
+  strings,
+  tuple,
+  vec
+};

package/coerce.js

@@ -2,42 +2,50 @@ import { isHex } from "@thi.ng/checks/is-hex";
 import { isNumericFloat, isNumericInt } from "@thi.ng/checks/is-numeric";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { Tuple } from "./api.js";
-export const coerceString = (x) => x;
-export const coerceFloat = (x) => isNumericFloat(x)
-    ? parseFloat(x)
-    : illegalArgs(`not a numeric value: ${x}`);
-export const coerceFloats = (xs) => xs.map(coerceFloat);
-export const coerceHexInt = (x) => isHex(x) ? parseInt(x, 16) : illegalArgs(`not a hex value: ${x}`);
-export const coerceHexInts = (xs) => xs.map(coerceHexInt);
-export const coerceInt = (x) => isNumericInt(x) ? parseInt(x) : illegalArgs(`not an integer: ${x}`);
-export const coerceInts = (xs) => xs.map(coerceInt);
-export const coerceJson = (x) => JSON.parse(x);
-export const coerceOneOf = (xs) => (x) => xs.includes(x) ? x : illegalArgs(`invalid option: ${x}`);
-export function coerceKV(delim = "=", strict = false, multi = false) {
-    return (pairs) => pairs.reduce((acc, x) => {
-        const idx = x.indexOf(delim);
-        strict &&
-            idx < 1 &&
-            illegalArgs(`got '${x}', but expected a 'key${delim}value' pair`);
-        if (idx > 0) {
-            const id = x.substring(0, idx);
-            const val = x.substring(idx + 1);
-            if (multi) {
-                acc[id] ? acc[id].push(val) : (acc[id] = [val]);
-            }
-            else {
-                acc[id] = val;
-            }
-        }
-        else {
-            acc[x] = multi ? ["true"] : "true";
-        }
-        return acc;
-    }, {});
+const coerceString = (x) => x;
+const coerceFloat = (x) => isNumericFloat(x) ? parseFloat(x) : illegalArgs(`not a numeric value: ${x}`);
+const coerceFloats = (xs) => xs.map(coerceFloat);
+const coerceHexInt = (x) => isHex(x) ? parseInt(x, 16) : illegalArgs(`not a hex value: ${x}`);
+const coerceHexInts = (xs) => xs.map(coerceHexInt);
+const coerceInt = (x) => isNumericInt(x) ? parseInt(x) : illegalArgs(`not an integer: ${x}`);
+const coerceInts = (xs) => xs.map(coerceInt);
+const coerceJson = (x) => JSON.parse(x);
+const coerceOneOf = (xs) => (x) => xs.includes(x) ? x : illegalArgs(`invalid option: ${x}`);
+function coerceKV(delim = "=", strict = false, multi = false) {
+  return (pairs) => pairs.reduce((acc, x) => {
+    const idx = x.indexOf(delim);
+    strict && idx < 1 && illegalArgs(
+      `got '${x}', but expected a 'key${delim}value' pair`
+    );
+    if (idx > 0) {
+      const id = x.substring(0, idx);
+      const val = x.substring(idx + 1);
+      if (multi) {
+        acc[id] ? acc[id].push(val) : acc[id] = [val];
+      } else {
+        acc[id] = val;
+      }
+    } else {
+      acc[x] = multi ? ["true"] : "true";
+    }
+    return acc;
+  }, {});
 }
-export const coerceTuple = (coerce, size, delim = ",") => (src) => {
-    const parts = src.split(delim);
-    parts.length !== size &&
-        illegalArgs(`got '${src}', but expected a tuple of ${size} values`);
-    return new Tuple(parts.map(coerce));
+const coerceTuple = (coerce, size, delim = ",") => (src) => {
+  const parts = src.split(delim);
+  parts.length !== size && illegalArgs(`got '${src}', but expected a tuple of ${size} values`);
+  return new Tuple(parts.map(coerce));
+};
+export {
+  coerceFloat,
+  coerceFloats,
+  coerceHexInt,
+  coerceHexInts,
+  coerceInt,
+  coerceInts,
+  coerceJson,
+  coerceKV,
+  coerceOneOf,
+  coerceString,
+  coerceTuple
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/args",
-  "version": "2.2.45",
+  "version": "2.2.46",
   "description": "Declarative, functional & typechecked CLI argument/options parser, value coercions etc.",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,13 +35,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/strings": "^3.7.2"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/strings": "^3.7.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -94,5 +97,5 @@
   "thi.ng": {
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/parse.js

@@ -3,118 +3,120 @@ import { defError } from "@thi.ng/errors/deferror";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { camel } from "@thi.ng/strings/case";
 import { usage } from "./usage.js";
-export const ParseError = defError(() => "parse error");
-export const parse = (specs, argv, opts) => {
-    opts = { start: 2, showUsage: true, help: ["--help", "-h"], ...opts };
-    try {
-        return parseOpts(specs, argv, opts);
-    }
-    catch (e) {
-        if (opts.showUsage) {
-            console.log(e.message + "\n\n" + usage(specs, opts.usageOpts));
-        }
-        throw new ParseError(e.message);
+const ParseError = defError(() => "parse error");
+const parse = (specs, argv, opts) => {
+  opts = { start: 2, showUsage: true, help: ["--help", "-h"], ...opts };
+  try {
+    return parseOpts(specs, argv, opts);
+  } catch (e) {
+    if (opts.showUsage) {
+      console.log(
+        e.message + "\n\n" + usage(specs, opts.usageOpts)
+      );
     }
+    throw new ParseError(e.message);
+  }
 };
 const parseOpts = (specs, argv, opts) => {
-    const aliases = aliasIndex(specs);
-    const acc = {};
-    let id;
-    let spec;
-    let i = opts.start;
-    for (; i < argv.length;) {
-        const a = argv[i];
-        if (!id) {
-            if (opts.help.includes(a)) {
-                console.log(usage(specs, opts.usageOpts));
-                return;
-            }
-            const state = parseKey(specs, aliases, acc, a);
-            id = state.id;
-            spec = state.spec;
-            i = i + ~~(state.state < 2);
-            if (state.state)
-                break;
-        }
-        else {
-            if (parseValue(spec, acc, id, a))
-                break;
-            id = null;
-            i++;
-        }
+  const aliases = aliasIndex(specs);
+  const acc = {};
+  let id;
+  let spec;
+  let i = opts.start;
+  for (; i < argv.length; ) {
+    const a = argv[i];
+    if (!id) {
+      if (opts.help.includes(a)) {
+        console.log(usage(specs, opts.usageOpts));
+        return;
+      }
+      const state = parseKey(specs, aliases, acc, a);
+      id = state.id;
+      spec = state.spec;
+      i = i + ~~(state.state < 2);
+      if (state.state)
+        break;
+    } else {
+      if (parseValue(spec, acc, id, a))
+        break;
+      id = null;
+      i++;
     }
-    id && illegalArgs(`missing value for: --${id}`);
-    return {
-        result: processResults(specs, acc),
-        index: i,
-        rest: argv.slice(i),
-        done: i >= argv.length,
-    };
+  }
+  id && illegalArgs(`missing value for: --${id}`);
+  return {
+    result: processResults(specs, acc),
+    index: i,
+    rest: argv.slice(i),
+    done: i >= argv.length
+  };
 };
-const aliasIndex = (specs) => Object.entries(specs).reduce((acc, [k, v]) => (v.alias ? ((acc[v.alias] = k), acc) : acc), {});
+const aliasIndex = (specs) => Object.entries(specs).reduce(
+  (acc, [k, v]) => v.alias ? (acc[v.alias] = k, acc) : acc,
+  {}
+);
 const parseKey = (specs, aliases, acc, a) => {
-    if (a[0] === "-") {
-        let id;
-        if (a[1] === "-") {
-            // terminator arg, stop parsing
-            if (a === "--")
-                return { state: 1 };
-            id = camel(a.substring(2));
-        }
-        else {
-            id = aliases[a.substring(1)];
-            !id && illegalArgs(`unknown option: ${a}`);
-        }
-        const spec = specs[id];
-        !spec && illegalArgs(id);
-        if (spec.flag) {
-            acc[id] = true;
-            id = undefined;
-            // stop parsing if fn returns false
-            if (spec.fn && !spec.fn("true"))
-                return { state: 1, spec };
-        }
-        return { state: 0, id, spec };
+  if (a[0] === "-") {
+    let id;
+    if (a[1] === "-") {
+      if (a === "--")
+        return { state: 1 };
+      id = camel(a.substring(2));
+    } else {
+      id = aliases[a.substring(1)];
+      !id && illegalArgs(`unknown option: ${a}`);
+    }
+    const spec = specs[id];
+    !spec && illegalArgs(id);
+    if (spec.flag) {
+      acc[id] = true;
+      id = void 0;
+      if (spec.fn && !spec.fn("true"))
+        return { state: 1, spec };
     }
-    // no option arg, stop parsing
-    return { state: 2 };
+    return { state: 0, id, spec };
+  }
+  return { state: 2 };
 };
 const parseValue = (spec, acc, id, a) => {
-    /^-[a-z]/i.test(a) && illegalArgs(`missing value for: --${id}`);
-    if (spec.multi) {
-        isArray(acc[id]) ? acc[id].push(a) : (acc[id] = [a]);
-    }
-    else {
-        acc[id] = a;
-    }
-    return spec.fn && !spec.fn(a);
+  /^-[a-z]/i.test(a) && illegalArgs(`missing value for: --${id}`);
+  if (spec.multi) {
+    isArray(acc[id]) ? acc[id].push(a) : acc[id] = [a];
+  } else {
+    acc[id] = a;
+  }
+  return spec.fn && !spec.fn(a);
 };
 const processResults = (specs, acc) => {
-    let spec;
-    for (let id in specs) {
-        spec = specs[id];
-        if (acc[id] === undefined) {
-            if (spec.default !== undefined) {
-                acc[id] = spec.default;
-            }
-            else if (spec.optional === false) {
-                illegalArgs(`missing arg: --${id}`);
-            }
-        }
-        else if (spec.coerce) {
-            coerceValue(spec, acc, id);
-        }
+  let spec;
+  for (let id in specs) {
+    spec = specs[id];
+    if (acc[id] === void 0) {
+      if (spec.default !== void 0) {
+        acc[id] = spec.default;
+      } else if (spec.optional === false) {
+        illegalArgs(`missing arg: --${id}`);
+      }
+    } else if (spec.coerce) {
+      coerceValue(spec, acc, id);
     }
-    return acc;
+  }
+  return acc;
 };
 const coerceValue = (spec, acc, id) => {
-    try {
-        if (spec.multi && spec.delim) {
-            acc[id] = acc[id].reduce((acc, x) => (acc.push(...x.split(spec.delim)), acc), []);
-        }
-        acc[id] = spec.coerce(acc[id]);
-    }
-    catch (e) {
-        throw new Error(`arg --${id}: ${e.message}`);
+  try {
+    if (spec.multi && spec.delim) {
+      acc[id] = acc[id].reduce(
+        (acc2, x) => (acc2.push(...x.split(spec.delim)), acc2),
+        []
+      );
     }
+    acc[id] = spec.coerce(acc[id]);
+  } catch (e) {
+    throw new Error(`arg --${id}: ${e.message}`);
+  }
+};
+export {
+  ParseError,
+  parse
 };

package/usage.js

@@ -4,73 +4,72 @@ import { padRight } from "@thi.ng/strings/pad-right";
 import { repeat } from "@thi.ng/strings/repeat";
 import { stringify } from "@thi.ng/strings/stringify";
 import { SPLIT_ANSI, wordWrapLines } from "@thi.ng/strings/word-wrap";
-import { DEFAULT_THEME, } from "./api.js";
-export const usage = (specs, opts = {}) => {
-    opts = {
-        lineWidth: 80,
-        paramWidth: 32,
-        showDefaults: true,
-        prefix: "",
-        suffix: "",
-        groups: ["flags", "main"],
-        ...opts,
-    };
-    const theme = opts.color !== false
-        ? { ...DEFAULT_THEME, ...opts.color }
-        : {};
-    const indent = repeat(" ", opts.paramWidth);
-    const format = (ids) => ids.map((id) => argUsage(id, specs[id], opts, theme, indent));
-    const sortedIDs = Object.keys(specs).sort();
-    const groups = opts.groups
-        ? opts.groups
-            .map((gid) => [
-            gid,
-            sortedIDs.filter((id) => specs[id].group === gid),
-        ])
-            .filter((g) => !!g[1].length)
-        : [["options", sortedIDs]];
-    return [
-        ...wrap(opts.prefix, opts.lineWidth),
-        ...groups.map(([gid, ids]) => [
-            ...(opts.showGroupNames ? [`${capitalize(gid)}:\n`] : []),
-            ...format(ids),
-            "",
-        ].join("\n")),
-        ...wrap(opts.suffix, opts.lineWidth),
-    ].join("\n");
+import {
+  DEFAULT_THEME
+} from "./api.js";
+const usage = (specs, opts = {}) => {
+  opts = {
+    lineWidth: 80,
+    paramWidth: 32,
+    showDefaults: true,
+    prefix: "",
+    suffix: "",
+    groups: ["flags", "main"],
+    ...opts
+  };
+  const theme = opts.color !== false ? { ...DEFAULT_THEME, ...opts.color } : {};
+  const indent = repeat(" ", opts.paramWidth);
+  const format = (ids) => ids.map((id) => argUsage(id, specs[id], opts, theme, indent));
+  const sortedIDs = Object.keys(specs).sort();
+  const groups = opts.groups ? opts.groups.map(
+    (gid) => [
+      gid,
+      sortedIDs.filter((id) => specs[id].group === gid)
+    ]
+  ).filter((g) => !!g[1].length) : [["options", sortedIDs]];
+  return [
+    ...wrap(opts.prefix, opts.lineWidth),
+    ...groups.map(
+      ([gid, ids]) => [
+        ...opts.showGroupNames ? [`${capitalize(gid)}:
+`] : [],
+        ...format(ids),
+        ""
+      ].join("\n")
+    ),
+    ...wrap(opts.suffix, opts.lineWidth)
+  ].join("\n");
 };
 const argUsage = (id, spec, opts, theme, indent) => {
-    const hint = argHint(spec, theme);
-    const alias = argAlias(spec, theme, hint);
-    const name = ansi(`--${kebab(id)}`, theme.param);
-    const params = `${alias}${name}${hint}`;
-    const isRequired = spec.optional === false && spec.default === undefined;
-    const prefixes = [];
-    isRequired && prefixes.push("required");
-    spec.multi && prefixes.push("multiple");
-    const body = argPrefix(prefixes, theme, isRequired) +
-        (spec.desc || "") +
-        argDefault(spec, opts, theme);
-    return (padRight(opts.paramWidth)(params, lengthAnsi(params)) +
-        wrap(body, opts.lineWidth - opts.paramWidth)
-            .map((l, i) => (i > 0 ? indent + l : l))
-            .join("\n"));
+  const hint = argHint(spec, theme);
+  const alias = argAlias(spec, theme, hint);
+  const name = ansi(`--${kebab(id)}`, theme.param);
+  const params = `${alias}${name}${hint}`;
+  const isRequired = spec.optional === false && spec.default === void 0;
+  const prefixes = [];
+  isRequired && prefixes.push("required");
+  spec.multi && prefixes.push("multiple");
+  const body = argPrefix(prefixes, theme, isRequired) + (spec.desc || "") + argDefault(spec, opts, theme);
+  return padRight(opts.paramWidth)(params, lengthAnsi(params)) + wrap(body, opts.lineWidth - opts.paramWidth).map((l, i) => i > 0 ? indent + l : l).join("\n");
 };
 const argHint = (spec, theme) => spec.hint ? ansi(" " + spec.hint, theme.hint) : "";
 const argAlias = (spec, theme, hint) => spec.alias ? `${ansi("-" + spec.alias, theme.param)}${hint}, ` : "";
-const argPrefix = (prefixes, theme, isRequired) => prefixes.length
-    ? ansi(`[${prefixes.join(", ")}] `, isRequired ? theme.required : theme.multi)
-    : "";
-const argDefault = (spec, opts, theme) => opts.showDefaults && spec.default != null && spec.default !== false
-    ? ansi(` (default: ${stringify(true)(spec.defaultHint != undefined
-        ? spec.defaultHint
-        : spec.default)})`, theme.default)
-    : "";
-const ansi = (x, col) => col != null ? `\x1b[${col}m${x}\x1b[0m` : x;
-const wrap = (str, width) => str
-    ? wordWrapLines(str, {
-        width,
-        splitter: SPLIT_ANSI,
-        hard: true,
-    })
-    : [];
+const argPrefix = (prefixes, theme, isRequired) => prefixes.length ? ansi(
+  `[${prefixes.join(", ")}] `,
+  isRequired ? theme.required : theme.multi
+) : "";
+const argDefault = (spec, opts, theme) => opts.showDefaults && spec.default != null && spec.default !== false ? ansi(
+  ` (default: ${stringify(true)(
+    spec.defaultHint != void 0 ? spec.defaultHint : spec.default
+  )})`,
+  theme.default
+) : "";
+const ansi = (x, col) => col != null ? `\x1B[${col}m${x}\x1B[0m` : x;
+const wrap = (str, width) => str ? wordWrapLines(str, {
+  width,
+  splitter: SPLIT_ANSI,
+  hard: true
+}) : [];
+export {
+  usage
+};