@deslop/coding-standards 0.1.1242 → 0.1.1243

package/README.md

@@ -21,7 +21,7 @@ export default defineConfig({lint: {extends: [lint]}})
 {
 	"scripts": {
 		"prepare": "effect-tsgo patch --no-typescript --tsrs",
-		"typecheck": "tsrs --noEmit --checkerAssignment go",
+		"typecheck": "tsrs --checkerAssignment go --pretty false",
 		"check": "vp check && vp run typecheck"
 	}
 }

package/dist/install.js

@@ -27604,7 +27604,7 @@ const runWith = (command, config) => {
 	}, ({ error, userMessage }) => andThen(showUserError(error, userMessage), fail$3(error))), catchFilter((e) => isQuitError(e) ? succeed$6(e) : fail$8(e), (_) => interrupt$1));
 };
 // package.json
-var version = "0.1.1242";
+var version = "0.1.1243";
 // src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {
 	const fs = yield* FileSystem;

package/dist/lint.js

@@ -1,4 +1,4 @@
-import { $ as join, A as dedupe, At as all, B as findFirstIndex, Br as isRegExp, Bt as getOrElse, C as TaggedError, D as contains, E as appendAll, Er as hasProperty, F as ensure, Fr as isNullish, Ft as firstSomeOf, Gr as constFalse, Gt as liftThrowable, H as flatMap, Ht as isNone, I as every, Ir as isNumber$1, It as flatMap$1, J as head, Jr as constVoid, Jt as none, K as get$3, Kt as map$1, L as filter$1, Lt as flatten$1, M as drop, Mr as isNotNull, Mt as contains$1, N as dropRight, Nr as isNotNullish, Nt as exists, O as containsWith, Or as isBoolean, P as empty$2, Pt as filter, Q as isReadonlyArrayNonEmpty, Qt as zipWith, R as filterMap, Rt as fromNullishOr, Sr as string, St as fromOption, T as append, Tr as symbol$1, U as flatten, Ut as isSome, Vr as isString, Vt as getOrUndefined, W as forEach, Wt as liftPredicate, X as isArrayNonEmpty, Xr as dual, Xt as some, Y as isArrayEmpty, Yt as orElse, Zt as toArray$1, _ as toUpperCase, ar as format, at as of, b as parse, br as number, c as Order, ct as some$1, d as match$1, dt as takeWhile, ei as pipe, et as last, f as matchAll, ft as zip, g as startsWith, gr as symbol, h as split, hr as equals, ht as has$2, i as make$2, it as matchRight, j as dedupeWith, jt as as, k as countBy, l as includes, lt as sort, m as slice, mr as byReferenceUnsafe, mt as get$2, n as append$1, nr as NodeInspectSymbol, nt as map, ot as prepend, p as replaceAll, pt as fromEntries, q as getSomes, qt as match, ri as pipeArguments, rr as toJson, s as toArray, t as match$2, u as isNonEmpty, un as strictEqual, ut as take, v as trim, vr as combine, vt as mapEntries, xr as optimize, yr as hash, z as findFirst, zt as fromUndefinedOr } from "./Boolean-C8Zb2yak.mjs";
+import { $ as join, A as dedupe, At as all, B as findFirstIndex, Br as isRegExp, Bt as getOrElse, C as TaggedError, D as contains, E as appendAll, Er as hasProperty, F as ensure, Fr as isNullish, Ft as firstSomeOf, Gr as constFalse, Gt as liftThrowable, H as flatMap, Ht as isNone, I as every, Ir as isNumber$1, It as flatMap$1, J as head, Jr as constVoid, Jt as none, K as get$3, Kt as map, L as filter$1, Lt as flatten$1, M as drop, Mr as isNotNull, Mt as contains$1, N as dropRight, Nr as isNotNullish, Nt as exists, O as containsWith, Or as isBoolean, P as empty$2, Pt as filter, Q as isReadonlyArrayNonEmpty, Qt as zipWith, R as filterMap, Rt as fromNullishOr, Sr as string, St as fromOption, T as append, Tr as symbol$1, U as flatten, Ut as isSome, Vr as isString, Vt as getOrUndefined, W as forEach, Wt as liftPredicate, X as isArrayNonEmpty, Xr as dual, Xt as some, Y as isArrayEmpty, Yt as orElse, Zt as toArray$1, _ as toUpperCase, ar as format, at as of, b as parse, br as number, c as Order, ct as some$1, d as match$1, dt as takeWhile, ei as pipe, et as last, f as matchAll, ft as zip, g as startsWith, gr as symbol, h as split, hr as equals, ht as has$2, i as make$2, it as matchRight, j as dedupeWith, jt as as, k as countBy, l as includes, lt as sort, m as slice, mr as byReferenceUnsafe, mt as get$2, n as append$1, nr as NodeInspectSymbol, nt as map$1, ot as prepend, p as replaceAll, pt as fromEntries, q as getSomes, qt as match, ri as pipeArguments, rr as toJson, s as toArray, t as match$2, u as isNonEmpty, un as strictEqual, ut as take, v as trim, vr as combine, vt as mapEntries, xr as optimize, yr as hash, z as findFirst, zt as fromUndefinedOr } from "./Boolean-C8Zb2yak.mjs";
 import { definePlugin, defineRule } from "vite-plus/lint/plugins";
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/MutableHashMap.js
 const TypeId$2 = "~effect/MutableHashMap";
