@loomcli/core 0.7.0 → 0.8.0

package/dist/options.js

@@ -1,22 +1,76 @@
-import { declaredName } from './command-rules.js';
+import { declaredName, repeatedAlias } from './command-rules.js';
 import { valueCode } from './diagnostic-text.js';
-import { DeclarationError, MissingValueError, quoted, RepeatedOptionError, ShortGroupError, UnexpectedValueError, UnknownOptionError, } from './errors.js';
+import { DeclarationError, quoted } from './errors.js';
 import { factFault, flagFault, siteFinding } from './facts.js';
-import { booleanOptionMultiple, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, } from './input-rules.js';
-/** Every parsed value lands in one of these maps; `lists` holds the repeated string options. */
+import { booleanOptionMultiple, countOptionMultiple, impliedNotAString, impliedOnBooleanOrCount, optionDeclaredTwice, optionPolarity, optionType, polarityOnCount, polarityOnString, shortAlias, shortOnlyBothPolarities, shortOnlyWithAliases, shortOnlyWithoutShort, spellingTaken, } from './input-rules.js';
+import { notAList } from './plugin-rules.js';
+/**
+ * Every parsed value lands in one of these maps; `lists` holds the repeated string options and
+ * `counts` the counted ones.
+ */
 export function emptyValues() {
-    return { booleans: new Map(), lists: new Map(), spellings: new Map(), strings: new Map() };
+    return {
+        booleans: new Map(),
+        counts: new Map(),
+        implied: new Map(),
+        lists: new Map(),
+        spellings: new Map(),
+        strings: new Map(),
+    };
+}
+/** One scope's compiled spellings as table entries, each marked with whether the scope is global. */
+export function tableEntries(spellings, global) {
+    return [...spellings].map(([spelling, option]) => [spelling, { ...option, global }]);
 }
 /**
- * The part of one declaration that yields a spelling of the given role, which a spelling fault
- * marks: the declared name for the long form, `short` for the short alias, and the `polarity` that
- * generates a negative form.
+ * Reads one option's spellings out of a compiled table, so a reader cannot report a form the parser
+ * does not accept. Each entry carries its own role, so the naming convention has one owner: the
+ * table that writes it.
  */
-export function spellingMark(site, role) {
-    if (role === 'long') {
-        return site.named;
+export function spellingsOf(table, name) {
+    const spellings = { long: null, negative: null, short: null };
+    for (const [spelling, option] of table) {
+        // An alias is unadvertised, so the spellings are the ones the declared name derives.
+        if (option.name === name && option.role !== 'alias') {
+            spellings[option.role] = spelling;
+        }
+    }
+    return spellings;
+}
+/**
+ * The spelling every reported problem names an option by: its long form, a negative-only Boolean
+ * option's negative form, and otherwise its short form, which a short-only option alone publishes.
+ * The problem belongs to the option, so an alias or the spelling the operator typed is never it.
+ */
+export function reportedOf({ long, negative, short }, name) {
+    // Every compiled option publishes one of the three, because shortOnly requires a short.
+    // A node no table wrote falls back to the declared name's long form.
+    return long ?? negative ?? short ?? `--${name}`;
+}
+/**
+ * The part of one declaration that yields a spelling of the given origin, which a spelling fault
+ * marks: the declared name for the long form, `short` for the short alias, the `polarity` that
+ * generates a negative form, and the alias in `aliases` for either form of an alias.
+ */
+export function spellingMark(site, origin) {
+    switch (origin.role) {
+        case 'long': {
+            return site.named;
+        }
+        case 'short': {
+            return `${site.at}.short`;
+        }
+        case 'negative': {
+            return `${site.at}.polarity`;
+        }
+        case 'alias': {
+            return `${site.at}.aliases.${String(origin.index)}`;
+        }
+        default: {
+            const exhaustive = origin;
+            return exhaustive;
+        }
     }
-    return `${site.at}.${role === 'short' ? 'short' : 'polarity'}`;
 }
 /** The declared name answers the declared-name rule an argument's name answers. */
 export function checkOptionName(name, site) {
@@ -28,14 +82,36 @@ export function checkOptionName(name, site) {
             sentence: `Option name ${valueCode(name)} is not a string.`,
         });
     }
-    if (!name || name.startsWith('-') || /[\s=]/u.test(name)) {
+    if (!isDeclaredName(name)) {
         throw new DeclarationError(declaredName, {
-            correction: 'Use a nonempty name without a leading hyphen, whitespace, or "=".',
+            correction: declaredNameCorrection,
             findings,
             sentence: `Option name ${quoted(name)} is invalid.`,
         });
     }
 }
+/**
+ * The one name rule for an argument, option, alias of an option, or view name: a bare token the
+ * parser can read, nonempty, with no leading hyphen, whitespace, or `=`, which it reads apart.
+ */
+export function isDeclaredName(name) {
+    return typeof name === 'string' && name !== '' && !name.startsWith('-') && !/[\s=]/u.test(name);
+}
+/** The one correction every declared-name diagnostic for a string ends with. */
+export const declaredNameCorrection = 'Use a nonempty name without a leading hyphen, whitespace, or "=".';
+/** The sentence and correction of each repeated-alias fault, for the Command or option `subject` names. */
+export function repeatedAliasText(subject, alias) {
+    return {
+        own: {
+            correction: 'Remove the alias.',
+            sentence: `${subject} declares alias ${quoted(alias)}, which is its own name.`,
+        },
+        twice: {
+            correction: 'Remove the repeated alias.',
+            sentence: `${subject} declares alias ${quoted(alias)} twice.`,
+        },
+    };
+}
 /** Whether a declared short alias is one ASCII letter, the rule every short spelling answers. */
 export function isShortAlias(short) {
     return typeof short === 'string' && /^[A-Za-z]$/u.test(short);
@@ -63,12 +139,79 @@ function checkShortForms(config, site, subject) {
         });
     }
 }
