@filipebraida/adonis-function-points 0.2.0 → 0.4.0

package/build/{resolvers-MFjRl2ef.js → resolvers-vMahHkAd.js}

@@ -1,55 +1,5 @@
+import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
-//#region src/inventory/resolvers/action_object.ts
-/**
-* "Action object" pattern: the transaction delegates to an action instantiated
-* at the call site.
-*
-*     await new ExpireInvite().handle({ invite })
-*
-*     const mark = new MarkContentChanged()
-*     await mark.handle({ documentId })
-*
-* The second form keeps the instance in a local variable, so the declaration
-* has to be followed back to the `new` — that is what `classOfReceiver` does.
-*/
-const actionObjectResolver = {
-	name: "action-object",
-	order: 10,
-	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
-		const member = expr.getName();
-		const className = classOfReceiver(expr.getExpression());
-		if (!className) return [];
-		const file = ctx.imports.get(className);
-		if (!file) return [];
-		return [{
-			file,
-			member
-		}];
-	}
-};
-/**
-* Finds the class behind a call receiver.
-*
-*   new Foo().handle()                    -> 'Foo'
-*   foo.handle()  where  const foo = new Foo()  -> 'Foo'
-*/
-function classOfReceiver(receiver) {
-	if (receiver.isKind(SyntaxKind.NewExpression)) {
-		const target = receiver.getExpression();
-		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
-	}
-	if (receiver.isKind(SyntaxKind.Identifier)) {
-		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
-		if (init?.isKind(SyntaxKind.NewExpression)) {
-			const target = init.getExpression();
-			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
-		}
-	}
-	return null;
-}
-//#endregion
 //#region src/inventory/paths.ts
 /**
 * One canonical spelling for every path the inventory emits.
@@ -71,6 +21,23 @@ function classOfReceiver(receiver) {
 * it to each comparison costs vigilance forever.
 */
 const toPosix = (value) => value.split("\\").join("/");
+/**
+* A path as it should appear in an EMITTED artefact: relative to the application.
+*
+* `CountSource.app` is documented as never being the absolute path, because that
+* says where the machine keeps its files and travels with every count sent
+* anywhere. One field below it, `config` shipped the absolute path — and so did
+* every `trace[].file`, 858 times in a single production count. The rule was
+* stated and then applied to one field.
+*
+* Internally the absolute path is the right thing: it is what ts-morph resolves
+* and what the call graph keys its caches on. So this converts at the boundary
+* where a path LEAVES, and nowhere else.
+*
+* A path outside the root keeps its `../` prefix, which describes where it is
+* without naming the home directory.
+*/
+const relativeTo = (root, value) => toPosix(path.relative(toPosix(root), toPosix(value))) || ".";
 /** Compares two paths that may have come from different sources. */
 const samePath = (a, b) => a !== void 0 && b !== void 0 && toPosix(a) === toPosix(b);
 //#endregion
@@ -170,29 +137,335 @@ function importedFrom(local, from, app) {
 		if (!named && !isDefault) continue;
 		return app.resolveSpecifier(declaration.getModuleSpecifierValue());
 	}