@@ -962,6 +962,12 @@ function variableFromScope(input) {
 function boundVariable(input) {
 	return filter(variableFromScope(input), (variable) => isArrayNonEmpty(variable.defs) || isArrayNonEmpty(variable.references));
 }
+function readsOf(input) {
+	return pipe(variableFromScope({
+		name: input.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())));
+}
 function variableFor(context, node) {
 	return variableFromScope({
 		name: node.name,
@@ -971,7 +977,7 @@ function variableFor(context, node) {
 const importedNames = /* @__PURE__ */ new WeakMap();
 function importNames(statements) {
 	return flatMap(statements, (statement) => {
-		if (statement.type === "ImportDeclaration") return map(statement.specifiers, (specifier) => specifier.local.name);
+		if (statement.type === "ImportDeclaration") return map$1(statement.specifiers, (specifier) => specifier.local.name);
 		if (statement.type === "TSModuleDeclaration" && statement.body?.type === "TSModuleBlock") return importNames(statement.body.body);
 		return [];
 	});
@@ -1004,8 +1010,8 @@ function effectImport(input) {
 	}), filter((variable) => isArrayNonEmpty(variable.defs)), match({
 		onNone: () => pipe(input.context.sourceCode.ast.body, findFirst((statement) => statement.type === "ImportDeclaration" && statement.source.value === "effect" && statement.importKind !== "type" && every(statement.specifiers, (specifier) => specifier.type === "ImportSpecifier")), flatMap$1((statement) => {
 			if (statement.type !== "ImportDeclaration") return none();
-			return pipe(findFirst(statement.specifiers, (specifier) => Order(importedName(specifier), input.name) > 0), map$1((specifier) => input.fixer.insertTextBefore(specifier, `${input.name}, `)), orElse(() => map$1(last(statement.specifiers), (specifier) => input.fixer.insertTextAfter(specifier, `, ${input.name}`))));
-		}), orElse(() => map$1(findFirst(input.context.sourceCode.ast.body, (statement) => statement.type !== "ExpressionStatement" || isNullish(statement.directive)), (statement) => input.fixer.insertTextBefore(statement, `import {${input.name}} from 'effect'\n`))), map$1(of)),
+			return pipe(findFirst(statement.specifiers, (specifier) => Order(importedName(specifier), input.name) > 0), map((specifier) => input.fixer.insertTextBefore(specifier, `${input.name}, `)), orElse(() => map(last(statement.specifiers), (specifier) => input.fixer.insertTextAfter(specifier, `, ${input.name}`))));
+		}), orElse(() => map(findFirst(input.context.sourceCode.ast.body, (statement) => statement.type !== "ExpressionStatement" || isNullish(statement.directive)), (statement) => input.fixer.insertTextBefore(statement, `import {${input.name}} from 'effect'\n`))), map(of)),
 		onSome: (variable) => liftPredicate(empty$2(), () => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "effect" && definition.parent.importKind !== "type" && definition.node.type === "ImportSpecifier" && definition.node.importKind !== "type" && definition.node.imported.type === "Identifier" && definition.node.imported.name === input.name))
 	}));
 }
@@ -1066,11 +1072,11 @@ function chainOf(node) {
 		members: [],
 		root: node
 	});
