oxlint-plugin-effect 0.14.0 → 0.15.0

package/dist/rules/_anti-slop-reflect-method.js

@@ -1,4 +1,5 @@
 import { resolveVariable } from "./_anti-slop-scope.js";
+import * as Option from "effect/Option";
 //#region src/rules/_anti-slop-reflect-method.ts
 /**
 * Ported from dmmulroy/anti-slop at
@@ -7,15 +8,18 @@ import { resolveVariable } from "./_anti-slop-scope.js";
 function isGlobalReflect(sourceCode, expression) {
 	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
 	if (sourceCode.isGlobalReference(expression)) return true;
-	const variable = resolveVariable(sourceCode, expression);
-	return variable === null || variable.defs.length === 0;
+	return Option.match(resolveVariable(sourceCode, expression), {
+		onNone: () => true,
+		onSome: (variable) => variable.defs.length === 0
+	});
 }
 /** Reports whether a call target names one method on the global Reflect object. */
 function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
 	if (!isGlobalReflect(sourceCode, callee.object)) return false;
 	const property = callee.property;
-	return callee.computed ? property.type === "Literal" && property.value === methodName : property.type === "Identifier" && property.name === methodName;
+	if (callee.computed) return property.type === "Literal" && property.value === methodName;
+	return property.type === "Identifier" && property.name === methodName;
 }
 //#endregion
 export { isGlobalReflectMethodCall };

package/dist/rules/_anti-slop-scope.js