-	return null;
-}
+	return null;
+}
+/**
+* The file a key of a generated registry points at.
+*
+* Both shapes the generators emit are handled: a direct reference to an
+* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
+* per artefact and per framework version, and reading only one of them silently
+* lost half the graph.
+*/
+function registryEntry(registryFile, key, project, app) {
+	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
+	if (!file) return null;
+	for (const declaration of file.getVariableDeclarations()) {
+		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
+		if (!value) continue;
+		if (Node.isIdentifier(value)) {
+			const target = importedFrom(value.getText(), file, app);
+			return target ? toPosix(target) : null;
+		}
+		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		const target = specifier ? app.resolveSpecifier(specifier) : null;
+		return target ? toPosix(target) : null;
+	}
+	return null;
+}
+//#endregion
+//#region src/inventory/detectors/lucid.ts
+const WRITE_METHODS = new Set([
+	"save",
+	"delete",
+	"create",
+	"createMany",
+	"merge",
+	"fill",
+	"updateOrCreate",
+	"fetchOrCreateMany",
+	"firstOrCreate",
+	"updateOrCreateMany",
+	"attach",
+	"detach",
+	"sync",
+	"increment",
+	"decrement",
+	"update",
+	"truncate",
+	"restore",
+	"forceDelete"
+]);
+/**
+* Which hooks each access fires, by decorator name — counting-decisions §3.
+*
+* `save()` fires the save pair AND the create-or-update pair, and which of the
+* two runs is not knowable statically. That is not a compromise here: AFP
+* §6.5.3 requires treating multiple optional paths as part of the same
+* transaction, so following both is the specified behaviour.
+*/
+const HOOKS_BY_METHOD = {
+	save: [
+		"beforeSave",
+		"afterSave",
+		"beforeCreate",
+		"afterCreate",
+		"beforeUpdate",
+		"afterUpdate"
+	],
+	create: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeSave",
+		"afterSave"
+	],
+	createMany: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeSave",
+		"afterSave"
+	],
+	firstOrCreate: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeSave",
+		"afterSave"
+	],
+	fetchOrCreateMany: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeSave",
+		"afterSave"
+	],
+	updateOrCreate: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeUpdate",
+		"afterUpdate",
+		"beforeSave",
+		"afterSave"
+	],
+	updateOrCreateMany: [
+		"beforeCreate",
+		"afterCreate",
+		"beforeUpdate",
+		"afterUpdate",
+		"beforeSave",
+		"afterSave"
+	],
+	delete: ["beforeDelete", "afterDelete"],
+	forceDelete: ["beforeDelete", "afterDelete"],
+	find: ["beforeFind", "afterFind"],
+	findOrFail: ["beforeFind", "afterFind"],
+	findBy: ["beforeFind", "afterFind"],
+	findByOrFail: ["beforeFind", "afterFind"],
+	first: ["beforeFind", "afterFind"],
+	firstOrFail: ["beforeFind", "afterFind"],
+	all: ["beforeFetch", "afterFetch"],
+	findMany: ["beforeFetch", "afterFetch"]
+};
+new Set(Object.values(HOOKS_BY_METHOD).flat());
+/**
+* Hook decorators fired by an access, or `[]` when it fires none.
+*
+* `truncate`, `increment`, `decrement` and the pivot operations change rows
+* without instantiating a model, so no hook runs.
+*/
+function hooksFiredBy(access) {
+	if (!access.firesHooks) return [];
+	return HOOKS_BY_METHOD[access.method] ?? [];
+}
+const READ_METHODS = new Set([
+	"find",
+	"findOrFail",
+	"findBy",
+	"findByOrFail",
+	"findMany",
+	"first",
+	"firstOrFail",
+	"all",
+	"query",
+	"preload",
+	"load",
+	"paginate",
+	"count",
+	"exists",
+	"related",
+	"where",
+	"orderBy"
+]);
+function detectAccess(call, symbols, relations = /* @__PURE__ */ new Map()) {
+	const expression = call.getExpression();
+	if (!Node.isPropertyAccessExpression(expression)) return null;
+	const method = expression.getName();
+	const isWrite = WRITE_METHODS.has(method);
+	if (!isWrite && !READ_METHODS.has(method)) return null;
+	const receiver = expression.getExpression();
+	/**
+	* Looks up the PATH before the root: `input.invite.save()` has root `input`,
+	* which is no store at all — `input.invite` is.
+	*
+	* This is the dominant shape in action objects with a typed input, and
+	* without it the graph reaches the action and sees no write.
+	*/
+	const store = symbols.get(pathSymbolOf(receiver) ?? "") ?? symbols.get(rootSymbolOf(receiver) ?? "");
+	if (!store) return null;
+	/**
+	* `distribution.related('files').create({…})` — the relation is the SUBJECT of
+	* the write, not a table read along the way.
+	*
+	* `relationTargetOf` reads the current method, and here the current method is
+	* `create`, whose receiver is the `related(…)` call. Without looking back up the
+	* chain the write was attributed to `distributions` alone and `distribution_files`
+	* came out as a table this application only reads — an EIF, maintained by
+	* somebody else. That is what a production application reported, and it is
+	* ordinary Lucid: `related(…)` followed by `create`, `createMany`, `save`,
+	* `saveMany`, `attach`, `detach` or `sync` writes the related table.
+	*/
+	const related = relatedCallIn(receiver);
+	const viaRelation = relationTargetOf(method, call, store, relations) ?? (related ? relationTargetOf("related", related, store, relations) : void 0);
+	return {
+		mode: isWrite ? "write" : "read",
+		store,
+		method,
+		line: call.getStartLineNumber(),
+		viaRelation,
+		/** the relation is written when the method acting on it writes */
+		relationWritten: isWrite,
+		firesHooks: firesHooks(receiver)
+	};
+}
+/**
+* The `related('x')` call inside a receiver chain, if any.
+*
+* Only `related` qualifies: `preload` and `load` hand back the parent, so a write
+* after them acts on the parent. `related` hands back the relation's own query
+* builder, and that is what makes the difference.
+*/
+function relatedCallIn(receiver) {
+	let current = receiver;
+	for (let depth = 0; depth < 20 && current; depth++) {
+		if (Node.isCallExpression(current)) {
+			const expression = current.getExpression();
+			if (Node.isPropertyAccessExpression(expression) && expression.getName() === "related") return current;
+			current = expression;
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isAwaitExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+/**
+* An access fires hooks unless it went through the query builder.
+*
+* The signal is a CALL anywhere in the receiver chain: `document.delete()` has
+* none, `Document.query().where(…).delete()` has two. It errs towards NOT
+* following — `(await Document.find(id))!.delete()` is read as bulk — because
+* an FTR that is missing understates, and one that is invented overstates.
+*/
+function firesHooks(receiver) {
+	let current = receiver;
+	for (let depth = 0; depth < 20; depth++) {
+		if (Node.isCallExpression(current)) return false;
+		if (!Node.isPropertyAccessExpression(current)) return Node.isIdentifier(current);
+		current = current.getExpression();
+	}
+	return false;
+}
+const RELATION_ACCESSORS = new Set([
+	"preload",
+	"load",
+	"related",
+	"withCount"
+]);
+/**
+* `.preload('author')` on a store declaring `{ author: 'Author' }` reaches
+* `Author`.
+*/
+function relationTargetOf(method, call, store, relations) {
+	if (!RELATION_ACCESSORS.has(method)) return void 0;
+	const name = call.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+	if (!name) return void 0;
+	return relations.get(store)?.[name];
+}
+/**
+* Dotted path of a receiver made only of property accesses: `input.invite`
+* yields "input.invite". Any call in between invalidates the path, because the
+* value stops being statically traceable.
+*/
+function pathSymbolOf(node) {
+	const parts = [];
+	let current = node;
+	for (let depth = 0; depth < 20; depth++) {
+		if (Node.isIdentifier(current)) return [current.getText(), ...parts].join(".");
+		if (!Node.isPropertyAccessExpression(current)) return null;
+		parts.unshift(current.getName());
+		current = current.getExpression();
+	}
+	return null;
+}
+/**
+* Root of an `a.b().c()` chain — the left-most identifier.
+*
+* It must traverse `await`, calls, property access and `new`, otherwise
+* `await new Action().handle()` and `Invite.query().where().update()` stop at
+* the first node and the write disappears.
+*/
+function rootSymbolOf(node) {
+	let current = node;
+	for (let depth = 0; depth < 60 && current; depth++) {
+		if (Node.isIdentifier(current)) return current.getText();
+		if (current.getKind() === SyntaxKind.ThisKeyword) return "this";
+		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current) || Node.isCallExpression(current) || Node.isNewExpression(current) || Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		return null;
+	}
+	return null;
+}
+//#endregion
+//#region src/inventory/resolvers/action_object.ts
+/**
+* "Action object" pattern: the transaction delegates to an action instantiated
+* at the call site.
+*
+*     await new ExpireInvite().handle({ invite })
+*
+*     const mark = new MarkContentChanged()
+*     await mark.handle({ documentId })
+*
+* The second form keeps the instance in a local variable, so the declaration
+* has to be followed back to the `new` — that is what `classOfReceiver` does.
+*/
+const actionObjectResolver = {
+	name: "action-object",
+	order: 10,
+	resolve(call, ctx) {
+		const expr = call.getExpression();
+		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		const member = expr.getName();
+		const className = classOfReceiver(expr.getExpression());
+		if (!className) return [];
+		const file = ctx.imports.get(className);
+		if (!file) return [];
+		return [{
+			file,
+			member
+		}];
+	}
+};
 /**
-* The file a key of a generated registry points at.
+* Finds the class behind a call receiver.
 *
-* Both shapes the generators emit are handled: a direct reference to an
-* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
-* per artefact and per framework version, and reading only one of them silently
-* lost half the graph.
+*   new Foo().handle()                    -> 'Foo'
+*   foo.handle()  where  const foo = new Foo()  -> 'Foo'
 */
-function registryEntry(registryFile, key, project, app) {
-	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
-	if (!file) return null;
-	for (const declaration of file.getVariableDeclarations()) {
-		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
-		if (!value) continue;
-		if (Node.isIdentifier(value)) {
-			const target = importedFrom(value.getText(), file, app);
-			return target ? toPosix(target) : null;
+function classOfReceiver(receiver) {
+	if (receiver.isKind(SyntaxKind.NewExpression)) {
+		const target = receiver.getExpression();
+		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
+	}
+	if (receiver.isKind(SyntaxKind.Identifier)) {
+		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		if (init?.isKind(SyntaxKind.NewExpression)) {
+			const target = init.getExpression();
+			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 		}
-		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-		const target = specifier ? app.resolveSpecifier(specifier) : null;
-		return target ? toPosix(target) : null;
 	}
 	return null;
 }
@@ -239,17 +512,24 @@ const DISPATCH_METHODS = new Set([
 /**
 * The method that actually runs the job, by queue package.
 *
-* There is no single name: `@adonisjs/queue` and `@rlanz/bull-queue` call it
-* `handle`, `@nemoventures/adonis-jobs` calls it `process`. Looking only for
-* `handle` meant every job in an application using the second one resolved to
-* a file and then to no body, so the dispatch was reported as an unknown while
-* the writes inside it went uncounted — the worst of both outcomes.
+* There is no single name, and this list grew twice by measurement rather than by
+* reasoning. `@rlanz/bull-queue` uses `handle`; `@nemoventures/adonis-jobs` calls
+* it `process`; `@adonisjs/queue` — the official package — generates
+* `async execute()` in its own `make:job` stub. Each omission cost the same: the
+* file resolved, no body was found, the dispatch was reported as an unknown, and
+* every write inside the job went uncounted.
+*
+* `execute` surfaced only once event dispatch started being followed, because the
+* listener was what enqueued the job and that path had never been walked. Which is
+* the argument for adding a name when a real application shows it: a list written
+* from imagination would have missed this one too.
 *
 * Ordered: a class declaring more than one is answering the dispatcher with the
 * first, and `handle` is the most common.
 */
 const EXECUTION_METHODS = [
 	"handle",
+	"execute",
 	"process",
 	"run",
 	"perform"
@@ -434,221 +714,6 @@ const staticServiceResolver = {
 	}
 };
 //#endregion
-//#region src/inventory/detectors/lucid.ts
-const WRITE_METHODS = new Set([
-	"save",
-	"delete",
-	"create",
-	"createMany",
-	"merge",
-	"fill",
-	"updateOrCreate",
-	"fetchOrCreateMany",
-	"firstOrCreate",
-	"updateOrCreateMany",
-	"attach",
-	"detach",
-	"sync",
-	"increment",
-	"decrement",
-	"update",
-	"truncate",
-	"restore",
-	"forceDelete"
-]);
-/**
-* Which hooks each access fires, by decorator name — counting-decisions §3.
-*
-* `save()` fires the save pair AND the create-or-update pair, and which of the
-* two runs is not knowable statically. That is not a compromise here: AFP
-* §6.5.3 requires treating multiple optional paths as part of the same
-* transaction, so following both is the specified behaviour.
-*/
-const HOOKS_BY_METHOD = {
-	save: [
-		"beforeSave",
-		"afterSave",
-		"beforeCreate",
-		"afterCreate",
-		"beforeUpdate",
-		"afterUpdate"
-	],
-	create: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeSave",
-		"afterSave"
-	],
-	createMany: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeSave",
-		"afterSave"
-	],
-	firstOrCreate: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeSave",
-		"afterSave"
-	],
-	fetchOrCreateMany: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeSave",
-		"afterSave"
-	],
-	updateOrCreate: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeUpdate",
-		"afterUpdate",
-		"beforeSave",
-		"afterSave"
-	],
-	updateOrCreateMany: [
-		"beforeCreate",
-		"afterCreate",
-		"beforeUpdate",
-		"afterUpdate",
-		"beforeSave",
-		"afterSave"
-	],
-	delete: ["beforeDelete", "afterDelete"],
-	forceDelete: ["beforeDelete", "afterDelete"],
-	find: ["beforeFind", "afterFind"],
-	findOrFail: ["beforeFind", "afterFind"],
-	findBy: ["beforeFind", "afterFind"],
-	findByOrFail: ["beforeFind", "afterFind"],
-	first: ["beforeFind", "afterFind"],
-	firstOrFail: ["beforeFind", "afterFind"],
-	all: ["beforeFetch", "afterFetch"],
-	findMany: ["beforeFetch", "afterFetch"]
-};
-new Set(Object.values(HOOKS_BY_METHOD).flat());
-/**
-* Hook decorators fired by an access, or `[]` when it fires none.
-*
-* `truncate`, `increment`, `decrement` and the pivot operations change rows
-* without instantiating a model, so no hook runs.
-*/
-function hooksFiredBy(access) {
-	if (!access.firesHooks) return [];
-	return HOOKS_BY_METHOD[access.method] ?? [];
-}
-const READ_METHODS = new Set([
-	"find",
-	"findOrFail",
-	"findBy",
-	"findByOrFail",
-	"findMany",
-	"first",
-	"firstOrFail",
-	"all",
-	"query",
-	"preload",
-	"load",
-	"paginate",
-	"count",
-	"exists",
-	"related",
-	"where",
-	"orderBy"
-]);
-function detectAccess(call, symbols, relations = /* @__PURE__ */ new Map()) {
-	const expression = call.getExpression();
-	if (!Node.isPropertyAccessExpression(expression)) return null;
-	const method = expression.getName();
-	const isWrite = WRITE_METHODS.has(method);
-	if (!isWrite && !READ_METHODS.has(method)) return null;
-	const receiver = expression.getExpression();
-	/**
-	* Looks up the PATH before the root: `input.invite.save()` has root `input`,
-	* which is no store at all — `input.invite` is.
-	*
-	* This is the dominant shape in action objects with a typed input, and
-	* without it the graph reaches the action and sees no write.
-	*/
-	const store = symbols.get(pathSymbolOf(receiver) ?? "") ?? symbols.get(rootSymbolOf(receiver) ?? "");
-	if (!store) return null;
-	return {
-		mode: isWrite ? "write" : "read",
-		store,
-		method,
-		line: call.getStartLineNumber(),
-		viaRelation: relationTargetOf(method, call, store, relations),
-		firesHooks: firesHooks(receiver)
-	};
-}
-/**
-* An access fires hooks unless it went through the query builder.
-*
-* The signal is a CALL anywhere in the receiver chain: `document.delete()` has
-* none, `Document.query().where(…).delete()` has two. It errs towards NOT
-* following — `(await Document.find(id))!.delete()` is read as bulk — because
-* an FTR that is missing understates, and one that is invented overstates.
-*/
-function firesHooks(receiver) {
-	let current = receiver;
-	for (let depth = 0; depth < 20; depth++) {
-		if (Node.isCallExpression(current)) return false;
-		if (!Node.isPropertyAccessExpression(current)) return Node.isIdentifier(current);
-		current = current.getExpression();
-	}
-	return false;
-}
-const RELATION_ACCESSORS = new Set([
-	"preload",
-	"load",
-	"related",
-	"withCount"
-]);
-/**
-* `.preload('author')` on a store declaring `{ author: 'Author' }` reaches
-* `Author`.
-*/
-function relationTargetOf(method, call, store, relations) {
-	if (!RELATION_ACCESSORS.has(method)) return void 0;
-	const name = call.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-	if (!name) return void 0;
-	return relations.get(store)?.[name];
-}
-/**
-* Dotted path of a receiver made only of property accesses: `input.invite`
-* yields "input.invite". Any call in between invalidates the path, because the
-* value stops being statically traceable.
-*/
-function pathSymbolOf(node) {
-	const parts = [];
-	let current = node;
-	for (let depth = 0; depth < 20; depth++) {
-		if (Node.isIdentifier(current)) return [current.getText(), ...parts].join(".");
-		if (!Node.isPropertyAccessExpression(current)) return null;
-		parts.unshift(current.getName());
-		current = current.getExpression();
-	}
-	return null;
-}
-/**
-* Root of an `a.b().c()` chain — the left-most identifier.
-*
-* It must traverse `await`, calls, property access and `new`, otherwise
-* `await new Action().handle()` and `Invite.query().where().update()` stop at
-* the first node and the write disappears.
-*/
-function rootSymbolOf(node) {
-	let current = node;
-	for (let depth = 0; depth < 60 && current; depth++) {
-		if (Node.isIdentifier(current)) return current.getText();
-		if (current.getKind() === SyntaxKind.ThisKeyword) return "this";
-		if (Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current) || Node.isCallExpression(current) || Node.isNewExpression(current) || Node.isAwaitExpression(current) || Node.isParenthesizedExpression(current) || Node.isNonNullExpression(current)) {
-			current = current.getExpression();
-			continue;
-		}
-		return null;
-	}
-	return null;
-}
-//#endregion
 //#region src/inventory/resolvers/transformer.ts
 /** BaseTransformer's public API; all of it funnels through `toObject` */
 const TRANSFORMER_METHODS = new Set([
@@ -772,4 +837,4 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	return null;
 }
 //#endregion
-export { rootSymbolOf as a, toPosix as c, hooksFiredBy as i, resolveCall as n, collectEventBindings as o, detectAccess as r, samePath as s, BUILTIN_CALL_RESOLVERS as t };
+export { rootSymbolOf as a, samePath as c, hooksFiredBy as i, toPosix as l, resolveCall as n, collectEventBindings as o, detectAccess as r, relativeTo as s, BUILTIN_CALL_RESOLVERS as t };