-	if (node.type === "MemberExpression") return flatMap$1(memberName(node), (name) => map$1(chainOf(node.object), (chain) => ({
+	if (node.type === "MemberExpression") return flatMap$1(memberName(node), (name) => map(chainOf(node.object), (chain) => ({
 		...chain,
 		members: append(chain.members, name)
 	})));
-	if (node.type === "CallExpression") return map$1(chainOf(node.callee), (chain) => ({
+	if (node.type === "CallExpression") return map(chainOf(node.callee), (chain) => ({
 		...chain,
 		calls: append(chain.calls, node)
 	}));
@@ -1133,7 +1139,7 @@ function propertyKey(property) {
 }
 function optionKeys(node) {
 	if (node.type !== "ObjectExpression") return empty$2();
-	return getSomes(map(node.properties, propertyKey));
+	return getSomes(map$1(node.properties, propertyKey));
 }
 function isTestClockMember(context, node, propertyName) {
 	return node.type === "MemberExpression" && node.object.type === "Identifier" && contains$1(memberName(node), propertyName) && isImportBinding({
@@ -1165,6 +1171,14 @@ function importedMember(input) {
 		source: "effect"
 	});
 }
+function effectMethod(input) {
+	if (input.node.callee.type !== "MemberExpression" || !importedMember({
+		context: input.context,
+		importedName: "Effect",
+		node: input.node.callee
+	})) return none();
+	return memberName(input.node.callee);
+}
 function isWriteTarget(node) {
 	if (node.parent === null) return false;
 	return (node.parent.type === "AssignmentExpression" || node.parent.type === "AssignmentPattern") && node.parent.left === node || node.parent.type === "ArrayPattern" || node.parent.type === "RestElement" || node.parent.type === "Property" && node.parent.value === node && node.parent.parent.type === "ObjectPattern" || (node.parent.type === "ForInStatement" || node.parent.type === "ForOfStatement") && node.parent.left === node || node.parent.type === "UpdateExpression" || node.parent.type === "UnaryExpression" && node.parent.operator === "delete";
@@ -1266,12 +1280,12 @@ function suspendedTypeName(input) {
 }
 function memberType(member) {
 	if (member.type === "TSIndexSignature") return some(member.typeAnnotation.typeAnnotation);
-	if (member.type === "TSPropertySignature") return map$1(fromNullishOr(member.typeAnnotation), (annotation) => annotation.typeAnnotation);
-	return map$1(fromNullishOr(member.returnType), (annotation) => annotation.typeAnnotation);
+	if (member.type === "TSPropertySignature") return map(fromNullishOr(member.typeAnnotation), (annotation) => annotation.typeAnnotation);
+	return map(fromNullishOr(member.returnType), (annotation) => annotation.typeAnnotation);
 }
 function referencedTypeNames(node) {
 	if (node.type === "TSTypeReference") {
-		const argumentNames = pipe(fromNullishOr(node.typeArguments), map$1((typeArguments) => pipe(typeArguments.params, flatMap(referencedTypeNames))), getOrElse(() => empty$2()));
+		const argumentNames = pipe(fromNullishOr(node.typeArguments), map((typeArguments) => pipe(typeArguments.params, flatMap(referencedTypeNames))), getOrElse(() => empty$2()));
 		if (node.typeName.type !== "Identifier") return argumentNames;
 		return prepend(argumentNames, node.typeName.name);
 	}
@@ -1293,8 +1307,8 @@ function referencedTypeNames(node) {
 		node.constraint,
 		node.nameType,
 		node.typeAnnotation
-	], map((child) => fromNullishOr(child)), getSomes, flatMap(referencedTypeNames));
-	if (node.type === "TSTypeLiteral") return pipe(node.members, map(memberType), getSomes, flatMap(referencedTypeNames));
+	], map$1((child) => fromNullishOr(child)), getSomes, flatMap(referencedTypeNames));
+	if (node.type === "TSTypeLiteral") return pipe(node.members, map$1(memberType), getSomes, flatMap(referencedTypeNames));
 	return empty$2();
 }
 function isNode(value) {
@@ -1379,12 +1393,12 @@ function schemaEdges(context, statement) {
 function schemaCycleNames(input) {
 	if (isArrayEmpty(input.seeds) || !some$1(input.program.body, (statement) => statement.type === "ImportDeclaration" && statement.source.value === "effect" && some$1(statement.specifiers, (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "Schema"))) return empty$2();
 	const edges = pipe(input.program.body, flatMap((statement) => schemaEdges(input.context, statement)));
-	const names = pipe(edges, map((edge) => edge.name), dedupe);
+	const names = pipe(edges, map$1((edge) => edge.name), dedupe);
 	const graph = directed((mutable) => {
-		const indices = fromEntries(map(names, (name) => [name, addNode(mutable, name)]));
+		const indices = fromEntries(map$1(names, (name) => [name, addNode(mutable, name)]));
 		for (const edge of edges) for (const target of edge.targets) zipWith(get$2(indices, edge.name), get$2(indices, target), (source, sink) => addEdge(mutable, source, sink, "reads"));
 	});
-	return pipe(stronglyConnectedComponents(graph), map((component) => getSomes(map(component, (index) => getNode(graph, index)))), filter$1((component) => (component.length > 1 || some$1(edges, (edge) => contains(component, edge.name) && contains(edge.targets, edge.name))) && some$1(component, (name) => contains(input.seeds, name))), flatten);
+	return pipe(stronglyConnectedComponents(graph), map$1((component) => getSomes(map$1(component, (index) => getNode(graph, index)))), filter$1((component) => (component.length > 1 || some$1(edges, (edge) => contains(component, edge.name) && contains(edge.targets, edge.name))) && some$1(component, (name) => contains(input.seeds, name))), flatten);
 }
 function suspends(context, node) {
 	if (node.type === "YieldExpression" || node.type === "AwaitExpression") return true;
@@ -1432,12 +1446,16 @@ function bindingName(node) {
 	if (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier") return some(node.parent.id.name);
 	return none();
 }
+function boundReads(input) {
+	return pipe(bindingName(input.node), flatMap$1((name) => readsOf({
+		context: input.context,
+		name,
+		node: input.node
+	})));
+}
 function singleUseThunk(input) {
 	if (isReadonlyArrayNonEmpty(input.node.params) || input.node.typeParameters !== null || !hasSingleStatementExpression(input.node)) return false;
-	return pipe(bindingName(input.node), flatMap$1((name) => variableFromScope({
-		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), exists((variable) => countBy(variable.references, (reference) => reference.isRead()) === 1));
+	return exists(boundReads(input), (reads) => reads.length === 1);
 }
 // src/rules/explicit-effect-concurrency.ts
 function statesConcurrency(node) {
@@ -1477,13 +1495,11 @@ function isFunction(context, node) {
 }
 const explicitEffectConcurrency = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression") return;
-		const name = memberName(node.callee);
-		if (!exists(name, (method) => method === "all" || method === "forEach") || !importedMember({
+		const name = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
+			node
+		});
+		if (!exists(name, (method) => method === "all" || method === "forEach")) return;
 		const index = match$2(contains$1(name, "all") || isFunction(context, node.arguments[0]) || node.arguments[1]?.type === "ObjectExpression", {
 			onFalse: () => 2,
 			onTrue: () => 1
@@ -1622,14 +1638,14 @@ function check$3(input) {
 	}
 	if (!isConstantName(input.found.id.name)) {
 		const name = pipe(input.found.id.name, replaceAll(/(?<=[a-z0-9])(?=[A-Z])/gu, "_"), toUpperCase);
-		const taken = some$1([input.found.id, ...map(input.variable.references, (reference) => reference.identifier)], (node) => isSome(variableFromScope({
+		const taken = some$1([input.found.id, ...map$1(input.variable.references, (reference) => reference.identifier)], (node) => isSome(variableFromScope({
 			name,
 			scope: input.context.sourceCode.getScope(node)
 		})));
 		input.context.report({
 			fix: (fixer) => {
 				if (taken) return [];
-				return [fixer.replaceTextRange([input.found.id.range[0], input.found.id.range[0] + input.found.id.name.length], name), ...pipe(input.variable.references, filter$1((reference) => reference.identifier !== input.found.id), map((reference) => renamed({
+				return [fixer.replaceTextRange([input.found.id.range[0], input.found.id.range[0] + input.found.id.name.length], name), ...pipe(input.variable.references, filter$1((reference) => reference.identifier !== input.found.id), map$1((reference) => renamed({
 					fixer,
 					name,
 					reference
@@ -1646,11 +1662,11 @@ function check$3(input) {
 }
 const moduleConstant = defineRule({
 	create: (context) => ({ Program: (program) => {
-		const leadingEnd = pipe(program.body, takeWhile((statement) => statement.type === "ImportDeclaration" || isSome(literalConstant(statement))), last, map$1((statement) => statement.range[1]), getOrElse(() => 0));
+		const leadingEnd = pipe(program.body, takeWhile((statement) => statement.type === "ImportDeclaration" || isSome(literalConstant(statement))), last, map((statement) => statement.range[1]), getOrElse(() => 0));
 		for (const statement of program.body) pipe(literalConstant(statement), flatMap$1((found) => pipe(variableFromScope({
 			name: found.id.name,
 			scope: context.sourceCode.getScope(found.node)
-		}), filter((variable) => !some$1(variable.references, (reference) => reference.identifier.parent.type === "ExportSpecifier")), map$1((variable) => ({
+		}), filter((variable) => !some$1(variable.references, (reference) => reference.identifier.parent.type === "ExportSpecifier")), map((variable) => ({
 			found,
 			variable
 		})))), match({
@@ -1670,7 +1686,7 @@ const moduleConstant = defineRule({
 // src/rules/motion-limits.ts
 const MOTION_UTILITY = /duration-|zoom-|scale-/u;
 function amount(token, pattern) {
-	return pipe(token, match$1(pattern), flatMap$1((match) => fromNullishOr(match[1])), map$1((value) => pipe(parse(value), getOrElse(() => 0))));
+	return pipe(token, match$1(pattern), flatMap$1((match) => fromNullishOr(match[1])), map((value) => pipe(parse(value), getOrElse(() => 0))));
 }
 function violation(token) {
 	const name = pipe(token, split(":"), last, getOrElse(() => token), replaceAll(/^!|!$/gu, ""));
@@ -1681,7 +1697,7 @@ function violation(token) {
 }
 function check$2(context, node, text) {
 	if (!MOTION_UTILITY.test(text)) return;
-	pipe(split(text, /\s+/u), findFirst(violation), map$1((message) => context.report({
+	pipe(split(text, /\s+/u), findFirst(violation), map((message) => context.report({
 		message,
 		node
 	})));
@@ -1776,8 +1792,8 @@ const noAccumulatingCopy = defineRule({
 			pipe(variableFromScope({
 				name: parameter.name,
 				scope: context.sourceCode.getScope(callback)
-			}), map$1((variable) => {
-				for (const reference of variable.references) pipe(copySite(context, reference.identifier), filter((copy) => !has(reported, copy.range[0])), map$1((copy) => {
+			}), map((variable) => {
+				for (const reference of variable.references) pipe(copySite(context, reference.identifier), filter((copy) => !has(reported, copy.range[0])), map((copy) => {
 					add(reported, copy.range[0]);
 					context.report({
 						message: "Copying the accumulator in a fold can make collection building quadratic. Prefer Array.map/filterMap/flatMap/groupBy, Record.fromEntries, Array.mapAccum, or a local MutableList/MutableHashMap collector.",
@@ -1850,10 +1866,7 @@ const noComponentAtomAllocation = defineRule({
 function isConstantFunction(input) {
 	if (input.node.async || input.node.generator || isArrayNonEmpty(input.node.params) || isNotNullish(input.node.typeParameters)) return false;
 	const returned = returnedExpression(input.node);
-	return isNotNullish(returned) && (returned.type === "Literal" && !hasProperty(returned, "regex") || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions)) && pipe(bindingName(input.node), flatMap$1((name) => variableFromScope({
-		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), exists((variable) => every(filter$1(variable.references, (reference) => reference.isRead()), (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier)));
+	return isNotNullish(returned) && (returned.type === "Literal" && !hasProperty(returned, "regex") || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions)) && exists(boundReads(input), (reads) => every(reads, (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier));
 }
 function isConstBound(node) {
 	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.kind === "const";
@@ -2041,7 +2054,7 @@ function operands(input) {
 function comparedNullish(input) {
 	if (input.node.type !== "BinaryExpression" || input.node.operator !== input.operator) return none();
 	const subject = input.node.left;
-	return map$1(nullishOperand({
+	return map(nullishOperand({
 		context: input.context,
 		node: input.node.right
 	}), (nullish) => ({
@@ -2059,7 +2072,7 @@ function guardCall(input) {
 		first: input.checks[0],
 		second: input.checks[1]
 	}) || input.context.sourceCode.getTokensBetween(input.checks[0].node, input.checks[1].node).length !== 1) return none();
-	return map$1(effectImport({
+	return map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Predicate",
@@ -2071,7 +2084,7 @@ const noDoubleNullishCheck = defineRule({
 		if (node.operator === "??") return;
 		if (node.parent.type === "LogicalExpression" && node.parent.operator === node.operator) return;
 		const variant = VARIANTS[node.operator];
-		const checks = map(operands({
+		const checks = map$1(operands({
 			node,
 			operator: node.operator
 		}), (operand) => comparedNullish({
@@ -2114,7 +2127,7 @@ function generator(context, node) {
 		propertyName: "gen"
 	}) || node.arguments.length !== 1) return none();
 	const effect = node.callee.object;
-	return pipe(head(node.arguments), filter((argument) => argument.type === "FunctionExpression" && argument.generator && !argument.async && argument.id === null && isArrayEmpty(argument.params) && argument.body !== null && isNone(match$1(/\b(?:arguments|this)\b/u)(context.sourceCode.getText(argument.body)))), map$1((body) => ({
+	return pipe(head(node.arguments), filter((argument) => argument.type === "FunctionExpression" && argument.generator && !argument.async && argument.id === null && isArrayEmpty(argument.params) && argument.body !== null && isNone(match$1(/\b(?:arguments|this)\b/u)(context.sourceCode.getText(argument.body)))), map((body) => ({
 		body,
 		effect
 	})));
@@ -2227,12 +2240,10 @@ function recoversEmpty(context, name, node) {
 }
 const noEmptyRecovery = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const name = pipe(effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		const name = pipe(memberName(node.callee), getOrElse(() => ""));
+			node
+		}), getOrElse(() => ""));
 		if (!pipe(name, startsWith("catch")) && !pipe(name, startsWith("orElse"))) return;
 		for (const argument of node.arguments) {
 			const callback = resolveBinding(context, argument);
@@ -2329,17 +2340,16 @@ function inspectPredicate(context, node) {
 }
 const noErrorMessageControlFlow = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const method = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		if (contains$1(memberName(node.callee), "catchIf")) {
+			node
+		});
+		if (contains$1(method, "catchIf")) {
 			if (node.arguments.length === 3) inspectPredicate(context, node.arguments[1]);
 			if (node.arguments.length === 2) inspectPredicate(context, node.arguments[0]);
 			return;
 		}
-		if (!contains$1(memberName(node.callee), "retry")) return;
+		if (!contains$1(method, "retry")) return;
 		for (const property of flatMap(node.arguments, (argument) => {
 			if (argument.type === "ObjectExpression") return argument.properties;
 			return [];
@@ -2504,7 +2514,7 @@ function check(input) {
 	}), check({
 		name: input.name,
 		node: input.node.right
-	})]), map$1(flatten));
+	})]), map(flatten));
 	if (input.node.type === "UnaryExpression" && input.node.operator === "!" && input.node.argument.type === "CallExpression" && input.node.argument.callee.type === "MemberExpression" && isSubject({
 		name: "Array",
 		node: input.node.argument.callee.object
@@ -2530,7 +2540,7 @@ function check(input) {
 		operator: input.node.operator,
 		other: input.node.left,
 		subject: input.node.right
-	})]), map$1(of));
+	})]), map(of));
 }
 function replaceableGuard(node) {
 	const predicate = node.returnType?.typeAnnotation;
@@ -2539,7 +2549,7 @@ function replaceableGuard(node) {
 	return pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
-	}), map$1((checks) => pipe(checks, sort(Order), join(" && "))), flatMap$1((key) => get$2({
+	}), map((checks) => pipe(checks, sort(Order), join(" && "))), flatMap$1((key) => get$2({
 		"!= null": "isNotNullish",
 		"!== null": "isNotNull",
 		"!== null && !Array.isArray && typeof === object": "isObject",
@@ -2564,7 +2574,7 @@ function replaceableGuard(node) {
 	}, key)));
 }
 function report$4(input) {
-	map$1(replaceableGuard(input.node), (guard) => input.context.report({
+	map(replaceableGuard(input.node), (guard) => input.context.report({
 		message: `Use Predicate.${guard} instead of this hand-written type guard.`,
 		node: input.node
 	}));
@@ -2637,7 +2647,7 @@ const PRIMITIVES = {
 const CONTROL_STYLE = /(?:^|:)(?:hover|focus|focus-visible|active):|(?:^|:)(?:rounded|shadow|ring)(?:-|$)|(?:^|:)p[blrtxy]?-(?!0$)|(?:^|:)bg-(?!transparent$)|(?:^|:)border(?:-[blrtxy])?$|(?:^|:)border-(?!0$|[blrtxy]-0$)/u;
 function classStrings(node) {
 	if (node.type === "Literal") return filter$1([node.value], isString);
-	if (node.type === "TemplateLiteral") return map(node.quasis, (quasi) => quasi.value.raw);
+	if (node.type === "TemplateLiteral") return map$1(node.quasis, (quasi) => quasi.value.raw);
 	if (node.type === "JSXExpressionContainer") return classStrings(node.expression);
 	if (node.type === "CallExpression") return flatMap(node.arguments, classStrings);
 	if (node.type === "ConditionalExpression") return flatMap([node.consequent, node.alternate], classStrings);
@@ -2649,8 +2659,8 @@ const noNativeControl = defineRule({
 	create: (context) => ({ JSXOpeningElement: (node) => {
 		if (node.name.type !== "JSXIdentifier") return;
 		const name = node.name.name;
-		map$1(get$2(PRIMITIVES, name), (primitive) => {
-			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map$1((attribute) => {
+		map(get$2(PRIMITIVES, name), (primitive) => {
+			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map((attribute) => {
 				if (attribute.type !== "JSXAttribute" || attribute.value === null) return empty$2();
 				return classStrings(attribute.value);
 			}), exists((values) => some$1(values, (value) => some$1(split(value, /\s+/u), matches(CONTROL_STYLE)))));
@@ -2674,7 +2684,7 @@ const noNativeEmptinessCheck = defineRule({
 			context,
 			node: node.left
 		})) return;
-		map$1(lengthTest(node), (test) => {
+		map(lengthTest(node), (test) => {
 			context.report({
 				message: `Use ${PREDICATES[test]}.`,
 				node
@@ -2770,10 +2780,10 @@ const noNativeMethodCall = defineRule({
 			"entries",
 			"keys",
 			"values"
-		], name) || isArrayEmpty(node.arguments)), flatMap$1((name) => pipe(get$2(REPLACEMENTS, name), map$1((replacement) => ({
+		], name) || isArrayEmpty(node.arguments)), flatMap$1((name) => pipe(get$2(REPLACEMENTS, name), map((replacement) => ({
 			name,
 			replacement
-		})))), map$1((method) => context.report({
+		})))), map((method) => context.report({
 			message: `Use ${method.replacement} instead of the native .${method.name}(); a third-party object's own method stays, with an inline disable naming it.`,
 			node: node.callee
 		})));
@@ -2900,8 +2910,8 @@ function receiverText(context, node) {
 function fix$5(input) {
 	const calls = chain(input.node);
 	if (!rewritable(input.context, calls)) return [];
-	const steps = filter$1(map(calls, (call) => argumentsText(input.context, call)), (text) => isNonEmpty(text));
-	return getOrElse(flatMap$1(head(calls), (innermost) => map$1(effectImport({
+	const steps = filter$1(map$1(calls, (call) => argumentsText(input.context, call)), (text) => isNonEmpty(text));
+	return getOrElse(flatMap$1(head(calls), (innermost) => map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "pipe",
@@ -3043,31 +3053,23 @@ const noPollingTest = defineRule({
 		}
 		return {
 			CallExpression: (node) => {
-				if (node.callee.type !== "MemberExpression") return;
-				const callee = node.callee;
-				if (importedMember({
+				const method = effectMethod({
 					context,
-					importedName: "Effect",
-					node: callee,
-					propertyName: "eventually"
-				})) {
+					node
+				});
+				if (contains$1(method, "eventually")) {
 					context.report({
 						message: MESSAGE$4,
 						node
 					});
 					return;
 				}
-				if (some$1([
+				if (exists(method, (name) => contains([
 					"repeat",
 					"repeatOrElse",
 					"retry",
 					"retryOrElse"
-				], (propertyName) => importedMember({
-					context,
-					importedName: "Effect",
-					node: callee,
-					propertyName
-				})) && (containsNode({
+				], name)) && (containsNode({
 					context,
 					matches: (child) => isWait(context, child),
 					node: pipedFrom(node),
@@ -3150,7 +3152,7 @@ function enclosed(input) {
 function needsAlias(input) {
 	if (input.declaration.parent.type !== "BlockStatement" || !contains(FUNCTIONS, input.declaration.parent.parent.type) || !pipe(input.declaration.parent.body, takeWhile((statement) => statement !== input.declaration), every((statement) => statement.type === "VariableDeclaration"))) return true;
 	const block = input.declaration.parent;
-	const paths = map(input.reads, (read) => ({
+	const paths = map$1(input.reads, (read) => ({
 		callback: enclosed({
 			block,
 			node: read,
@@ -3181,7 +3183,7 @@ function replacement(input) {
 	return input.text;
 }
 function report$3(input) {
-	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map((reference) => reference.identifier));
+	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map$1((reference) => reference.identifier));
 	const text = input.context.sourceCode.getText(input.init);
 	const aliasRequired = needsAlias({
 		context: input.context,
@@ -3232,7 +3234,7 @@ function report$3(input) {
 					node,
 					read
 				})) || !every(input.context.sourceCode.getTokensBetween(input.declaration, read), inert$1))) return [];
-				return [fixer.remove(input.declaration), ...map(reads, (read) => fixer.replaceText(read, replacement({
+				return [fixer.remove(input.declaration), ...map$1(reads, (read) => fixer.replaceText(read, replacement({
 					name: input.name,
 					read,
 					text
@@ -3320,7 +3322,7 @@ const noRedundantStateType = defineRule({
 			propertyName: "make"
 		})))) return;
 		if (isString(argument.value) && type?.type === "TSStringKeyword" || isNumber$1(argument.value) && type?.type === "TSNumberKeyword" || isBoolean(argument.value) && type?.type === "TSBooleanKeyword") context.report({
-			fix: (fixer) => toArray$1(map$1(fromNullishOr(node.typeArguments), (typeArguments) => fixer.remove(typeArguments))),
+			fix: (fixer) => toArray$1(map(fromNullishOr(node.typeArguments), (typeArguments) => fixer.remove(typeArguments))),
 			message: "Drop this state type; the initializer infers the same primitive type.",
 			node: type
 		});
@@ -3352,7 +3354,7 @@ function nullableType(input) {
 function removeNull(input) {
 	const before = input.context.sourceCode.getTokenBefore(input.member);
 	if (before?.value === "|" && before.range[0] >= input.type.range[0]) return some(input.fixer.removeRange([before.range[0], input.member.range[1]]));
-	return pipe(fromNullishOr(input.context.sourceCode.getTokenAfter(input.member)), filter((token) => token.value === "|"), map$1((token) => input.fixer.removeRange([input.member.range[0], token.range[1]])));
+	return pipe(fromNullishOr(input.context.sourceCode.getTokenAfter(input.member)), filter((token) => token.value === "|"), map((token) => input.fixer.removeRange([input.member.range[0], token.range[1]])));
 }
 const noRedundantUseRefNullType = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -3389,7 +3391,7 @@ function fix$4(input) {
 		name: "Array",
 		scope: input.context.sourceCode.getScope(input.init)
 	}), (variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "effect"))) return [];
-	return getOrElse(flatMap$1(elementType(input.annotation.typeAnnotation), (element) => map$1(effectImport({
+	return getOrElse(flatMap$1(elementType(input.annotation.typeAnnotation), (element) => map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Array",
@@ -3477,7 +3479,7 @@ function shippedSchema(input) {
 	return pipe(shipped, findFirst((entry) => contains$1(base, entry.base) && contains$1(check, entry.check) && isArrayEmpty(rest) && match(fromUndefinedOr(entry.only), {
 		onNone: () => value === void 0,
 		onSome: (only) => value?.type === "Literal" && value.value === only
-	})), map$1((entry) => entry.schema));
+	})), map((entry) => entry.schema));
 }
 function pipedBase(node) {
 	if (node.parent.type !== "CallExpression") return none();
@@ -3511,7 +3513,7 @@ function reinventedSchema(input) {
 }
 const noReinventedSchema = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		map$1(reinventedSchema({
+		map(reinventedSchema({
 			context,
 			node
 		}), (schema) => {
@@ -3548,7 +3550,7 @@ function fix$3(input) {
 			...input,
 			reference
 		}))) return none();
-		return some([input.fixer.removeRange([input.node.imported.range[1], input.node.local.range[1]]), ...map(variable.references, (reference) => {
+		return some([input.fixer.removeRange([input.node.imported.range[1], input.node.local.range[1]]), ...map$1(variable.references, (reference) => {
 			if (reference.identifier.parent.type === "Property" && reference.identifier.parent.shorthand) return input.fixer.replaceText(reference.identifier.parent, `${input.node.local.name}: ${input.imported}`);
 			return input.fixer.replaceText(reference.identifier, input.imported);
 		})]);
@@ -3615,7 +3617,7 @@ function reaches(input) {
 	if (isArrayEmpty(next)) return false;
 	return reaches({
 		...input,
-		nodes: pipe(next, flatMap((variable) => variable.defs), filter$1((definition) => definition.type === "FunctionName" || definition.type === "Variable"), map((definition) => definition.node)),
+		nodes: pipe(next, flatMap((variable) => variable.defs), filter$1((definition) => definition.type === "FunctionName" || definition.type === "Variable"), map$1((definition) => definition.node)),
 		visited: appendAll(input.visited, next)
 	});
 }
@@ -3718,7 +3720,7 @@ function forwardedChain(input) {
 	});
 }
 function exactForwardingFunction(input) {
-	const names = pipe(input.node.params, map(parameterName), getSomes);
+	const names = pipe(input.node.params, map$1(parameterName), getSomes);
 	const returned = returnedExpression(input.node);
 	if (input.node.async || input.node.generator || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish(returned)) return false;
 	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
@@ -3760,14 +3762,15 @@ function copiesSafely(input) {
 	});
 }
 function singleUseFunction(input) {
-	const names = pipe(input.node.params, map(parameterName), getSomes);
+	const names = pipe(input.node.params, map$1(parameterName), getSomes);
 	const returned = returnedExpression(input.node);
 	if (input.node.async || input.node.generator || input.node.typeParameters !== null || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish(returned)) return false;
 	const oneLine = !pipe(input.context.sourceCode.getText(returned), includes("\n"));
-	return pipe(unexportedBindingName(input.node), flatMap$1((name) => variableFromScope({
+	return pipe(unexportedBindingName(input.node), flatMap$1((name) => readsOf({
+		context: input.context,
 		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap$1(head), map$1((reference) => reference.identifier), filter((read) => read.range[0] < input.node.range[0] || read.range[0] > input.node.range[1]), exists((read) => {
+		node: input.node
+	})), filter((reads) => reads.length === 1), flatMap$1(head), map((reference) => reference.identifier), filter((read) => read.range[0] < input.node.range[0] || read.range[0] > input.node.range[1]), exists((read) => {
 		if (read.parent.type !== "CallExpression") return false;
 		if (read.parent.callee !== read) return oneLine && some$1(read.parent.arguments, (argument) => argument === read);
 		if (!copiesSafely({
@@ -3791,20 +3794,22 @@ function redundantConstAlias(input) {
 			return definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const";
 		});
 	}))) return false;
-	return pipe(variableFromScope({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), exists((alias) => countBy(alias.references, (reference) => reference.isRead()) === 1));
+		node: input.node
+	}), exists((reads) => reads.length === 1));
 }
 function exportedAlias(input) {
 	return input.node.parent.type === "VariableDeclaration" && input.node.parent.kind === "const" && input.node.parent.parent.type === "ExportNamedDeclaration" && input.node.id.type === "Identifier" && input.node.init?.type === "Identifier" && pipe(variableFor(input.context, input.node.init), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" || definition.type === "FunctionName" || definition.type === "ClassName" || definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const")));
 }
 function singleUseLiteral(input) {
 	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.parent.parent.type === "Program" || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || !(input.node.init?.type === "Literal" && !hasProperty(input.node.init, "regex") || input.node.init?.type === "TemplateLiteral" && isArrayEmpty(input.node.init.expressions))) return false;
-	return pipe(variableFromScope({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => reads.length === 1 && reads[0]?.identifier.parent.type !== "ExportSpecifier"));
+		node: input.node
+	}), exists((reads) => reads.length === 1 && reads[0]?.identifier.parent.type !== "ExportSpecifier"));
 }
 function singleUseLayerPart(input) {
 	const init = input.node.init;
@@ -3814,10 +3819,11 @@ function singleUseLayerPart(input) {
 		node: init.callee,
 		propertyName: "gen"
 	}))) return false;
-	return pipe(variableFromScope({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => {
+		node: input.node
+	}), exists((reads) => {
 		const consumer = reads[0]?.identifier.parent;
 		if (reads.length !== 1 || consumer?.type !== "CallExpression") return false;
 		if (init.type === "MemberExpression") return importedMember({
@@ -4057,10 +4063,11 @@ function report$2(input) {
 	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null) return;
 	const statements = declaration.parent.body;
 	const name = input.node.id.name;
-	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap$1((index) => get$3(statements, index + 1)), flatMap$1((next) => pipe(variableFromScope({
+	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap$1((index) => get$3(statements, index + 1)), flatMap$1((next) => pipe(readsOf({
+		context: input.context,
 		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap$1(head), map$1((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
+		node: input.node
+	}), filter((reads) => reads.length === 1), flatMap$1(head), map((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
 		node: read,
 		statement: next
 	}) && readable({
@@ -4070,7 +4077,7 @@ function report$2(input) {
 	}) && !(init.type === "ConditionalExpression" && insideConditional({
 		node: read,
 		statement: next
-	})) && !(suspends(input.context, init) && receiver(outermost(read))) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])), map$1((read) => ({
+	})) && !(suspends(input.context, init) && receiver(outermost(read))) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])), map((read) => ({
 		next,
 		read
 	})))), match({
@@ -4283,7 +4290,7 @@ function branches(node) {
 function returns(context, node) {
 	const chain = branches(node);
 	if (some$1(chain.tests, (test) => test.consequent.type === "ConditionalExpression")) return [];
-	return [...map(chain.tests, (test) => `if (${context.sourceCode.getText(test.test)}) return ${context.sourceCode.getText(test.consequent)}`), `return ${context.sourceCode.getText(chain.last)}`];
+	return [...map$1(chain.tests, (test) => `if (${context.sourceCode.getText(test.test)}) return ${context.sourceCode.getText(test.consequent)}`), `return ${context.sourceCode.getText(chain.last)}`];
 }
 function inStatementList(node) {
 	return node.parent?.type === "BlockStatement" || node.parent?.type === "StaticBlock" || node.parent?.type === "SwitchCase";
@@ -4483,7 +4490,7 @@ function fix$1(input) {
 	const guard = GUARDS[input.node.parent.right.value];
 	if (guard === void 0) return [];
 	const replacement = input.fixer.replaceTextRange(input.node.parent.range, `${NEGATIONS[input.node.parent.operator]}Predicate.${guard}(${input.node.argument.name})`);
-	return getOrElse(map$1(effectImport({
+	return getOrElse(map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Predicate",
@@ -4621,7 +4628,7 @@ const WALL_CLOCKS = [
 function globalPath(context, node) {
 	if (node.type === "Identifier") return liftPredicate(node.name, () => !exists(variableFor(context, node), (variable) => isArrayNonEmpty(variable.defs)));
 	if (node.type !== "MemberExpression") return none();
-	return flatMap$1(memberName(node), (name) => map$1(globalPath(context, node.object), (path) => `${path}.${name}`));
+	return flatMap$1(memberName(node), (name) => map(globalPath(context, node.object), (path) => `${path}.${name}`));
 }
 function readsRealTime(context, node) {
 	if (importedMember({
@@ -4798,12 +4805,10 @@ function reportOption(context, key, bare, options) {
 }
 const preserveErrorCause = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const name = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		const name = memberName(node.callee);
+			node
+		});
 		if (contains$1(name, "mapError")) {
 			const bare = detailedFailure(context, node);
 			forEach(filter$1(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$1(context, callback));
@@ -4997,7 +5002,7 @@ function reportSchemaVariable(input) {
 				name
 			})) return [];
 			const start = pipe(input.context.sourceCode.getCommentsBefore(input.statement), head, getOrElse(() => input.statement)).range[0];
-			return [fixer.insertTextBeforeRange([start, start], `${EXPORT_PREFIXES[input.statement.type] ?? ""}type ${name} = typeof ${name}.Type\n`), ...pipe(input.queries, filter$1((query) => contains$1(queriedSchema(query), name) && readsModuleBinding(input.context, query, name)), map((query) => fixer.replaceText(query, name)))];
+			return [fixer.insertTextBeforeRange([start, start], `${EXPORT_PREFIXES[input.statement.type] ?? ""}type ${name} = typeof ${name}.Type\n`), ...pipe(input.queries, filter$1((query) => contains$1(queriedSchema(query), name) && readsModuleBinding(input.context, query, name)), map$1((query) => fixer.replaceText(query, name)))];
 		},
 		message: `Place \`type ${name} = typeof ${name}.Type\` immediately before this Schema.`,
 		node: input.variable
@@ -5023,7 +5028,7 @@ const schemaTypePair = defineRule({
 		const seeds = make$2();
 		return {
 			CallExpression: (node) => {
-				map$1(suspendedTypeName({
+				map(suspendedTypeName({
 					context,
 					node
 				}), (name) => append$1(seeds, name));
@@ -5098,7 +5103,7 @@ const swiftuiThemeValues = defineRule({
 				const name = calleeName(node);
 				if (contains(["listRowInsets", "padding"], name) && some$1(properties(node.arguments[0]), (property) => isNumber(property.value)) || name === "lineSpacing" && isNumber(node.arguments[0])) report(context, node, "Space with the theme’s spacing steps, such as padding({all: space[4]}).");
 				if (name === "font" && some$1(properties(node.arguments[0]), (property) => keyOf(property) === "size")) report(context, node, "Set type with a text token or a Dynamic Type textStyle, not a point size.");
-				if (contains(PAINTS, name) && some$1(flatMap(node.arguments, (argument) => [argument, ...map(properties(argument), (property) => property.value)]), (value) => value.type === "Literal" && isString(value.value) && isSome(match$1(/^#[\da-f]{3,8}$/iu)(value.value)))) report(context, node, "Paint with the theme’s colors, which follow light and dark, not a hex string.");
+				if (contains(PAINTS, name) && some$1(flatMap(node.arguments, (argument) => [argument, ...map$1(properties(argument), (property) => property.value)]), (value) => value.type === "Literal" && isString(value.value) && isSome(match$1(/^#[\da-f]{3,8}$/iu)(value.value)))) report(context, node, "Paint with the theme’s colors, which follow light and dark, not a hex string.");
 			},
 			ImportDeclaration: (node) => {
 				if (startsWith("@expo/ui/swift-ui")(node.source.value)) file.swiftui = true;
@@ -5377,10 +5382,18 @@ const lint = {
 				message: "Import Array from 'effect'.",
 				name: "Array"
 			},
+			{
+				message: "Use Base64 or Base64Url from effect/encoding.",
+				name: "atob"
+			},
 			{
 				message: "Import Boolean from 'effect'.",
 				name: "Boolean"
 			},
+			{
+				message: "Use Base64 or Base64Url from effect/encoding.",
+				name: "btoa"
+			},
 			{
 				message: "Use the effect/crypto services: SecureRandom, Digest, Signature.",
 				name: "crypto"
@@ -5552,7 +5565,7 @@ const lint = {
 				message: "Use Record or Struct from 'effect'.",
 				object: "Object"
 			},
-			...map(RUNNERS, (property) => ({
+			...map$1(RUNNERS, (property) => ({
 				message: RUN_MESSAGE,
 				object: "Effect",
 				property
@@ -5582,12 +5595,12 @@ const lint = {
 				object: "Math",
 				property: "round"
 			},
-			...map(REACT_LEGACY_APIS, (property) => ({
+			...map$1(REACT_LEGACY_APIS, (property) => ({
 				message: REACT_LEGACY_MESSAGE,
 				object: "React",
 				property
 			})),
-			...map(REACT_HOOKS, (property) => ({
+			...map$1(REACT_HOOKS, (property) => ({
 				message: `Import ${property} by name from react.`,
 				object: "React",
 				property
@@ -5627,7 +5640,7 @@ const lint = {
 				object: "Data",
 				property: "TaggedError"
 			},
-			...map([
+			...map$1([
 				"addEventListener",
 				"atob",
 				"btoa",
@@ -5647,7 +5660,7 @@ const lint = {
 				object: "window",
 				property
 			})),
-			...map([
+			...map$1([
 				"clearInterval",
 				"clearTimeout",
 				"setInterval",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1242",
+  "version": "0.1.1243",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",