-/** A Boolean option's polarity, which a string option does not declare. */
+/**
+ * The aliases, each a name the declared-name rule accepts, none repeating the option's name or
+ * another alias. `shortOnly` removes every long spelling, so it declares none.
+ */
+function checkAliases(config, site, name) {
+    const subject = `Option ${quoted(name)}`;
+    // The types reject the pair, so this reads `shortOnly` before `aliases` narrows it away.
+    if (config.shortOnly === true && config.aliases !== undefined) {
+        throw factFault(shortOnlyWithAliases, site, {
+            correction: 'Remove aliases or shortOnly.',
+            fact: 'aliases',
+            sentence: `${subject} declares aliases and shortOnly, which removes every long spelling.`,
+        });
+    }
+    const { aliases } = config;
+    if (aliases === undefined) {
+        return;
+    }
+    if (!Array.isArray(aliases)) {
+        throw factFault(notAList, site, {
+            correction: 'Supply a list of alias names.',
+            fact: 'aliases',
+            sentence: `${subject} declares aliases that are not an array.`,
+        });
+    }
+    const seen = new Set();
+    for (const [index, alias] of aliases.entries()) {
+        const at = `${site.at}.aliases.${String(index)}`;
+        if (typeof alias !== 'string') {
+            throw new DeclarationError(declaredName, {
+                correction: 'Supply a string name.',
+                findings: [siteFinding(site, at)],
+                sentence: `${subject} declares an alias named ${valueCode(alias)}.`,
+            });
+        }
+        if (!isDeclaredName(alias)) {
+            throw new DeclarationError(declaredName, {
+                correction: declaredNameCorrection,
+                findings: [siteFinding(site, at)],
+                sentence: `${subject} declares an alias named ${quoted(alias)}.`,
+            });
+        }
+        const repeated = repeatedAliasText(subject, alias);
+        if (alias === name) {
+            throw new DeclarationError(repeatedAlias, {
+                ...repeated.own,
+                findings: [siteFinding(site, at, 'its own name')],
+            });
+        }
+        if (seen.has(alias)) {
+            throw new DeclarationError(repeatedAlias, {
+                ...repeated.twice,
+                findings: [siteFinding(site, at, 'already an alias')],
+            });
+        }
+        seen.add(alias);
+    }
+}
+/** A Boolean option's polarity, which a string option and a counted option do not declare. */
 function checkPolarity(config, site, subject) {
+    // The type is read before the check below narrows the config to the kind the types allow.
+    const { type } = config;
     if (config.polarity === undefined) {
         return;
     }
-    if (config.type !== 'boolean') {
+    if (type === 'count') {
+        throw factFault(polarityOnCount, site, {
+            correction: 'Remove polarity or use type "boolean".',
+            fact: 'polarity',
+            sentence: `${subject} declares polarity but is a counted option.`,
+        });
+    }
+    if (type !== 'boolean') {
         throw factFault(polarityOnString, site, {
             correction: 'Remove polarity or use type "boolean".',
             fact: 'polarity',
@@ -90,50 +233,156 @@ function checkPolarity(config, site, subject) {
         });
     }
 }
+/** `multiple` belongs to a string option: a Boolean option has one value and a count counts. */
+function checkMultiple(config, site, subject) {
+    // The type is read before the check below narrows the config to the kind the types allow.
+    const { type } = config;
+    if (config.multiple === undefined) {
+        return;
+    }
+    if (type === 'boolean') {
+        throw factFault(booleanOptionMultiple, site, {
+            correction: 'Remove multiple or declare a string option.',
+            fact: 'multiple',
+            sentence: `${subject} is a boolean option and declares multiple.`,
+        });
+    }
+    if (type === 'count') {
+        throw factFault(countOptionMultiple, site, {
+            correction: 'Remove multiple; a counted option already counts every occurrence.',
+            fact: 'multiple',
+            sentence: `${subject} is a counted option and declares multiple.`,
+        });
+    }
+    if (typeof config.multiple !== 'boolean') {
+        throw flagFault(site, 'multiple');
+    }
+}
+/** The kind each option type reads as in a sentence about a value it cannot take. */
+const valuelessKinds = { boolean: 'a Boolean option', count: 'a counted option' };
+/**
+ * A string option's implied value, the string a bare spelling supplies. A Boolean option and a
+ * counted option take no value, so neither declares one. Presence is the key, so a declared
+ * `undefined` is a declaration the rule reads.
+ */
+function checkImplied(config, site, subject) {
+    if (!('implied' in config)) {
+        return;
+    }
+    if (config.type !== 'string') {
+        throw factFault(impliedOnBooleanOrCount, site, {
+            correction: 'Remove implied or declare a string option.',
+            fact: 'implied',
+            sentence: `${subject} is ${valuelessKinds[config.type]} and declares implied.`,
+        });
+    }
+    if (typeof config.implied !== 'string') {
+        throw factFault(impliedNotAString, site, {
+            correction: 'Supply a string, the value a bare spelling supplies.',
+            fact: 'implied',
+            sentence: `${subject} declares implied that is not a string.`,
+        });
+    }
+}
 /** Every rule one option declaration answers alone, before the table meets it. */
 function validateDeclaration({ name, config }, site) {
     checkOptionName(name, site);
     const subject = `Option ${quoted(name)}`;
-    if (!['string', 'boolean'].includes(config.type)) {
+    if (!['string', 'boolean', 'count'].includes(config.type)) {
         throw factFault(optionType, site, {
-            correction: 'Use "string" or "boolean".',
+            correction: 'Use "string", "boolean", or "count".',
             fact: 'type',
             sentence: `${subject} has an invalid type.`,
         });
     }
     checkShortForms(config, site, subject);
-    if (config.type === 'boolean' && config.multiple !== undefined) {
-        throw factFault(booleanOptionMultiple, site, {
-            correction: 'Remove multiple or declare a string option.',
-            fact: 'multiple',
-            sentence: `${subject} is a boolean option and declares multiple.`,
-        });
-    }
-    if (config.multiple !== undefined && typeof config.multiple !== 'boolean') {
-        throw flagFault(site, 'multiple');
-    }
+    checkAliases(config, site, name);
+    checkMultiple(config, site, subject);
     checkPolarity(config, site, subject);
+    checkImplied(config, site, subject);
 }
 function addSpelling(claims, spelling, claim) {
     const existing = claims.get(spelling);
     if (existing) {
         throw new DeclarationError(spellingTaken, {
             correction: 'Change one declaration.',
-            findings: [existing, claim].map(({ option, site }) => siteFinding(site, spellingMark(site, option.role))),
+            findings: [existing, claim].map(({ option, site }) => siteFinding(site, spellingMark(site, option))),
             sentence: `Option spelling ${quoted(spelling)} is used by both ${quoted(existing.option.name)} and ${quoted(claim.option.name)}.`,
         });
     }
     claims.set(spelling, claim);
 }
+/**
+ * The long forms one name yields for an option, the declared name or an alias: the positive form,
+ * unless the polarity is negative, and the negative form for `both` and `negative` polarity.
+ */
+function addLongForms(claims, option, long) {
+    const { config, positive, site } = option;
+    const forms = [];
+    if (config.type !== 'boolean' || config.polarity !== 'negative') {
+        forms.push([`--${long.name}`, { ...positive, ...long.positive }]);
+    }
+    if (config.type === 'boolean' && (config.polarity === 'both' || config.polarity === 'negative')) {
+        forms.push([
+            `--no-${long.name}`,
+            {
+                name: positive.name,
+                type: 'boolean',
+                value: false,
+                valueClass: 'boolean',
+                ...long.negative,
+            },
+        ]);
+    }
+    for (const [spelling, form] of forms) {
+        // The name's forms claim first, so a spelling the option already holds repeats it by an alias.
+        if (form.role === 'alias' && claims.get(spelling)?.option.name === positive.name) {
+            throw new DeclarationError(repeatedAlias, {
+                correction: 'Remove the alias.',
+                findings: [
+                    siteFinding(site, spellingMark(site, form), 'a spelling the option already accepts'),
+                ],
+                sentence: `Option ${quoted(positive.name)} declares alias ${quoted(long.name)}, whose spelling ${quoted(spelling)} the option already accepts.`,
+            });
+        }
+        addSpelling(claims, spelling, { option: form, site });
+    }
+}
 /**
  * One Boolean option's value for one invocation: the value the parser consumed, or the value its
  * declared polarity gives an absent option. A negative-only option is absent as `true`, because its
- * one spelling turns the value off. Every scope reads it here, so a plugin option and a validated
- * declaration answer the same rule.
+ * one spelling turns the value off. Validation reads every Boolean option's value here, whichever
+ * scope declared it.
  */
 export function booleanValue(values, name, config) {
     return values.booleans.get(name) ?? config.polarity === 'negative';
 }
+/** The form an option's positive spellings read words by, its long form and short alias alike. */
+function positiveForm(name, config) {
+    switch (config.type) {
+        case 'string': {
+            const multiple = config.multiple === true;
+            return config.implied === undefined
+                ? { multiple, name, type: 'string', valueClass: 'separate' }
+                : { implied: config.implied, multiple, name, type: 'string', valueClass: 'implied' };
+        }
+        case 'boolean': {
+            return {
+                name,
+                type: 'boolean',
+                value: config.polarity !== 'negative',
+                valueClass: 'boolean',
+            };
+        }
+        case 'count': {
+            return { name, type: 'count', valueClass: 'count' };
+        }
+        default: {
+            const exhaustive = config;
+            return exhaustive;
+        }
+    }
+}
 /**
  * One scope's options compiled into the spelling table the parser reads, with every rule one
  * declaration answers alone and every rule two of them answer together.
@@ -158,19 +407,17 @@ export function compileOptions(declarations, scope) {
             });
         }
         names.set(name, declaration);
-        const positive = config.type === 'string'
-            ? { multiple: config.multiple === true, name, type: 'string' }
-            : { name, type: 'boolean', value: config.polarity !== 'negative' };
+        const positive = positiveForm(name, config);
         if (!config.shortOnly) {
-            if (config.type === 'string' || config.polarity !== 'negative') {
-                addSpelling(claims, `--${name}`, { option: { ...positive, role: 'long' }, site });
-            }
-            if (config.type === 'boolean' &&
-                (config.polarity === 'both' || config.polarity === 'negative')) {
-                addSpelling(claims, `--no-${name}`, {
-                    option: { name, role: 'negative', type: 'boolean', value: false },
-                    site,
-                });
+            const option = { config, positive, site };
+            addLongForms(claims, option, {
+                name,
+                negative: { role: 'negative' },
+                positive: { role: 'long' },
+            });
+            for (const [index, alias] of (config.aliases ?? []).entries()) {
+                const origin = { index, role: 'alias' };
+                addLongForms(claims, option, { name: alias, negative: origin, positive: origin });
             }
         }
         if (config.short !== undefined) {
@@ -179,196 +426,22 @@ export function compileOptions(declarations, scope) {
     }
     return new Map([...claims].map(([spelling, { option }]) => [spelling, option]));
 }
-/**
- * Whether a token reads as an option: it starts with a hyphen. Routing stops at one, and a
- * separate value is never one. The parser and `locate` read each token through this rule.
- */
-export function isOptionToken(token) {
-    return token.startsWith('-');
-}
-/**
- * A token that starts with `--` split at its first `=` into the spelling and the inline value, or
- * `undefined` for any other token. The parser and `locate` split long tokens through this rule.
- */
-export function longToken(token) {
-    if (!token.startsWith('--')) {
-        return undefined;
-    }
-    const equals = token.indexOf('=');
-    return equals === -1
-        ? { inline: undefined, spelling: token }
-        : { inline: token.slice(equals + 1), spelling: token.slice(0, equals) };
-}
-function lookup(spellings, spelling) {
-    const option = spellings.get(spelling);
-    if (!option) {
-        throw new UnknownOptionError(spelling);
-    }
-    return option;
-}
-/**
- * The name of the string option one long spelling names in a table, which takes its value after
- * `=`, or `undefined` for a Boolean, negative, short, or unknown spelling.
- */
-export function longStringOption(spellings, spelling) {
-    const option = spellings.get(spelling);
-    return option?.type === 'string' && option.role === 'long' ? option.name : undefined;
-}
-function acceptValue({ option, spelling, values, next, inline, }) {
-    const repeatable = option.type === 'string' && option.multiple;
-    if (!repeatable && (values.strings.has(option.name) || values.booleans.has(option.name))) {
-        throw new RepeatedOptionError(spelling);
-    }
-    // A repeatable option records its last occurrence, because each one overwrites the entry.
-    values.spellings.set(option.name, spelling);
-    if (option.type === 'boolean') {
-        if (inline !== undefined) {
-            throw new UnexpectedValueError(spelling, inline);
-        }
-        values.booleans.set(option.name, option.value);
-        return 'alone';
-    }
-    const value = inline ?? next;
-    if (value === undefined) {
-        return { name: option.name, spelling };
-    }
-    if (inline === undefined && isOptionToken(value)) {
-        throw new MissingValueError(spelling);
-    }
-    if (repeatable) {
-        const collected = values.lists.get(option.name) ?? [];
-        collected.push(value);
-        values.lists.set(option.name, collected);
-    }
-    else {
-        values.strings.set(option.name, value);
-    }
-    return inline === undefined ? 'next' : 'alone';
-}
-function parseOption(spellings, input, values) {
-    const { token, next } = input;
-    const long = longToken(token);
-    if (long) {
-        const { inline, spelling } = long;
-        return acceptValue({ inline, next, option: lookup(spellings, spelling), spelling, values });
-    }
-    if (token === '-') {
-        lookup(spellings, token);
-    }
-    for (let index = 1; index < token.length; index += 1) {
-        const spelling = `-${token[index]}`;
-        const option = lookup(spellings, spelling);
-        const suffix = token.slice(index + 1);
-        if (option.type === 'string' && suffix !== '') {
-            throw new ShortGroupError({ reason: 'value-position', token: spelling });
-        }
-        const inline = suffix.startsWith('=') ? suffix.slice(1) : undefined;
-        const reading = acceptValue({ inline, next, option, spelling, values });
-        if (reading !== 'alone') {
-            return reading;
-        }
-    }
-    return 'alone';
-}
-/**
- * Reads one option token into the scan and answers whether it took the next token too. The names
- * it newly supplied join `supplied` in the order the values map first recorded them, so a repeated
- * option keeps its first position.
- */
-function readOption(spellings, input, state) {
-    const known = state.values.spellings.size;
-    const reading = parseOption(spellings, input, state.values);
-    for (const name of [...state.values.spellings.keys()].slice(known)) {
-        state.supplied.push({ name, token: input.index });
-    }
-    if (typeof reading === 'object') {
-        state.awaiting = reading;
-    }
-    return reading === 'next';
-}
-/**
- * A hyphen token belongs to the globals when its long spelling or every short letter does. The
- * pre-scan reads the globals alone, so a letter it does not own is only "not a global option".
- * The scan stops at a global value option, because the letters after it may be the value the
- * operator meant to pass: the token then belongs to the globals, and parsing reports the
- * value-position fault that names that option alone.
- */
-function isGlobalToken(spellings, token) {
-    const long = longToken(token);
-    if (long) {
-        return spellings.has(long.spelling);
-    }
-    const group = token.slice(1).split('=')[0] ?? '';
-    let global = '';
-    let other = '';
-    for (let index = 0; index < group.length; index += 1) {
-        const letter = group.charAt(index);
-        const option = spellings.get(`-${letter}`);
-        if (option) {
-            global = global === '' ? letter : global;
-            if (option.type === 'string') {
-                break;
-            }
-        }
-        else {
-            other = other === '' ? letter : other;
-        }
-    }
-    if (global === '') {
-        return false;
-    }
-    if (other !== '') {
-        throw new ShortGroupError({ global, other, reason: 'mixed-scope', token });
-    }
-    return true;
-}
-/** Consumes global options anywhere before the passthrough delimiter and leaves the rest routable. */
-export function scanGlobals(spellings, tokens) {
-    const state = { awaiting: undefined, supplied: [], values: emptyValues() };
-    const rest = [];
-    const positions = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if (token === undefined) {
-            break;
-        }
-        if (token === '--') {
-            // One push per token, because a spread call would overflow the stack on a long list.
-            for (const [offset, tail] of tokens.slice(index).entries()) {
-                rest.push(tail);
-                positions.push(index + offset);
-            }
-            break;
-        }
-        if (!isOptionToken(token) || !isGlobalToken(spellings, token)) {
-            rest.push(token);
-            positions.push(index);
-        }
-        else if (readOption(spellings, { index, next: tokens[index + 1], token }, state)) {
-            index += 1;
-        }
-    }
-    return { ...state, positions, rest };
-}
-/** The pre-scan of a complete invocation, where a global still waiting for its value is a fault. */
-export function extractGlobals(spellings, tokens) {
-    const { awaiting, rest, values } = scanGlobals(spellings, tokens);
-    if (awaiting) {
-        throw new MissingValueError(awaiting.spelling);
-    }
-    return { rest, values };
-}
 /**
  * Whether one option holds a value a tier supplied: a token in any spelling it accepts, or a fill
  * from an input source. A declared default is never in these maps, so it never counts.
  */
 export function isSupplied(values, name) {
-    return values.strings.has(name) || values.lists.has(name) || values.booleans.has(name);
+    return (values.strings.has(name) ||
+        values.lists.has(name) ||
+        values.booleans.has(name) ||
+        values.counts.has(name));
 }
 /** One run's own copy of parsed values, which the input-source stage fills without touching argv's. */
 export function copyValues(values) {
     return {
         booleans: new Map(values.booleans),
+        counts: new Map(values.counts),
+        implied: new Map([...values.implied].map(([name, positions]) => [name, [...positions]])),
         lists: new Map([...values.lists].map(([name, list]) => [name, [...list]])),
         spellings: new Map(values.spellings),
         strings: new Map(values.strings),
@@ -378,45 +451,10 @@ export function copyValues(values) {
 export function mergeValues(globals, locals) {
     return {
         booleans: new Map([...globals.booleans, ...locals.booleans]),
+        counts: new Map([...globals.counts, ...locals.counts]),
+        implied: new Map([...globals.implied, ...locals.implied]),
         lists: new Map([...globals.lists, ...locals.lists]),
         spellings: new Map([...globals.spellings, ...locals.spellings]),
         strings: new Map([...globals.strings, ...locals.strings]),
     };
 }
-/** Reads one Command's tokens into options, positionals, and the passthrough tail. */
-export function scanInputs(spellings, tokens) {
-    const state = { awaiting: undefined, supplied: [], values: emptyValues() };
-    const positionals = [];
-    const read = (passthrough, delimited) => ({
-        awaiting: state.awaiting,
-        delimited,
-        options: state.values,
-        passthrough,
-        positionals,
-        supplied: state.supplied,
-    });
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if (token === undefined) {
-            break;
-        }
-        if (token === '--') {
-            return read(tokens.slice(index + 1), true);
-        }
-        if (!isOptionToken(token)) {
-            positionals.push(token);
-        }
-        else if (readOption(spellings, { index, next: tokens[index + 1], token }, state)) {
-            index += 1;
-        }
-    }
-    return read([], false);
-}
-/** Parses a complete invocation's local tokens, where a waiting option is a missing value. */
-export function parseInputs(spellings, tokens) {
-    const { awaiting, options, passthrough, positionals } = scanInputs(spellings, tokens);
-    if (awaiting) {
-        throw new MissingValueError(awaiting.spelling);
-    }
-    return { options, passthrough, positionals };
-}