@optique/core 1.4.0-dev.2708 → 1.4.0-dev.2711

package/dist/constructs.cjs

@@ -8,6 +8,7 @@ const require_internal_dependency = require('./internal/dependency.cjs');
 const require_dependency_runtime = require('./dependency-runtime.cjs');
 const require_internal_parser = require('./internal/parser.cjs');
 const require_annotation_state = require('./annotation-state.cjs');
+const require_empty_input = require('./internal/empty-input.cjs');
 const require_execution_context = require('./execution-context.cjs');
 const require_usage_internals = require('./usage-internals.cjs');
 const require_short_option = require('./short-option.cjs');
@@ -890,7 +891,8 @@ function applyHiddenToUsageTerm(term, hidden) {
 	if (term.type === "multiple") return {
 		type: "multiple",
 		terms: applyHiddenToUsage(term.terms, hidden),
-		min: term.min
+		min: term.min,
+		...term.acceptsEmpty == null ? {} : { acceptsEmpty: term.acceptsEmpty }
 	};
 	if (term.type === "sequence") return {
 		type: "sequence",
@@ -898,7 +900,8 @@ function applyHiddenToUsageTerm(term, hidden) {
 	};
 	if (term.type === "exclusive") return {
 		type: "exclusive",
-		terms: term.terms.map((u) => applyHiddenToUsage(u, hidden))
+		terms: term.terms.map((u) => applyHiddenToUsage(u, hidden)),
+		...term.acceptsEmpty == null ? {} : { acceptsEmpty: term.acceptsEmpty }
 	};
 	if (term.type === "argument" || term.type === "option" || term.type === "command" || term.type === "passthrough") return {
 		...term,
@@ -962,7 +965,7 @@ function isOptionRequiringValue(usage, token) {
 		} else if (term.type === "optional" || term.type === "multiple" || term.type === "sequence") {
 			if (traverse(term.terms)) return true;
 		} else if (term.type === "exclusive") {
-			for (const exclusiveUsage of term.terms) if (traverse(exclusiveUsage)) return true;
+			for (const exclusiveUsage$1 of term.terms) if (traverse(exclusiveUsage$1)) return true;
 		}
 		return false;
 	}
@@ -1202,6 +1205,28 @@ function preserveExclusiveStateAfterOptionsTerminator(context, result) {
 	};
 }
 /**
+* Describes the branches of an exclusive combinator for the empty-input
+* rules.
+*/
+function getExclusiveBranches(parsers) {
+	return parsers.map((parser) => ({
+		facts: require_empty_input.getEmptyInputFacts(parser),
+		matchesTokens: parser.leadingNames.size > 0 || parser.acceptingAnyToken
+	}));
+}
+/**
+* Builds the exclusive usage term of `or()` and `longestMatch()`, recording
+* whether the combinator accepts an empty argument list when known.
+*/
+function exclusiveUsage(parsers, facts) {
+	const acceptsEmpty = require_empty_input.acceptsEmptyInput(facts);
+	return [{
+		type: "exclusive",
+		terms: parsers.map((p) => p.usage),
+		...acceptsEmpty == null ? {} : { acceptsEmpty }
+	}];
+}
+/**
 * Creates a complete() method shared by or() and longestMatch().
 * @internal
 */
@@ -1914,15 +1939,13 @@ function or(...args) {
 		if (optionsTerminatorResult != null) return preserveExclusiveStateAfterOptionsTerminator(context, optionsTerminatorResult);
 		return error;
 	};
+	const emptyInputFacts = require_empty_input.orFacts(getExclusiveBranches(parsers));
 	const singleResult = {
 		mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
-		usage: [{
-			type: "exclusive",
-			terms: parsers.map((p) => p.usage)
-		}],
+		usage: exclusiveUsage(parsers, emptyInputFacts),
 		leadingNames: unionLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
@@ -1984,7 +2007,7 @@ function or(...args) {
 	defineExclusiveSchedulingNodes(singleResult, parsers);
 	require_internal_parser.defineInheritedAnnotationParser(singleResult);
 	require_passthrough.defineReachableChildren(singleResult, parsers, (state) => selectExclusiveChildren(parsers, state, true));
-	return require_modifiers.fluent(require_short_option.scopeParser(singleResult, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return require_modifiers.fluent(require_empty_input.withEmptyInputFacts(require_short_option.scopeParser(singleResult, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))), emptyInputFacts));
 }
 /**
 * @since 0.5.0
@@ -2162,15 +2185,13 @@ function createLongestMatch(...args) {
 		if (bestMatch != null) return commitLongestMatch(context, bestMatch, void 0, consumingFailure);
 		return error;
 	};
+	const emptyInputFacts = require_empty_input.longestMatchFacts(getExclusiveBranches(parsers));
 	const multiResult = {
 		mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
-		usage: [{
-			type: "exclusive",
-			terms: parsers.map((p) => p.usage)
-		}],
+		usage: exclusiveUsage(parsers, emptyInputFacts),
 		leadingNames: unionLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
@@ -2230,7 +2251,7 @@ function createLongestMatch(...args) {
 	defineExclusiveSchedulingNodes(multiResult, parsers);
 	require_internal_parser.defineInheritedAnnotationParser(multiResult);
 	require_passthrough.defineReachableChildren(multiResult, parsers, (state) => selectExclusiveChildren(parsers, state, false));
-	return require_modifiers.fluent(require_short_option.scopeParser(multiResult, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return require_modifiers.fluent(require_empty_input.withEmptyInputFacts(require_short_option.scopeParser(multiResult, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))), emptyInputFacts));
 }
 /**
 * Creates the initial parse error shared by object-like combinators.
@@ -3288,7 +3309,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			state: require_annotation_state.getWrappedChildParseState(state, getFieldState(field, parser), parser)
 		}));
 	});
-	return require_modifiers.fluent(require_short_option.scopeParser(objectParser, require_short_option.combinedOptionScope(parserPairs.map(([, p]) => p), parserPairs.map(([field]) => field)), void 0, true));
+	return require_modifiers.fluent(require_empty_input.withEmptyInputFacts(require_short_option.scopeParser(objectParser, require_short_option.combinedOptionScope(parserPairs.map(([, p]) => p), parserPairs.map(([field]) => field)), void 0, true), combinedMode === "sync" ? require_empty_input.objectFacts(parserPairs.map(([, p]) => ({
+		facts: require_empty_input.getEmptyInputFacts(p),
+		matchesTokens: p.leadingNames.size > 0 || p.acceptingAnyToken
+	})), parserPairs.map(([field]) => field)) : {}));
 }
 function isParserLike(value) {
 	return value != null && (typeof value === "object" || typeof value === "function") && "parse" in value && "$valueType" in value && "$stateType" in value;
@@ -4339,7 +4363,10 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		parser,
 		state: require_annotation_state.getWrappedChildParseState(state, state[index], parser)
 	})));
-	return require_modifiers.fluent(require_short_option.scopeParser(tupleParser, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return require_modifiers.fluent(require_empty_input.withEmptyInputFacts(require_short_option.scopeParser(tupleParser, require_short_option.combinedOptionScope(parsers, parsers.map((_, index) => index))), require_empty_input.tupleFacts(parsers.map((p) => ({
+		facts: require_empty_input.getEmptyInputFacts(p),
+		matchesTokens: p.leadingNames.size > 0 || p.acceptingAnyToken
+	})))));
 }
 function seq(...rawArgs) {
 	const label = typeof rawArgs[0] === "string" ? rawArgs[0] : void 0;
@@ -6510,7 +6537,7 @@ function group(label, parser, options = {}) {
 		parser,
 		state
 	}]);
-	return require_modifiers.fluent(require_short_option.scopeParser(groupParser, require_short_option.combinedOptionScope([parser])));
+	return require_modifiers.fluent(require_empty_input.withEmptyInputFacts(require_short_option.scopeParser(groupParser, require_short_option.combinedOptionScope([parser])), require_empty_input.getEmptyInputFacts(parser)));
 }
 /**
 * Creates a conditional parser that selects different branch parsers based on

package/dist/constructs.js

@@ -8,6 +8,7 @@ import { createDependencySourceState, dependencyId, isDependencySourceState, isP
 import { buildRuntimeNodesFromArray, buildRuntimeNodesFromPairs, collectExplicitSourceValues, collectExplicitSourceValuesAsync, collectSourcesFromState, completeEffectfulSourcesAsync, createDependencyRuntimeContext, effectfulSchedulingNodesKey, exclusiveSourceScopeKey, extractRawInputFromState, fillMissingSourceDefaults, fillMissingSourceDefaultsAsync, forkRuntimeForCommittedSubtree, getDefaultDependencySnapshot, guaranteedStaticSourceIdsKey, hasInactiveCompletion, isMatchedState, recordSourceScope, releaseUncollectedSourceValues, replaceCachedBarrierFailure, resolveDerivedSourceValues, resolveDerivedSourceValuesAsync, resolveStateWithRuntime, resolveStateWithRuntimeAsync, serializeSchedulingPath, sourceCollectionExpansionKey, staticSourceScopeKey } from "./dependency-runtime.js";
 import { defineInheritedAnnotationParser, defineParseLanes, getOwnParseLanes, getParserSuggestRuntimeNodes, unmatchedNonCliDependencySourceStateMarker } from "./internal/parser.js";
 import { annotationViewTargets, getWrappedChildParseState, getWrappedChildState, reconcileObjectChildState, unwrapAnnotationView } from "./annotation-state.js";
+import { acceptsEmptyInput, getEmptyInputFacts, longestMatchFacts, objectFacts, orFacts, tupleFacts, withEmptyInputFacts } from "./internal/empty-input.js";
 import { mergeChildExec, withChildContext, withChildExecPath } from "./execution-context.js";
 import { collectLeadingCandidates } from "./usage-internals.js";
 import { adoptOptionScope, combinedOptionScope, conditionalOptionScope, forkOptionScope, restoreOptionScope, scopeParser, selectableOptionScope, withOptionScope, withParserOptionScope } from "./short-option.js";
@@ -890,7 +891,8 @@ function applyHiddenToUsageTerm(term, hidden) {
 	if (term.type === "multiple") return {
 		type: "multiple",
 		terms: applyHiddenToUsage(term.terms, hidden),
-		min: term.min
+		min: term.min,
+		...term.acceptsEmpty == null ? {} : { acceptsEmpty: term.acceptsEmpty }
 	};
 	if (term.type === "sequence") return {
 		type: "sequence",
@@ -898,7 +900,8 @@ function applyHiddenToUsageTerm(term, hidden) {
 	};
 	if (term.type === "exclusive") return {
 		type: "exclusive",
-		terms: term.terms.map((u) => applyHiddenToUsage(u, hidden))
+		terms: term.terms.map((u) => applyHiddenToUsage(u, hidden)),
+		...term.acceptsEmpty == null ? {} : { acceptsEmpty: term.acceptsEmpty }
 	};
 	if (term.type === "argument" || term.type === "option" || term.type === "command" || term.type === "passthrough") return {
 		...term,
@@ -962,7 +965,7 @@ function isOptionRequiringValue(usage, token) {
 		} else if (term.type === "optional" || term.type === "multiple" || term.type === "sequence") {
 			if (traverse(term.terms)) return true;
 		} else if (term.type === "exclusive") {
-			for (const exclusiveUsage of term.terms) if (traverse(exclusiveUsage)) return true;
+			for (const exclusiveUsage$1 of term.terms) if (traverse(exclusiveUsage$1)) return true;
 		}
 		return false;
 	}
@@ -1202,6 +1205,28 @@ function preserveExclusiveStateAfterOptionsTerminator(context, result) {
 	};
 }
 /**
+* Describes the branches of an exclusive combinator for the empty-input
+* rules.
+*/
+function getExclusiveBranches(parsers) {
+	return parsers.map((parser) => ({
+		facts: getEmptyInputFacts(parser),
+		matchesTokens: parser.leadingNames.size > 0 || parser.acceptingAnyToken
+	}));
+}
+/**
+* Builds the exclusive usage term of `or()` and `longestMatch()`, recording
+* whether the combinator accepts an empty argument list when known.
+*/
+function exclusiveUsage(parsers, facts) {
+	const acceptsEmpty = acceptsEmptyInput(facts);
+	return [{
+		type: "exclusive",
+		terms: parsers.map((p) => p.usage),
+		...acceptsEmpty == null ? {} : { acceptsEmpty }
+	}];
+}
+/**
 * Creates a complete() method shared by or() and longestMatch().
 * @internal
 */
@@ -1914,15 +1939,13 @@ function or(...args) {
 		if (optionsTerminatorResult != null) return preserveExclusiveStateAfterOptionsTerminator(context, optionsTerminatorResult);
 		return error;
 	};
+	const emptyInputFacts = orFacts(getExclusiveBranches(parsers));
 	const singleResult = {
 		mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
-		usage: [{
-			type: "exclusive",
-			terms: parsers.map((p) => p.usage)
-		}],
+		usage: exclusiveUsage(parsers, emptyInputFacts),
 		leadingNames: unionLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
@@ -1984,7 +2007,7 @@ function or(...args) {
 	defineExclusiveSchedulingNodes(singleResult, parsers);
 	defineInheritedAnnotationParser(singleResult);
 	defineReachableChildren(singleResult, parsers, (state) => selectExclusiveChildren(parsers, state, true));
-	return fluent(scopeParser(singleResult, combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return fluent(withEmptyInputFacts(scopeParser(singleResult, combinedOptionScope(parsers, parsers.map((_, index) => index))), emptyInputFacts));
 }
 /**
 * @since 0.5.0
@@ -2162,15 +2185,13 @@ function createLongestMatch(...args) {
 		if (bestMatch != null) return commitLongestMatch(context, bestMatch, void 0, consumingFailure);
 		return error;
 	};
+	const emptyInputFacts = longestMatchFacts(getExclusiveBranches(parsers));
 	const multiResult = {
 		mode: combinedMode,
 		$valueType: [],
 		$stateType: [],
 		priority: Math.max(...parsers.map((p) => p.priority)),
-		usage: [{
-			type: "exclusive",
-			terms: parsers.map((p) => p.usage)
-		}],
+		usage: exclusiveUsage(parsers, emptyInputFacts),
 		leadingNames: unionLeadingNames(parsers),
 		acceptingAnyToken: parsers.some((p) => p.acceptingAnyToken),
 		initialState: void 0,
@@ -2230,7 +2251,7 @@ function createLongestMatch(...args) {
 	defineExclusiveSchedulingNodes(multiResult, parsers);
 	defineInheritedAnnotationParser(multiResult);
 	defineReachableChildren(multiResult, parsers, (state) => selectExclusiveChildren(parsers, state, false));
-	return fluent(scopeParser(multiResult, combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return fluent(withEmptyInputFacts(scopeParser(multiResult, combinedOptionScope(parsers, parsers.map((_, index) => index))), emptyInputFacts));
 }
 /**
 * Creates the initial parse error shared by object-like combinators.
@@ -3288,7 +3309,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			state: getWrappedChildParseState(state, getFieldState(field, parser), parser)
 		}));
 	});
-	return fluent(scopeParser(objectParser, combinedOptionScope(parserPairs.map(([, p]) => p), parserPairs.map(([field]) => field)), void 0, true));
+	return fluent(withEmptyInputFacts(scopeParser(objectParser, combinedOptionScope(parserPairs.map(([, p]) => p), parserPairs.map(([field]) => field)), void 0, true), combinedMode === "sync" ? objectFacts(parserPairs.map(([, p]) => ({
+		facts: getEmptyInputFacts(p),
+		matchesTokens: p.leadingNames.size > 0 || p.acceptingAnyToken
+	})), parserPairs.map(([field]) => field)) : {}));
 }
 function isParserLike(value) {
 	return value != null && (typeof value === "object" || typeof value === "function") && "parse" in value && "$valueType" in value && "$stateType" in value;
@@ -4339,7 +4363,10 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 		parser,
 		state: getWrappedChildParseState(state, state[index], parser)
 	})));
-	return fluent(scopeParser(tupleParser, combinedOptionScope(parsers, parsers.map((_, index) => index))));
+	return fluent(withEmptyInputFacts(scopeParser(tupleParser, combinedOptionScope(parsers, parsers.map((_, index) => index))), tupleFacts(parsers.map((p) => ({
+		facts: getEmptyInputFacts(p),
+		matchesTokens: p.leadingNames.size > 0 || p.acceptingAnyToken
+	})))));
 }
 function seq(...rawArgs) {
 	const label = typeof rawArgs[0] === "string" ? rawArgs[0] : void 0;
@@ -6510,7 +6537,7 @@ function group(label, parser, options = {}) {
 		parser,
 		state
 	}]);
-	return fluent(scopeParser(groupParser, combinedOptionScope([parser])));
+	return fluent(withEmptyInputFacts(scopeParser(groupParser, combinedOptionScope([parser])), getEmptyInputFacts(parser)));
 }
 /**
 * Creates a conditional parser that selects different branch parsers based on

package/dist/internal/empty-input.cjs

@@ -0,0 +1,368 @@
+
+//#region src/internal/empty-input.ts
+/**
+* The state of an empty step that leaves its input state unchanged.
+* @internal
+*/
+const UNCHANGED = Object.freeze({ unchanged: true });
+/**
+* Returns the state that an empty step produces from the given initial
+* state.
+* @param next The step's resulting state.
+* @param initialState The state the step started from.
+* @returns The resulting state.
+* @internal
+*/
+function resolveEmptyStepState(next, initialState) {
+	return "unchanged" in next ? initialState : next.state(initialState);
+}
+const emptyInputFactsKey = Symbol("emptyInputFacts");
+const UNKNOWN = Object.freeze({});
+/**
+* Attaches empty-input facts to a parser.  The facts are stored as a
+* non-enumerable property, so object spread does not copy them, and they
+* are bound to the parser's current `parse`, `complete`, and
+* `initialState`, so replacing any of those invalidates them.
+* @param parser The parser to annotate.
+* @param facts The facts to attach.
+* @internal
+*/
+function defineEmptyInputFacts(parser, facts) {
+	if (Object.keys(facts).length < 1) return;
+	Object.defineProperty(parser, emptyInputFactsKey, {
+		value: {
+			facts,
+			parse: parser.parse,
+			complete: parser.complete,
+			...Object.getOwnPropertyDescriptor(parser, "initialState")?.get == null ? { initialState: { value: parser.initialState } } : {}
+		},
+		configurable: true,
+		enumerable: false,
+		writable: false
+	});
+}
+/**
+* Returns the empty-input facts of a parser, or an empty object when the
+* facts are unknown.
+* @param parser The parser to inspect.
+* @returns The facts known for the parser.
+* @internal
+*/
+function getEmptyInputFacts(parser) {
+	const stored = parser[emptyInputFactsKey];
+	if (stored == null || stored.parse !== parser.parse || stored.complete !== parser.complete || stored.initialState != null && stored.initialState.value !== parser.initialState) return UNKNOWN;
+	return stored.facts;
+}
+/**
+* Returns whether `parse(parser, [])` succeeds, when that is known from the
+* facts.
+* @param facts The parser's facts.
+* @returns `true` or `false` when known, `undefined` otherwise.
+* @internal
+*/
+function acceptsEmptyInput(facts) {
+	if (facts.step === "failure") return false;
+	if (facts.step == null) return void 0;
+	return facts.afterStep;
+}
+/**
+* Returns the facts of a parser that fails its empty step and whose
+* completion from the initial state has the given outcome.
+* @param fromInitial Whether completion from the initial state succeeds.
+* @returns The facts.
+* @internal
+*/
+function failingStepFacts(fromInitial) {
+	return {
+		step: "failure",
+		fromInitial
+	};
+}
+/**
+* Returns whether `complete()` succeeds after the parser was offered an
+* empty step whose state change was kept (on success) or discarded (on
+* failure).
+* @param facts The parser's facts.
+* @returns The outcome, or `undefined` when unknown.
+* @internal
+*/
+function completionAfterOptionalStep(facts) {
+	if (facts.step === "failure") return facts.fromInitial;
+	if (facts.step == null) return void 0;
+	return facts.afterStep;
+}
+/**
+* The state of a wrapper that stores its child's resulting state as the
+* only element of a fresh array.
+*/
+function wrapInFreshArray(child, childInitialState) {
+	return { state: () => [resolveEmptyStepState(child, childInitialState)] };
+}
+/**
+* Computes the facts of `optional(p)` and `withDefault(p, value)` when
+* completing the wrapper from its initial state is known to succeed.
+* @param child The facts of the wrapped parser.
+* @param childInitialState The wrapped parser's initial state.
+* @param fromInitial Whether completing the wrapper from its initial state
+*                    succeeds, or `undefined` when unknown.
+* @returns The facts of the wrapper.
+* @internal
+*/
+function optionalLikeFacts(child, childInitialState, fromInitial) {
+	if (child.step === "failure") return {
+		step: "success",
+		next: UNCHANGED,
+		afterStep: fromInitial,
+		fromInitial
+	};
+	if (child.step == null) return { fromInitial };
+	return {
+		step: child.step,
+		...child.next == null ? {} : { next: wrapInFreshArray(child.next, childInitialState) },
+		afterStep: child.afterStep,
+		fromInitial
+	};
+}
+/**
+* Computes the facts of `multiple(p, { min })` without a `max` bound.
+* @param child The facts of the repeated parser.
+* @param retainsItem Whether a successful empty step of the child is kept
+*                    as a repetition item, or `undefined` when unknown.
+* @param childInitialState The repeated parser's initial state.
+* @param min The minimum number of items.
+* @returns The facts of the repetition.
+* @internal
+*/
+function multipleFacts(child, retainsItem, childInitialState, min) {
+	const fromInitial = min < 1;
+	if (child.step === "failure") return min < 1 ? {
+		step: "success",
+		next: UNCHANGED,
+		afterStep: true,
+		fromInitial
+	} : {
+		step: "failure",
+		fromInitial
+	};
+	if (child.step == null || retainsItem == null) return { fromInitial };
+	if (!retainsItem) return {
+		step: "success",
+		next: UNCHANGED,
+		afterStep: min < 1,
+		fromInitial
+	};
+	return {
+		step: child.step,
+		...child.next == null ? {} : { next: wrapInFreshArray(child.next, childInitialState) },
+		afterStep: child.afterStep == null ? void 0 : min <= 1 && child.afterStep,
+		fromInitial
+	};
+}
+function selectZeroInputCandidate(branches) {
+	let index = -1;
+	let count = 0;
+	for (let i = 0; i < branches.length; i++) {
+		const branch = branches[i];
+		if (branch.matchesTokens) continue;
+		if (branch.facts.step == null) return void 0;
+		if (branch.facts.step !== "success") continue;
+		if (index < 0) index = i;
+		count++;
+	}
+	return count === 1 ? { index } : null;
+}
+/**
+* Computes the completion of `or()` and `longestMatch()` from their initial
+* state, which selects the unique zero-input candidate among the branches
+* that cannot match tokens.
+*/
+function exclusiveFromInitial(branches) {
+	const candidate = selectZeroInputCandidate(branches);
+	if (candidate === void 0) return void 0;
+	if (candidate === null) return false;
+	return branches[candidate.index].facts.afterStep;
+}
+/**
+* An exemplar of an exclusive combinator's state after it selected a branch.
+* It is a fresh, non-nullish value, which is all that repetition item checks
+* look at.
+*/
+function exclusiveNextState(index) {
+	return { state: () => [index, {
+		success: true,
+		consumed: []
+	}] };
+}
+/**
+* Computes the facts of `or()`.
+* @param branches The branches of the exclusive combinator.
+* @returns The facts of the combinator.
+* @internal
+*/
+function orFacts(branches) {
+	const candidate = selectZeroInputCandidate(branches);
+	if (candidate === void 0) return {};
+	const fromInitial = exclusiveFromInitial(branches);
+	if (candidate === null) return {
+		step: "failure",
+		fromInitial
+	};
+	return {
+		step: "success",
+		next: exclusiveNextState(candidate.index),
+		afterStep: branches[candidate.index].facts.afterStep,
+		fromInitial
+	};
+}
+/**
+* Computes the facts of `longestMatch()`, which selects the first branch
+* whose empty step succeeds, preferring a definitive success over a
+* provisional one.
+* @param branches The branches of the exclusive combinator.
+* @returns The facts of the combinator.
+* @internal
+*/
+function longestMatchFacts(branches) {
+	const fromInitial = exclusiveFromInitial(branches);
+	let best = null;
+	for (let i = 0; i < branches.length; i++) {
+		const facts = branches[i].facts;
+		if (facts.step == null) return { fromInitial };
+		if (facts.step === "failure") continue;
+		if (best == null || best.facts.step === "provisional" && facts.step === "success") best = {
+			index: i,
+			facts
+		};
+		if (best.facts.step === "success") break;
+	}
+	if (best == null) return {
+		step: "failure",
+		fromInitial
+	};
+	return {
+		step: best.facts.step,
+		next: exclusiveNextState(best.index),
+		afterStep: best.facts.afterStep,
+		fromInitial
+	};
+}
+function all(values) {
+	let unknown = false;
+	for (const value of values) {
+		if (value === false) return false;
+		if (value == null) unknown = true;
+	}
+	return unknown ? void 0 : true;
+}
+/**
+* Computes the facts of `tuple()`.  On an empty buffer `tuple()` offers
+* each child one zero-token step, stores the state of every child whose
+* step succeeded in a fresh state array, and skips the rest.
+* @param children The children in declaration order.
+* @returns The facts of the tuple.
+* @internal
+*/
+function tupleFacts(children) {
+	const fromInitial = all(children.map((c) => c.facts.fromInitial));
+	if (children.some((c) => c.facts.step == null)) return {
+		step: "success",
+		fromInitial
+	};
+	const afterStep = all(children.map((c) => completionAfterOptionalStep(c.facts)));
+	let next;
+	if (children.every((c) => c.facts.step === "failure")) next = UNCHANGED;
+	else if (children.every((c) => c.facts.step === "failure" || c.facts.next != null)) {
+		const steps = children.map((c) => c.facts.step === "failure" ? void 0 : c.facts.next);
+		next = { state: (initialState) => {
+			const slots = Array.isArray(initialState) ? initialState : [];
+			return steps.map((step, i) => step == null ? slots[i] : resolveEmptyStepState(step, slots[i]));
+		} };
+	}
+	return {
+		step: "success",
+		...next == null ? {} : { next },
+		afterStep,
+		fromInitial
+	};
+}
+/**
+* The state of `object()` after an empty step: a committed field state makes
+* it store a fresh record with the other fields unchanged.
+*/
+function objectNextState(changed) {
+	if (changed.length < 1) return UNCHANGED;
+	return { state: (initialState) => {
+		const record = initialState != null && typeof initialState === "object" ? { ...initialState } : {};
+		for (const [key, next] of changed) record[key] = resolveEmptyStepState(next, record[key]);
+		return record;
+	} };
+}
+/**
+* Computes the facts of a synchronous `object()`.  On an empty buffer
+* `object()` offers each field that cannot match tokens one zero-token
+* step, keeps the resulting state when it changed, and then succeeds only
+* if every field can complete.
+* @param children The fields.
+* @param keys The field keys, parallel to `children`.
+* @returns The facts of the object.
+* @internal
+*/
+function objectFacts(children, keys) {
+	const fromInitial = all(children.map((c) => c.facts.fromInitial));
+	const outcomes = [];
+	const changed = [];
+	let nextKnown = true;
+	for (const [i, child] of children.entries()) {
+		const { step, next } = child.facts;
+		if (child.matchesTokens || step === "failure") outcomes.push(child.facts.fromInitial);
+		else if (step == null) {
+			outcomes.push(void 0);
+			nextKnown = false;
+		} else if (next == null) {
+			nextKnown = false;
+			outcomes.push(child.facts.afterStep === child.facts.fromInitial ? child.facts.afterStep : void 0);
+		} else if ("unchanged" in next) outcomes.push(child.facts.fromInitial);
+		else {
+			changed.push([keys[i], next]);
+			outcomes.push(child.facts.afterStep);
+		}
+	}
+	const accepted = all(outcomes);
+	if (accepted == null) return { fromInitial };
+	if (!accepted) return {
+		step: "failure",
+		fromInitial
+	};
+	return {
+		step: "success",
+		...nextKnown ? { next: objectNextState(changed) } : {},
+		afterStep: true,
+		fromInitial
+	};
+}
+/**
+* Attaches empty-input facts to a parser and returns the parser.
+* @param parser The parser to annotate.
+* @param facts The facts to attach.
+* @returns The same parser.
+* @internal
+*/
+function withEmptyInputFacts(parser, facts) {
+	defineEmptyInputFacts(parser, facts);
+	return parser;
+}
+
+//#endregion
+exports.UNCHANGED = UNCHANGED;
+exports.acceptsEmptyInput = acceptsEmptyInput;
+exports.defineEmptyInputFacts = defineEmptyInputFacts;
+exports.failingStepFacts = failingStepFacts;
+exports.getEmptyInputFacts = getEmptyInputFacts;
+exports.longestMatchFacts = longestMatchFacts;
+exports.multipleFacts = multipleFacts;
+exports.objectFacts = objectFacts;
+exports.optionalLikeFacts = optionalLikeFacts;
+exports.orFacts = orFacts;
+exports.resolveEmptyStepState = resolveEmptyStepState;
+exports.tupleFacts = tupleFacts;
+exports.withEmptyInputFacts = withEmptyInputFacts;