@optique/core 0.5.0-dev.79 → 0.5.0-dev.80

package/dist/constructs.cjs

@@ -0,0 +1,754 @@
+const require_message = require('./message.cjs');
+
+//#region src/constructs.ts
+/**
+* @since 0.5.0
+*/
+function or(...args) {
+	let parsers;
+	let options;
+	if (args.length > 0 && args[args.length - 1] && typeof args[args.length - 1] === "object" && !("$valueType" in args[args.length - 1])) {
+		options = args[args.length - 1];
+		parsers = args.slice(0, -1);
+	} else {
+		parsers = args;
+		options = void 0;
+	}
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...parsers.map((p) => p.priority)),
+		usage: [{
+			type: "exclusive",
+			terms: parsers.map((p) => p.usage)
+		}],
+		initialState: void 0,
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: options?.errors?.noMatch ?? require_message.message`No matching option or command found.`
+			};
+			const [i, result] = state;
+			if (result.success) return parsers[i].complete(result.next.state);
+			return {
+				success: false,
+				error: result.error
+			};
+		},
+		parse(context) {
+			let error = {
+				consumed: 0,
+				error: context.buffer.length < 1 ? options?.errors?.noMatch ?? require_message.message`No matching option or command found.` : (() => {
+					const token = context.buffer[0];
+					const defaultMsg = require_message.message`Unexpected option or subcommand: ${require_message.optionName(token)}.`;
+					return options?.errors?.unexpectedInput != null ? typeof options.errors.unexpectedInput === "function" ? options.errors.unexpectedInput(token) : options.errors.unexpectedInput : defaultMsg;
+				})()
+			};
+			const orderedParsers = parsers.map((p, i) => [p, i]);
+			orderedParsers.sort(([_, a], [__, b]) => context.state?.[0] === a ? -1 : context.state?.[0] === b ? 1 : a - b);
+			for (const [parser, i] of orderedParsers) {
+				const result = parser.parse({
+					...context,
+					state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
+				});
+				if (result.success && result.consumed.length > 0) {
+					if (context.state?.[0] !== i && context.state?.[1].success) return {
+						success: false,
+						consumed: context.buffer.length - result.next.buffer.length,
+						error: require_message.message`${require_message.values(context.state[1].consumed)} and ${require_message.values(result.consumed)} cannot be used together.`
+					};
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: [i, result]
+						},
+						consumed: result.consumed
+					};
+				} else if (!result.success && error.consumed < result.consumed) error = result;
+			}
+			return {
+				...error,
+				success: false
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			let description;
+			let fragments;
+			if (state.kind === "unavailable" || state.state == null) fragments = parsers.flatMap((p) => p.getDocFragments({ kind: "unavailable" }, void 0).fragments);
+			else {
+				const [index, parserResult] = state.state;
+				const innerState = parserResult.success ? {
+					kind: "available",
+					state: parserResult.next.state
+				} : { kind: "unavailable" };
+				const docFragments = parsers[index].getDocFragments(innerState, void 0);
+				description = docFragments.description;
+				fragments = docFragments.fragments;
+			}
+			const entries = fragments.filter((f) => f.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			return {
+				description,
+				fragments: [...sections.map((s) => ({
+					...s,
+					type: "section"
+				})), {
+					type: "section",
+					entries
+				}]
+			};
+		}
+	};
+}
+/**
+* @since 0.5.0
+*/
+function longestMatch(...args) {
+	let parsers;
+	let options;
+	if (args.length > 0 && args[args.length - 1] && typeof args[args.length - 1] === "object" && !("$valueType" in args[args.length - 1])) {
+		options = args[args.length - 1];
+		parsers = args.slice(0, -1);
+	} else {
+		parsers = args;
+		options = void 0;
+	}
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...parsers.map((p) => p.priority)),
+		usage: [{
+			type: "exclusive",
+			terms: parsers.map((p) => p.usage)
+		}],
+		initialState: void 0,
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: options?.errors?.noMatch ?? require_message.message`No matching option or command found.`
+			};
+			const [i, result] = state;
+			if (result.success) return parsers[i].complete(result.next.state);
+			return {
+				success: false,
+				error: result.error
+			};
+		},
+		parse(context) {
+			let bestMatch = null;
+			let error = {
+				consumed: 0,
+				error: context.buffer.length < 1 ? options?.errors?.noMatch ?? require_message.message`No matching option or command found.` : (() => {
+					const token = context.buffer[0];
+					const defaultMsg = require_message.message`Unexpected option or subcommand: ${require_message.optionName(token)}.`;
+					return options?.errors?.unexpectedInput != null ? typeof options.errors.unexpectedInput === "function" ? options.errors.unexpectedInput(token) : options.errors.unexpectedInput : defaultMsg;
+				})()
+			};
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const result = parser.parse({
+					...context,
+					state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
+				});
+				if (result.success) {
+					const consumed = context.buffer.length - result.next.buffer.length;
+					if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
+						index: i,
+						result,
+						consumed
+					};
+				} else if (error.consumed < result.consumed) error = result;
+			}
+			if (bestMatch && bestMatch.result.success) return {
+				success: true,
+				next: {
+					...context,
+					buffer: bestMatch.result.next.buffer,
+					optionsTerminated: bestMatch.result.next.optionsTerminated,
+					state: [bestMatch.index, bestMatch.result]
+				},
+				consumed: bestMatch.result.consumed
+			};
+			return {
+				...error,
+				success: false
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			let description;
+			let fragments;
+			if (state.kind === "unavailable" || state.state == null) fragments = parsers.flatMap((p) => p.getDocFragments({ kind: "unavailable" }).fragments);
+			else {
+				const [i, result] = state.state;
+				if (result.success) {
+					const docResult = parsers[i].getDocFragments({
+						kind: "available",
+						state: result.next.state
+					});
+					description = docResult.description;
+					fragments = docResult.fragments;
+				} else fragments = parsers.flatMap((p) => p.getDocFragments({ kind: "unavailable" }).fragments);
+			}
+			return {
+				description,
+				fragments
+			};
+		}
+	};
+}
+function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
+	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
+	let parsers;
+	let options = {};
+	if (typeof labelOrParsers === "string") {
+		parsers = maybeParsersOrOptions;
+		options = maybeOptions ?? {};
+	} else {
+		parsers = labelOrParsers;
+		options = maybeParsersOrOptions ?? {};
+	}
+	const parserPairs = Object.entries(parsers);
+	parserPairs.sort(([_, parserA], [__, parserB]) => parserB.priority - parserA.priority);
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...Object.values(parsers).map((p) => p.priority)),
+		usage: parserPairs.flatMap(([_, p]) => p.usage),
+		initialState: Object.fromEntries(Object.entries(parsers).map(([key, parser]) => [key, parser.initialState])),
+		parse(context) {
+			let error = {
+				consumed: 0,
+				error: context.buffer.length > 0 ? (() => {
+					const token = context.buffer[0];
+					const customMessage = options.errors?.unexpectedInput;
+					return customMessage ? typeof customMessage === "function" ? customMessage(token) : customMessage : require_message.message`Unexpected option or argument: ${token}.`;
+				})() : options.errors?.endOfInput ?? require_message.message`Expected an option or argument, but got end of input.`
+			};
+			let currentContext = context;
+			let anySuccess = false;
+			const allConsumed = [];
+			let madeProgress = true;
+			while (madeProgress && currentContext.buffer.length > 0) {
+				madeProgress = false;
+				for (const [field, parser] of parserPairs) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state && typeof currentContext.state === "object" && field in currentContext.state ? currentContext.state[field] : parser.initialState
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: {
+								...currentContext.state,
+								[field]: result.next.state
+							}
+						};
+						allConsumed.push(...result.consumed);
+						anySuccess = true;
+						madeProgress = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+			}
+			if (anySuccess) return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+			if (context.buffer.length === 0) {
+				let allCanComplete = true;
+				for (const [field, parser] of parserPairs) {
+					const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+					const completeResult = parser.complete(fieldState);
+					if (!completeResult.success) {
+						allCanComplete = false;
+						break;
+					}
+				}
+				if (allCanComplete) return {
+					success: true,
+					next: context,
+					consumed: []
+				};
+			}
+			return {
+				...error,
+				success: false
+			};
+		},
+		complete(state) {
+			const result = {};
+			for (const field in state) {
+				if (!(field in parsers)) continue;
+				const valueResult = parsers[field].complete(state[field]);
+				if (valueResult.success) result[field] = valueResult.value;
+				else return {
+					success: false,
+					error: valueResult.error
+				};
+			}
+			return {
+				success: true,
+				value: result
+			};
+		},
+		getDocFragments(state, defaultValue) {
+			const fragments = parserPairs.flatMap(([field, p]) => {
+				const fieldState = state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state[field]
+				};
+				return p.getDocFragments(fieldState, defaultValue?.[field]).fragments;
+			});
+			const entries = fragments.filter((d) => d.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const section = {
+				title: label,
+				entries
+			};
+			sections.push(section);
+			return { fragments: sections.map((s) => ({
+				...s,
+				type: "section"
+			})) };
+		}
+	};
+}
+function tuple(labelOrParsers, maybeParsers) {
+	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
+	const parsers = typeof labelOrParsers === "string" ? maybeParsers : labelOrParsers;
+	return {
+		$valueType: [],
+		$stateType: [],
+		usage: parsers.toSorted((a, b) => b.priority - a.priority).flatMap((p) => p.usage),
+		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
+		initialState: parsers.map((parser) => parser.initialState),
+		parse(context) {
+			let currentContext = context;
+			const allConsumed = [];
+			const matchedParsers = /* @__PURE__ */ new Set();
+			while (matchedParsers.size < parsers.length) {
+				let foundMatch = false;
+				let error = {
+					consumed: 0,
+					error: require_message.message`No remaining parsers could match the input.`
+				};
+				const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+				for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						allConsumed.push(...result.consumed);
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+				if (!foundMatch) for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length < 1) {
+						currentContext = {
+							...currentContext,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && result.consumed < 1) {
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					}
+				}
+				if (!foundMatch) return {
+					...error,
+					success: false
+				};
+			}
+			return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+		},
+		complete(state) {
+			const result = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const valueResult = parsers[i].complete(state[i]);
+				if (valueResult.success) result[i] = valueResult.value;
+				else return {
+					success: false,
+					error: valueResult.error
+				};
+			}
+			return {
+				success: true,
+				value: result
+			};
+		},
+		getDocFragments(state, defaultValue) {
+			const fragments = parsers.flatMap((p, i) => {
+				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state[i]
+				};
+				return p.getDocFragments(indexState, defaultValue?.[i]).fragments;
+			});
+			const entries = fragments.filter((d) => d.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const section = {
+				title: label,
+				entries
+			};
+			sections.push(section);
+			return { fragments: sections.map((s) => ({
+				...s,
+				type: "section"
+			})) };
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			const parsersStr = parsers.length === 1 ? `[1 parser]` : `[${parsers.length} parsers]`;
+			return label ? `tuple(${JSON.stringify(label)}, ${parsersStr})` : `tuple(${parsersStr})`;
+		}
+	};
+}
+function merge(...args) {
+	const label = typeof args[0] === "string" ? args[0] : void 0;
+	let parsers = typeof args[0] === "string" ? args.slice(1) : args;
+	parsers = parsers.toSorted((a, b) => b.priority - a.priority);
+	const initialState = {};
+	for (const parser of parsers) if (parser.initialState && typeof parser.initialState === "object") for (const field in parser.initialState) initialState[field] = parser.initialState[field];
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...parsers.map((p) => p.priority)),
+		usage: parsers.flatMap((p) => p.usage),
+		initialState,
+		parse(context) {
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
+				if (parser.initialState === void 0) parserState = void 0;
+				else if (parser.initialState && typeof parser.initialState === "object") if (context.state && typeof context.state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const result = parser.parse({
+					...context,
+					state: parserState
+				});
+				if (result.success) {
+					let newState;
+					if (parser.initialState === void 0) newState = {
+						...context.state,
+						[`__parser_${i}`]: result.next.state
+					};
+					else newState = {
+						...context.state,
+						...result.next.state
+					};
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: newState
+						},
+						consumed: result.consumed
+					};
+				} else if (result.consumed < 1) continue;
+				else return result;
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: require_message.message`No matching option or argument found.`
+			};
+		},
+		complete(state) {
+			const object$1 = {};
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
+				if (parser.initialState === void 0) {
+					const key = `__parser_${i}`;
+					if (state && typeof state === "object" && key in state) parserState = state[key];
+					else parserState = void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") if (state && typeof state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const result = parser.complete(parserState);
+				if (!result.success) return result;
+				for (const field in result.value) object$1[field] = result.value[field];
+			}
+			return {
+				success: true,
+				value: object$1
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			const fragments = parsers.flatMap((p) => {
+				const parserState = p.initialState === void 0 ? { kind: "unavailable" } : state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state
+				};
+				return p.getDocFragments(parserState, void 0).fragments;
+			});
+			const entries = fragments.filter((f) => f.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			if (label) {
+				const labeledSection = {
+					title: label,
+					entries
+				};
+				sections.push(labeledSection);
+				return { fragments: sections.map((s) => ({
+					...s,
+					type: "section"
+				})) };
+			}
+			return { fragments: [...sections.map((s) => ({
+				...s,
+				type: "section"
+			})), {
+				type: "section",
+				entries
+			}] };
+		}
+	};
+}
+function concat(...parsers) {
+	const initialState = parsers.map((parser) => parser.initialState);
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: parsers.length > 0 ? Math.max(...parsers.map((p) => p.priority)) : 0,
+		usage: parsers.flatMap((p) => p.usage),
+		initialState,
+		parse(context) {
+			let currentContext = context;
+			const allConsumed = [];
+			const matchedParsers = /* @__PURE__ */ new Set();
+			while (matchedParsers.size < parsers.length) {
+				let foundMatch = false;
+				let error = {
+					consumed: 0,
+					error: require_message.message`No remaining parsers could match the input.`
+				};
+				const remainingParsers = parsers.map((parser, index) => [parser, index]).filter(([_, index]) => !matchedParsers.has(index)).sort(([parserA], [parserB]) => parserB.priority - parserA.priority);
+				for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						allConsumed.push(...result.consumed);
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+				if (!foundMatch) for (const [parser, index] of remainingParsers) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state[index]
+					});
+					if (result.success && result.consumed.length < 1) {
+						currentContext = {
+							...currentContext,
+							state: currentContext.state.map((s, idx) => idx === index ? result.next.state : s)
+						};
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					} else if (!result.success && result.consumed < 1) {
+						matchedParsers.add(index);
+						foundMatch = true;
+						break;
+					}
+				}
+				if (!foundMatch) return {
+					...error,
+					success: false
+				};
+			}
+			return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+		},
+		complete(state) {
+			const results = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = state[i];
+				const result = parser.complete(parserState);
+				if (!result.success) return result;
+				if (Array.isArray(result.value)) results.push(...result.value);
+				else results.push(result.value);
+			}
+			return {
+				success: true,
+				value: results
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			const fragments = parsers.flatMap((p, index) => {
+				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state[index]
+				};
+				return p.getDocFragments(indexState, void 0).fragments;
+			});
+			const entries = fragments.filter((f) => f.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const result = [...sections.map((s) => ({
+				...s,
+				type: "section"
+			}))];
+			if (entries.length > 0) result.push({
+				type: "section",
+				entries
+			});
+			return { fragments: result };
+		}
+	};
+}
+/**
+* Wraps a parser with a group label for documentation purposes.
+*
+* The `group()` function is a documentation-only wrapper that applies a label
+* to any parser for help text organization. This allows you to use clean code
+* structure with combinators like {@link merge} while maintaining well-organized
+* help text through group labeling.
+*
+* The wrapped parser has identical parsing behavior but generates documentation
+* fragments wrapped in a labeled section. This is particularly useful when
+* combining parsers using {@link merge}—you can wrap the merged result with
+* `group()` to add a section header in help output.
+*
+* @example
+* ```typescript
+* const apiOptions = merge(
+*   object({ endpoint: option("--endpoint", string()) }),
+*   object({ timeout: option("--timeout", integer()) })
+* );
+*
+* const groupedApiOptions = group("API Options", apiOptions);
+* // Now produces a labeled "API Options" section in help text
+* ```
+*
+* @example
+* ```typescript
+* // Can be used with any parser, not just merge()
+* const verboseGroup = group("Verbosity", object({
+*   verbose: option("-v", "--verbose"),
+*   quiet: option("-q", "--quiet")
+* }));
+* ```
+*
+* @template TValue The value type of the wrapped parser.
+* @template TState The state type of the wrapped parser.
+* @param label A descriptive label for this parser group, used for
+*              documentation and help text organization.
+* @param parser The parser to wrap with a group label.
+* @returns A new parser that behaves identically to the input parser
+*          but generates documentation within a labeled section.
+* @since 0.4.0
+*/
+function group(label, parser) {
+	return {
+		$valueType: parser.$valueType,
+		$stateType: parser.$stateType,
+		priority: parser.priority,
+		usage: parser.usage,
+		initialState: parser.initialState,
+		parse: (context) => parser.parse(context),
+		complete: (state) => parser.complete(state),
+		getDocFragments: (state, defaultValue) => {
+			const { description, fragments } = parser.getDocFragments(state, defaultValue);
+			const allEntries = [];
+			const titledSections = [];
+			for (const fragment of fragments) if (fragment.type === "entry") allEntries.push(fragment);
+			else if (fragment.type === "section") if (fragment.title) titledSections.push(fragment);
+			else allEntries.push(...fragment.entries);
+			const labeledSection = {
+				title: label,
+				entries: allEntries
+			};
+			return {
+				description,
+				fragments: [...titledSections.map((s) => ({
+					...s,
+					type: "section"
+				})), {
+					type: "section",
+					...labeledSection
+				}]
+			};
+		}
+	};
+}
+
+//#endregion
+exports.concat = concat;
+exports.group = group;
+exports.longestMatch = longestMatch;
+exports.merge = merge;
+exports.object = object;
+exports.or = or;
+exports.tuple = tuple;