@@ -1,13 +1,15 @@
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_anti-slop-scope.ts
 /** Resolve an identifier to its binding by walking lexical scopes upward. */
 function resolveVariable(sourceCode, identifier) {
-	let scope = sourceCode.getScope(identifier);
-	while (scope !== null) {
-		const variable = scope.set.get(identifier.name);
-		if (variable !== void 0) return variable;
-		scope = scope.upper;
+	let scope = Option.some(sourceCode.getScope(identifier));
+	while (Option.isSome(scope)) {
+		const variable = scope.value.set.get(identifier.name);
+		if (Predicate.isNotUndefined(variable)) return Option.some(variable);
+		scope = Option.fromNullishOr(scope.value.upper);
 	}
-	return null;
+	return Option.none();
 }
 //#endregion
 export { resolveVariable };

package/dist/rules/_anti-slop-type-alias-resolution.js

@@ -1,58 +1,54 @@
+import { childNodesAt, isAstNode } from "./_ast-children.js";
+import { ancestors } from "./_ast-ancestors.js";
 import { lexicalTypeParameterNames } from "./_anti-slop-lexical-type-parameters.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_anti-slop-type-alias-resolution.ts
 const environmentsByProgram = /* @__PURE__ */ new WeakMap();
 function isNode(value) {
-	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+	return isAstNode(value);
+}
+function isTypeScope(node) {
+	return node.type === "Program" || node.type === "BlockStatement" || node.type === "TSModuleBlock" || node.type === "StaticBlock" || node.type === "SwitchStatement";
 }
 function enclosingTypeScope(node) {
-	let current = node.parent;
-	while (current !== null) {
-		if (current.type === "Program" || current.type === "BlockStatement" || current.type === "TSModuleBlock" || current.type === "StaticBlock" || current.type === "SwitchStatement") return current;
-		current = current.parent;
-	}
-	return node;
+	return Option.getOrElse(Arr.findFirst(ancestors(node), isTypeScope), () => node);
 }
 function declaredTypeBinding(node) {
-	if (node.type === "TSTypeAliasDeclaration") return {
-		alias: node,
+	if (node.type === "TSTypeAliasDeclaration") return Option.some({
+		alias: Option.some(node),
 		name: node.id.name
-	};
-	if (node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return node.id === null ? null : {
-		alias: null,
-		name: node.id.name
-	};
-	if (node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") return {
-		alias: null,
+	});
+	if (node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "ClassExpression") return Option.map(Option.fromNullishOr(node.id), (id) => ({
+		alias: Option.none(),
+		name: id.name
+	}));
+	if (node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") return Option.some({
+		alias: Option.none(),
 		name: node.local.name
-	};
-	return null;
+	});
+	return Option.none();
 }
 function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
 	const declared = declaredTypeBinding(node);
-	if (declared !== null) {
-		const bindings = bindingsByName.get(declared.name) ?? [];
+	if (Option.isSome(declared)) {
+		const { alias, name } = declared.value;
+		const bindings = bindingsByName.get(name) ?? [];
 		bindings.push({
-			...declared,
+			alias,
+			name,
 			scope: enclosingTypeScope(node)
 		});
-		bindingsByName.set(declared.name, bindings);
-		if (declared.alias !== null) aliases.push(declared.alias);
-	}
-	const fields = node;
-	for (const key of visitorKeys[node.type] ?? []) {
-		const value = fields[key];
-		if (isNode(value)) {
-			collectTypeBindings(value, visitorKeys, bindingsByName, aliases);
-			continue;
-		}
-		if (!Array.isArray(value)) continue;
-		for (const child of value) if (isNode(child)) collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+		bindingsByName.set(name, bindings);
+		if (Option.isSome(alias)) aliases.push(alias.value);
 	}
+	for (const key of visitorKeys[node.type] ?? []) for (const child of childNodesAt(node, key, isNode)) collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
 }
 /** Collect every lexical type alias and competing type binding in a program. */
 function createTypeAliasEnvironment(program, visitorKeys) {
 	const cached = environmentsByProgram.get(program);
-	if (cached !== void 0) return cached;
+	if (Predicate.isNotUndefined(cached)) return cached;
 	const bindingsByName = /* @__PURE__ */ new Map();
 	const aliases = [];
 	collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
@@ -65,14 +61,7 @@ function createTypeAliasEnvironment(program, visitorKeys) {
 	return environment;
 }
 function ancestorDistance(ancestor, node) {
-	let current = node;
-	let distance = 0;
-	while (current !== null) {
-		if (current === ancestor) return distance;
-		current = current.parent;
-		distance += 1;
-	}
-	return null;
+	return Arr.findFirstIndex([node, ...ancestors(node)], (current) => current === ancestor);
 }
 function nearestTypeBindings(name, use, environment) {
 	const candidates = environment.bindingsByName.get(name) ?? [];
@@ -80,61 +69,65 @@ function nearestTypeBindings(name, use, environment) {
 	let nearest = [];
 	for (const candidate of candidates) {
 		const distance = ancestorDistance(candidate.scope, use);
-		if (distance === null || distance > nearestDistance) continue;
-		if (distance === nearestDistance) {
+		if (Option.isNone(distance) || distance.value > nearestDistance) continue;
+		if (distance.value === nearestDistance) {
 			nearest.push(candidate);
 			continue;
 		}
-		nearestDistance = distance;
+		nearestDistance = distance.value;
 		nearest = [candidate];
 	}
 	return nearest;
 }
 /** Resolve the nearest visible alias with this name, respecting lexical shadowing. */
 function visibleTypeAlias(name, use, environment) {
-	if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name)) return null;
+	if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name)) return Option.none();
 	const bindings = nearestTypeBindings(name, use, environment);
-	return bindings.length === 1 ? bindings[0]?.alias ?? null : null;
+	if (bindings.length !== 1) return Option.none();
+	return Option.flatMap(Arr.head(bindings), (binding) => binding.alias);
 }
 /** Return whether a local declaration shadows a built-in type at this use. */
 function hasVisibleTypeBinding(name, use, environment) {
 	return lexicalTypeParameterNames(use, environment.visitorKeys).has(name) || nearestTypeBindings(name, use, environment).length > 0;
 }
 function typeReferenceName(type) {
-	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+	if (type.typeName.type !== "Identifier") return Option.none();
+	return Option.some(type.typeName.name);
 }
 function aliasSubstitutions(alias, reference, base) {
 	const parameters = alias.typeParameters?.params ?? [];
 	const typeArguments = reference.typeArguments?.params ?? [];
 	const next = new Map(base);
 	for (const [index, parameter] of parameters.entries()) {
-		const explicitArgument = typeArguments[index];
-		const argument = explicitArgument ?? parameter.default;
-		if (argument === null || argument === void 0) return null;
-		const argumentSubstitutions = explicitArgument === void 0 ? next : base;
+		const explicitArgument = Arr.get(typeArguments, index);
+		const argument = Option.orElse(explicitArgument, () => Option.fromNullishOr(parameter.default));
+		if (Option.isNone(argument)) return Option.none();
+		let argumentSubstitutions = base;
+		if (Option.isNone(explicitArgument)) argumentSubstitutions = next;
 		next.set(parameter.name.name, {
-			type: argument,
+			type: argument.value,
 			substitutions: new Map(argumentSubstitutions)
 		});
 	}
-	return next;
+	return Option.some(next);
 }
 /** Match a type after resolving visible aliases and substituting their type parameters. */
 function resolvedTypeMatches(type, environment, matcher) {
 	const evaluate = (current, substitutions, resolvingAliases) => {
 		if (current.type === "TSTypeReference") {
 			const name = typeReferenceName(current);
-			if (name !== null) {
-				const substitution = substitutions.get(name);
-				if (substitution !== void 0 && !current.typeArguments?.params.length) return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
-				const alias = visibleTypeAlias(name, current, environment);
-				if (alias !== null && !resolvingAliases.has(alias)) {
-					const nextSubstitutions = aliasSubstitutions(alias, current, substitutions);
-					if (nextSubstitutions !== null) {
-						const nextResolving = new Set(resolvingAliases);
-						nextResolving.add(alias);
-						return evaluate(alias.typeAnnotation, nextSubstitutions, nextResolving);
-					}
+			if (Option.isSome(name)) {
+				const substitution = substitutions.get(name.value);
+				if (Predicate.isNotUndefined(substitution) && !current.typeArguments?.params.length) return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
+				const expansion = Option.flatMap(Option.filter(visibleTypeAlias(name.value, current, environment), (alias) => !resolvingAliases.has(alias)), (alias) => Option.map(aliasSubstitutions(alias, current, substitutions), (next) => ({
+					alias,
+					next
+				})));
+				if (Option.isSome(expansion)) {
+					const { alias, next } = expansion.value;
+					const nextResolving = new Set(resolvingAliases);
+					nextResolving.add(alias);
+					return evaluate(alias.typeAnnotation, next, nextResolving);
 				}
 			}
 		}

package/dist/rules/_ast-ancestors.js

@@ -0,0 +1,14 @@
+import * as Option from "effect/Option";
+//#region src/rules/_ast-ancestors.ts
+/** The node's parent, or none at the Program root. */
+const parentOf = (node) => Option.fromNullishOr(node.parent);
+/** The node's ancestors, nearest first, ending at the Program root. */
+function* ancestors(node) {
+	let current = parentOf(node);
+	while (Option.isSome(current)) {
+		yield current.value;
+		current = parentOf(current.value);
+	}
+}
+//#endregion
+export { ancestors, parentOf };

package/dist/rules/_ast-children.js

@@ -0,0 +1,18 @@
+import * as Predicate from "effect/Predicate";
+//#region src/rules/_ast-children.ts
+/**
+* Child-node access by property name, for AST walkers driven by visitor keys
+* or object keys. Reads through the property descriptor, so no walker has to
+* view a node as an open dictionary.
+*/
+/** Whether a value is an AST node: an object whose `type` is a string. */
+const isAstNode = (value) => Predicate.hasProperty(value, "type") && Predicate.isString(value.type);
+/** The nodes held at `node[key]`: the node itself, the nodes of an array, or none. */
+const childNodesAt = (node, key, isNode) => {
+	const value = Object.getOwnPropertyDescriptor(node, key)?.value;
+	if (isNode(value)) return [value];
+	if (Array.isArray(value)) return value.filter(isNode);
+	return [];
+};
+//#endregion
+export { childNodesAt, isAstNode };

package/dist/rules/_call-arguments.js

@@ -0,0 +1,11 @@
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+//#region src/rules/_call-arguments.ts
+const isExpression = (argument) => argument.type !== "SpreadElement";
+/** The call's argument at `index`, or none when it is missing or spread. */
+const expressionArgument = (node, index) => Option.filter(Arr.get(node.arguments, index), isExpression);
+const isStaticProperty = (property, name) => property.type === "Property" && !property.computed && (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name);
+/** Every non-computed property of an object literal named `name`, in source order. */
+const staticProperties = (node, name) => node.properties.filter((property) => isStaticProperty(property, name));
+//#endregion
+export { expressionArgument, staticProperties };

package/dist/rules/_effect-context.js

@@ -1,27 +1,32 @@
+import { ancestors } from "./_ast-ancestors.js";
 import { isStaticCall, isStaticMember } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
 //#region src/rules/_effect-context.ts
-const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+/** `Effect.gen(...)`, `Effect.fn(...)`, or `Effect.fnUntraced(...)` called with the program directly. */
+const directProgramKind = (callee, effectNamespaces) => {
+	if (isStaticMember(callee, effectNamespaces, "gen")) return Option.some("gen");
+	if (isStaticMember(callee, effectNamespaces, "fn")) return Option.some("fn");
+	if (isStaticMember(callee, effectNamespaces, "fnUntraced")) return Option.some("fnUntraced");
+	return Option.none();
+};
+/** `Effect.fn("name")(...)` or `Effect.fnUntraced(options)(...)` called with the program. */
+const curriedProgramKind = (callee, effectNamespaces) => {
+	if (isStaticCall(callee, effectNamespaces, "fn")) return Option.some("fn");
+	if (isStaticCall(callee, effectNamespaces, "fnUntraced")) return Option.some("fnUntraced");
+	return Option.none();
+};
+/** The kind of Effect program a function is the body of, when it is an argument of one. */
 const effectProgramKind = (node, effectNamespaces) => {
 	const parent = node.parent;
-	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return void 0;
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "gen")) return "gen";
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fn")) return "fn";
-	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
-	if (parent.callee.type !== "CallExpression") return void 0;
-	if (isStaticCall(parent.callee, effectNamespaces, "fn")) return "fn";
-	if (isStaticCall(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
-};
-const enclosingEffectProgram = (node, effectNamespaces) => {
-	let current = node.parent;
-	while (current !== void 0 && current !== null) {
-		if (isFunction(current)) {
-			const kind = effectProgramKind(current, effectNamespaces);
-			if (kind === void 0) return void 0;
-			return [current, kind];
-		}
-		current = current.parent;
-	}
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return Option.none();
+	const callee = parent.callee;
+	if (callee.type === "Super") return Option.none();
+	return Option.orElse(directProgramKind(callee, effectNamespaces), () => curriedProgramKind(callee, effectNamespaces));
 };
-const isInsideEffectProgram = (node, effectNamespaces) => enclosingEffectProgram(node, effectNamespaces) !== void 0;
+/** The nearest enclosing function, when it is the body of an Effect program. */
+const enclosingEffectProgram = (node, effectNamespaces) => Option.flatMap(Arr.findFirst(ancestors(node), isFunction), (program) => Option.map(effectProgramKind(program, effectNamespaces), (kind) => [program, kind]));
+const isInsideEffectProgram = (node, effectNamespaces) => Option.isSome(enclosingEffectProgram(node, effectNamespaces));
 //#endregion
 export { enclosingEffectProgram, isInsideEffectProgram };

package/dist/rules/_function-metrics.js

@@ -1,5 +1,9 @@
+import { childNodesAt, isAstNode } from "./_ast-children.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/rules/_function-metrics.ts
-const isNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const isNode = (value) => isAstNode(value);
 const isFunctionType = (type) => type === "ArrowFunctionExpression" || type === "FunctionDeclaration" || type === "FunctionExpression";
 const isFunctionNode = (node) => isFunctionType(node.type);
 /** Slots that hold the parent link, source positions, or type-level syntax. */
@@ -26,12 +30,7 @@ const transparentTypeWrappers = new Set([
 	"TSInstantiationExpression"
 ]);
 const isTypeOnly = (node) => node.type.startsWith("TS") && !transparentTypeWrappers.has(node.type);
-const slot = (node, key) => {
-	const value = node[key];
-	if (isNode(value)) return [value];
-	if (Array.isArray(value)) return value.filter(isNode);
-	return [];
-};
+const slot = (node, key) => childNodesAt(node, key, isNode);
 /** Runtime child nodes of `node`, in source order of their slots. */
 const children = (node) => {
 	if (transparentTypeWrappers.has(node.type)) return slot(node, "expression");
@@ -44,8 +43,7 @@ const children = (node) => {
 };
 /** The nodes that form the body of a function unit: its parameters and its body. */
 const unitRoots = (fn) => {
-	const node = fn;
-	return [...slot(node, "params"), ...slot(node, "body")];
+	return [...slot(fn, "params"), ...slot(fn, "body")];
 };
 /**
 * Flatten a logical expression tree into its operator sequence, left to right.
@@ -81,7 +79,8 @@ const cognitiveComplexity = (fn) => {
 		for (const child of slot(node, key)) visit(child, nesting);
 	};
 	const visitIf = (node, nesting, isElseIf) => {
-		total += isElseIf ? 1 : 1 + nesting;
+		total += 1;
+		if (!isElseIf) total += nesting;
 		visitSlot(node, "test", nesting);
 		visitSlot(node, "consequent", nesting + 1);
 		for (const alternate of slot(node, "alternate")) if (alternate.type === "IfStatement") visitIf(alternate, nesting, true);
@@ -140,19 +139,30 @@ const halsteadDifficulty = (counts) => {
 };
 const functionOperator = (node) => {
 	if (node.type === "ArrowFunctionExpression") return "=>";
-	return node.generator === true ? "function*" : "function";
+	if (node.generator === true) return "function*";
+	return "function";
 };
 const literalOperand = (node) => {
-	if (typeof node.raw === "string") return node.raw;
-	if (typeof node.bigint === "string") return `${node.bigint}n`;
+	if (Predicate.isString(node.raw)) return node.raw;
+	if (Predicate.isString(node.bigint)) return `${node.bigint}n`;
 	return String(node.value);
 };
+const isNonEmpty = (text) => text.length > 0;
 const templateOperand = (node) => {
 	const value = node.value;
-	if (typeof value !== "object" || value === null) return null;
-	const raw = value.raw;
-	return typeof raw === "string" && raw.length > 0 ? raw : null;
+	if (!Predicate.hasProperty(value, "raw") || !Predicate.isString(value.raw)) return Option.none();
+	return Option.liftPredicate(value.raw, isNonEmpty);
+};
+/** `tokens` when `present`, otherwise none: the operator tokens of an optional clause. */
+const tokensIf = (present, ...tokens) => {
+	if (!present) return [];
+	return tokens;
 };
+/** The `name` of the node held in a slot, or empty when the slot holds none. */
+const slotName = (node, key) => Option.match(Arr.head(slot(node, key)), {
+	onNone: () => "",
+	onSome: (child) => String(child.name)
+});
 /** Node types that always stand for the same operator tokens. */
 const fixedOperators = new Map([
 	["ForStatement", ["for"]],
@@ -195,35 +205,47 @@ const operatorCarriers = new Set([
 /** Statement-level nodes whose operator tokens depend on the node's shape. */
 const statementOperators = (node) => {
 	switch (node.type) {
-		case "IfStatement": return isNode(node.alternate) ? ["if", "else"] : ["if"];
-		case "ForOfStatement": return node.await === true ? ["for-await-of"] : ["for-of"];
-		case "SwitchCase": return isNode(node.test) ? ["case"] : ["default"];
-		case "TryStatement": return isNode(node.finalizer) ? ["try", "finally"] : ["try"];
+		case "IfStatement": return ["if", ...tokensIf(isNode(node.alternate), "else")];
+		case "ForOfStatement":
+			if (node.await === true) return ["for-await-of"];
+			return ["for-of"];
+		case "SwitchCase":
+			if (isNode(node.test)) return ["case"];
+			return ["default"];
+		case "TryStatement": return ["try", ...tokensIf(isNode(node.finalizer), "finally")];
 		case "VariableDeclaration": return [String(node.kind)];
-		case "VariableDeclarator": return isNode(node.init) ? ["="] : [];
+		case "VariableDeclarator": return tokensIf(isNode(node.init), "=");
 		case "ClassDeclaration":
-		case "ClassExpression": return isNode(node.superClass) ? ["class", "extends"] : ["class"];
-		case "PropertyDefinition": return isNode(node.value) ? ["="] : [];
+		case "ClassExpression": return ["class", ...tokensIf(isNode(node.superClass), "extends")];
+		case "PropertyDefinition": return tokensIf(isNode(node.value), "=");
 		default: return [];
 	}
 };
+/** `?.` calls and accesses carry a leading `?`. */
+const optionalMark = (node) => {
+	if (node.optional === true) return "?";
+	return "";
+};
+const memberAccess = (node) => {
+	if (node.computed === true) return "[]";
+	return ".";
+};
 /** Expression-level nodes whose operator tokens depend on the node's shape. */
 const expressionOperators = (node) => {
 	if (operatorCarriers.has(node.type)) return [String(node.operator)];
 	switch (node.type) {
-		case "CallExpression": return node.optional === true ? ["?.()"] : ["()"];
-		case "MemberExpression": {
-			const access = node.computed === true ? "[]" : ".";
-			return node.optional === true ? [`?${access}`] : [access];
-		}
+		case "CallExpression": return [`${optionalMark(node)}()`];
+		case "MemberExpression": return [`${optionalMark(node)}${memberAccess(node)}`];
 		case "Property":
 			if (node.kind === "get" || node.kind === "set") return [String(node.kind)];
-			return node.shorthand === true || node.method === true ? [] : [":"];
-		case "YieldExpression": return node.delegate === true ? ["yield*"] : ["yield"];
-		case "JSXAttribute": return isNode(node.value) ? ["="] : [];
+			return tokensIf(node.shorthand !== true && node.method !== true, ":");
+		case "YieldExpression":
+			if (node.delegate === true) return ["yield*"];
+			return ["yield"];
+		case "JSXAttribute": return tokensIf(isNode(node.value), "=");
 		case "ArrowFunctionExpression":
 		case "FunctionDeclaration":
-		case "FunctionExpression": return node.async === true ? ["async", functionOperator(node)] : [functionOperator(node)];
+		case "FunctionExpression": return [...tokensIf(node.async === true, "async"), functionOperator(node)];
 		default: return [];
 	}
 };
@@ -237,18 +259,15 @@ const operatorsOf = (node) => [
 const operandOf = (node) => {
 	switch (node.type) {
 		case "Identifier":
-		case "JSXIdentifier": return String(node.name);
-		case "PrivateIdentifier": return `#${String(node.name)}`;
-		case "Literal": return literalOperand(node);
+		case "JSXIdentifier": return Option.some(String(node.name));
+		case "PrivateIdentifier": return Option.some(`#${String(node.name)}`);
+		case "Literal": return Option.some(literalOperand(node));
 		case "TemplateElement": return templateOperand(node);
-		case "ThisExpression": return "this";
-		case "Super": return "super";
-		case "MetaProperty": return `${isNode(node.meta) ? String(node.meta.name) : ""}.${isNode(node.property) ? String(node.property.name) : ""}`;
-		case "JSXText": {
-			const text = String(node.value).trim();
-			return text.length > 0 ? text : null;
-		}
-		default: return null;
+		case "ThisExpression": return Option.some("this");
+		case "Super": return Option.some("super");
+		case "MetaProperty": return Option.some(`${slotName(node, "meta")}.${slotName(node, "property")}`);
+		case "JSXText": return Option.liftPredicate(String(node.value).trim(), isNonEmpty);
+		default: return Option.none();
 	}
 };
 /**
@@ -266,7 +285,7 @@ const halstead = (fn) => {
 		if (isTypeOnly(node)) return;
 		for (const operator of operatorsOf(node)) tally(operators, operator);
 		const operand = operandOf(node);
-		if (operand !== null) tally(operands, operand);
+		if (Option.isSome(operand)) tally(operands, operand.value);
 		if (isFunctionType(node.type) || node.type === "MetaProperty") return;
 		for (const child of children(node)) visit(child);
 	};