@auspex-ai/next 0.0.0-stage → 1.4.2

package/dist/icon-name-loader.cjs

@@ -0,0 +1,1156 @@
+const require_transform = require("./transform-Dc5diC_P.cjs");
+let node_path = require("node:path");
+node_path = require_transform.__toESM(node_path, 1);
+let magic_string = require("magic-string");
+//#region ../build-names/src/element-name/label.ts
+/** 式の置き換え */
+const HOLE = "[*]";
+/** 子の中のテキストを文書順に集める(入れ子の要素の子を含む)。式は HOLE にする */
+function collect(children, out) {
+	for (const c of children) switch (c.type) {
+		case "JSXText":
+			out.push(c.value);
+			break;
+		case "JSXElement":
+		case "JSXFragment":
+			collect(c.children ?? [], out);
+			break;
+		case "JSXExpressionContainer":
+			out.push(fromExpression(c.expression));
+			break;
+		case "JSXSpreadChild": out.push(HOLE);
+	}
+}
+/** 式 1 つ分のテキスト。文字列リテラルと式の無いテンプレートリテラルだけが静的な文言 */
+function fromExpression(e) {
+	if (!e || e.type === "JSXEmptyExpression") return "";
+	if (e.type === "StringLiteral") return e.value;
+	if (e.type === "TemplateLiteral") {
+		let s = "";
+		for (const [i, q] of e.quasis.entries()) {
+			s += q.value.cooked ?? q.value.raw;
+			if (i < e.expressions.length) s += HOLE;
+		}
+		return s;
+	}
+	return HOLE;
+}
+function normalize(raw) {
+	return raw.replace(/\s+/g, " ").trim().replace(/\[\*\](?: ?\[\*\])+/g, HOLE).normalize("NFC");
+}
+/** [*]・空白・句読点を除いて何も残らないか */
+function isEmptyText(s) {
+	return s.split(HOLE).join("").replace(/[\s\p{P}]/gu, "") === "";
+}
+/** 静的な文字列リテラルの属性値(式は取らない) */
+function staticAttr(o, name) {
+	for (const a of o.attributes) {
+		if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier" || a.name.name !== name) continue;
+		return a.value?.type === "StringLiteral" ? a.value.value : null;
+	}
+	return null;
+}
+/** クリックされうる JSX 要素のラベル。取れない・使えない(実行時の値だけ・句読点だけ・長すぎる)ときは null */
+function labelOf(el) {
+	const parts = [];
+	collect(el.children ?? [], parts);
+	let text = normalize(parts.join(""));
+	if (isEmptyText(text)) {
+		text = "";
+		for (const attr of ["aria-label", "title"]) {
+			const v = staticAttr(el.openingElement, attr);
+			if (v === null) continue;
+			const n = normalize(v);
+			if (!isEmptyText(n)) {
+				text = n;
+				break;
+			}
+		}
+	}
+	if (text === "" || [...text].length > 80) return null;
+	return text;
+}
+//#endregion
+//#region ../build-names/src/element-name/extract.ts
+const SKIP_KEYS$1 = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+function children(n) {
+	const out = [];
+	for (const k of Object.keys(n)) {
+		if (SKIP_KEYS$1.has(k)) continue;
+		const v = n[k];
+		if (Array.isArray(v)) {
+			for (const c of v) if (c && typeof c.type === "string") out.push(c);
+		} else if (v && typeof v.type === "string") out.push(v);
+	}
+	return out;
+}
+const GENERIC_HANDLER = /^((on|handle)(Click|Press|Tap|Change|Select|Submit|PointerDown|MouseDown|TouchStart|KeyDown|DoubleClick|Action)?|callback|cb|fn|handler|action|formAction|onClickHandler|clickHandler)$/;
+const GENERIC_COMPONENT = /^(App|Common|Shared|My|Main|Primary|Secondary|Submit)?(Button|IconButton|Link|NavLink|Anchor|Clickable|Pressable|Item|MenuItem|ListItem|Root|Trigger|Wrapper|Card|Tab|Option|Chip|App|Component|Default|Page|Layout|Home)$|^(Base|Styled|Custom|Ui|UI|Primitive)[A-Z]\w*$|(Page|Layout|Template)$/;
+const GENERIC_MEMBER_PROP = /* @__PURE__ */ new Set([
+	"mutate",
+	"mutateAsync",
+	"trigger",
+	"execute",
+	"run",
+	"call",
+	"open",
+	"close",
+	"toggle",
+	"show",
+	"hide",
+	"reset",
+	"refetch",
+	"submit",
+	"onOpen",
+	"onClose",
+	"onToggle"
+]);
+/** 呼んでも要素の意味にならない呼び出し */
+const NOISE_CALLS = /* @__PURE__ */ new Set([
+	"preventDefault",
+	"stopPropagation",
+	"stopImmediatePropagation",
+	"log",
+	"warn",
+	"error",
+	"info",
+	"debug",
+	"alert",
+	"confirm",
+	"prompt",
+	"setTimeout",
+	"clearTimeout",
+	"requestAnimationFrame",
+	"startTransition",
+	"then",
+	"catch",
+	"finally",
+	"resolve",
+	"all",
+	"focus",
+	"blur",
+	"scrollIntoView",
+	"success",
+	"loading",
+	"dismiss",
+	"toast",
+	"Number",
+	"String",
+	"Boolean",
+	"parseInt",
+	"structuredClone"
+]);
+/** メンバー呼び出しのときだけ雑音(配列・文字列・ストレージのメソッド) */
+const NOISE_MEMBER = /* @__PURE__ */ new Set([
+	"stringify",
+	"parse",
+	"push",
+	"filter",
+	"map",
+	"includes",
+	"find",
+	"slice",
+	"trim",
+	"join",
+	"replace",
+	"getItem",
+	"setItem",
+	"removeItem",
+	"getTime",
+	"now",
+	"max",
+	"min",
+	"floor",
+	"round",
+	"random",
+	"toString",
+	"toISOString",
+	"current",
+	"forEach",
+	"concat",
+	"split",
+	"set",
+	"get",
+	"delete",
+	"has",
+	"add"
+]);
+const NOISE_OBJECTS = /* @__PURE__ */ new Set([
+	"e",
+	"ev",
+	"evt",
+	"event",
+	"console",
+	"toast",
+	"Math",
+	"Date",
+	"JSON",
+	"Object",
+	"Array",
+	"localStorage",
+	"sessionStorage"
+]);
+/** 既存の計測呼び出し(第 1 引数などのイベント名を名前にする) */
+const TRACK_CALLEES = /* @__PURE__ */ new Set([
+	"track",
+	"trackEvent",
+	"sendGAEvent",
+	"sendGTMEvent",
+	"logEvent",
+	"gtag",
+	"capture",
+	"logAnalyticsEvent",
+	"analyticsTrack"
+]);
+const TRACK_OBJECTS = /* @__PURE__ */ new Set([
+	"posthog",
+	"mixpanel",
+	"amplitude",
+	"analytics",
+	"ga"
+]);
+const CLICKISH_COMPONENT = /Button|Link|Tab|MenuItem|Trigger|Checkbox|Radio|Switch|Toggle|SelectItem|Option|Chip|Action$/;
+const HANDLER_PROPS = [
+	"onClick",
+	"onPress",
+	"onPointerDown",
+	"onMouseDown",
+	"onTouchStart",
+	"onDoubleClick",
+	"onKeyDown",
+	"onChange",
+	"onCheckedChange",
+	"onValueChange",
+	"onSelect",
+	"onToggle"
+];
+const GROUP_HANDLER_PROPS = [
+	"onValueChange",
+	"onChange",
+	"onCheckedChange"
+];
+const VALUE_ELEMENTS = /^(input|option|SelectItem|TabsTrigger|RadioGroupItem|ToggleGroupItem|DropdownMenuRadioItem|Radio|Tab)$/;
+const NATIVE_CLICKABLE = /* @__PURE__ */ new Set([
+	"button",
+	"a",
+	"input",
+	"select",
+	"label",
+	"summary",
+	"area",
+	"option"
+]);
+const CLICK_ROLES = /* @__PURE__ */ new Set([
+	"button",
+	"link",
+	"tab",
+	"menuitem",
+	"option",
+	"switch",
+	"checkbox",
+	"radio",
+	"menuitemradio",
+	"menuitemcheckbox"
+]);
+/** 配列の名前として意味を持たない変数名 */
+const GENERIC_ARRAY = /^(items|list|data|rows|options|entries|children|props)$/;
+/**
+* 候補の名前として使える形か(受信口の形の規則 `isElementName` と同じ)。ここでは候補を選ぶためだけに使い、
+* 書き込んだ値の検査は受信口に一本化する(Design Doc #43 の 3 節)
+*/
+const ID = /^[A-Za-z0-9_.:/[\]*#|-]{1,64}$/;
+function usable(n) {
+	return !!n && ID.test(n) && !/\d{3,}/.test(n.replace(/\[\*\]/g, ""));
+}
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"ParenthesizedExpression",
+	"JSXExpressionContainer",
+	"AwaitExpression",
+	"TSTypeAssertion"
+]);
+function unwrap(e) {
+	let n = e;
+	while (n && WRAPPERS.has(n.type)) n = n.type === "AwaitExpression" ? n.argument : n.expression;
+	return n;
+}
+function staticString(e) {
+	const n = unwrap(e);
+	if (!n) return null;
+	if (n.type === "StringLiteral") return n.value;
+	if (n.type === "TemplateLiteral" && n.expressions.length === 0) return n.quasis[0].value.cooked ?? null;
+	return null;
+}
+/** 引数の静的な値: 文字列・数値・真偽・null と、x ± 数値 の ±N */
+function literalArg(e) {
+	const str = staticString(e);
+	if (str !== null) return str;
+	const n = unwrap(e);
+	if (!n) return null;
+	if (n.type === "NumericLiteral") return String(n.value);
+	if (n.type === "UnaryExpression" && n.operator === "-" && n.argument.type === "NumericLiteral") return `-${n.argument.value}`;
+	if (n.type === "BooleanLiteral") return String(n.value);
+	if (n.type === "NullLiteral") return "null";
+	if (n.type === "BinaryExpression" && (n.operator === "+" || n.operator === "-") && n.right.type === "NumericLiteral") return `${n.operator}${n.right.value}`;
+	return null;
+}
+function keyName(p) {
+	if (p.computed) return null;
+	if (p.key.type === "Identifier") return p.key.name;
+	if (p.key.type === "StringLiteral") return p.key.value;
+	return null;
+}
+/** パスとして: 式の部分は [*]。静的な部分が無ければ null */
+function pathTemplate(e) {
+	const n = unwrap(e);
+	if (!n) return null;
+	const s = staticString(n);
+	if (s !== null) return s;
+	if (n.type === "TemplateLiteral") {
+		let out = "";
+		n.quasis.forEach((q, i) => {
+			out += q.value.cooked;
+			if (i < n.expressions.length) out += "[*]";
+		});
+		return out;
+	}
+	if (n.type === "BinaryExpression" && n.operator === "+") {
+		const l = pathTemplate(n.left);
+		if (l === null) return null;
+		return l + (pathTemplate(n.right) ?? "[*]");
+	}
+	if (n.type === "ObjectExpression") {
+		const p = n.properties.find((p) => p.type === "ObjectProperty" && keyName(p) === "pathname");
+		return p ? pathTemplate(p.value) : null;
+	}
+	return null;
+}
+/** パスを名前にする: クエリ・ハッシュを落とし、外部 URL はホストだけ、mailto・tel は種類だけ */
+function normalizePath(p) {
+	if (p === null) return null;
+	const s = p.trim();
+	if (/^mailto:/i.test(s)) return "mailto";
+	if (/^tel:/i.test(s)) return "tel";
+	if (/^https?:\/\//i.test(s)) {
+		const host = s.replace(/^https?:\/\//i, "").split(/[/?#]/)[0] ?? "";
+		return host.includes("[*]") || !host ? null : `ext:${host}`;
+	}
+	if (s.startsWith("#")) return s.length > 1 ? s : null;
+	if (!s.startsWith("/")) return null;
+	return (s.split(/[?#]/)[0] ?? "").replace(/\[\*\][^/]*/g, "[*]").replace(/\/+$/, "") || "/";
+}
+function calleeParts(c) {
+	const n = unwrap(c);
+	if (n.type === "Identifier") return {
+		obj: null,
+		prop: n.name
+	};
+	if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+		const prop = !n.computed && n.property.type === "Identifier" ? n.property.name : null;
+		const o = unwrap(n.object);
+		return {
+			obj: o.type === "Identifier" ? o.name : o.type === "MemberExpression" && !o.computed && o.property.type === "Identifier" ? o.property.name : o.type === "ThisExpression" ? "this" : null,
+			prop
+		};
+	}
+	return {
+		obj: null,
+		prop: null
+	};
+}
+const PRIORITY = [
+	"track",
+	"call",
+	"setterArg",
+	"api",
+	"nav",
+	"mcall",
+	"setter"
+];
+/** 後始末(pause・stopSpeaking)が先に来て本体が後に来る書き方が多いので、同じ種類の中では最後のものを採る */
+const LAST = /* @__PURE__ */ new Set([
+	"call",
+	"setterArg",
+	"mcall"
+]);
+var Ctx = class {
+	parent = /* @__PURE__ */ new WeakMap();
+	constructor(program) {
+		const visit = (n) => {
+			for (const c of children(n)) {
+				this.parent.set(c, n);
+				visit(c);
+			}
+		};
+		visit(program);
+	}
+	ancestors(n) {
+		const out = [];
+		for (let p = this.parent.get(n); p; p = this.parent.get(p)) out.push(p);
+		return out;
+	}
+	/** 識別子の束縛(同じファイル内: 変数宣言・関数宣言・分割代入・引数)を内側のスコープから探す */
+	binding(name, from) {
+		for (const a of [from, ...this.ancestors(from)]) {
+			if (/Function/.test(a.type)) for (const p of a.params) {
+				if (p.type === "Identifier" && p.name === name) return {
+					init: null,
+					kind: "param"
+				};
+				if (p.type === "ObjectPattern") {
+					for (const pr of p.properties) if (pr.type === "ObjectProperty" && unwrap(pr.value)?.type === "Identifier" && pr.value.name === name) return {
+						init: null,
+						kind: "param"
+					};
+				}
+			}
+			const body = a.type === "BlockStatement" || a.type === "Program" ? a.body : null;
+			if (!body) continue;
+			for (const st of body) {
+				const decl = st.type === "ExportNamedDeclaration" || st.type === "ExportDefaultDeclaration" ? st.declaration : st;
+				if (decl?.type === "VariableDeclaration") for (const d of decl.declarations) {
+					if (d.id.type === "Identifier" && d.id.name === name) return {
+						init: d.init,
+						kind: "var"
+					};
+					if (d.id.type === "ObjectPattern") {
+						for (const pr of d.id.properties) if (pr.type === "ObjectProperty" && pr.value.type === "Identifier" && pr.value.name === name) return {
+							init: d.init,
+							kind: "destructure"
+						};
+					}
+					if (d.id.type === "ArrayPattern" && d.id.elements.some((el) => el?.type === "Identifier" && el.name === name)) return {
+						init: d.init,
+						kind: "destructure",
+						pattern: d.id
+					};
+				}
+				if (decl?.type === "FunctionDeclaration" && decl.id?.name === name) return {
+					init: decl,
+					kind: "fn"
+				};
+			}
+		}
+		return null;
+	}
+};
+function trackName(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	const args = call.arguments;
+	const fromObj = (a) => {
+		const o = unwrap(a);
+		if (o?.type !== "ObjectExpression") return null;
+		const p = o.properties.find((p) => p.type === "ObjectProperty" && [
+			"event",
+			"name",
+			"action"
+		].includes(keyName(p) ?? ""));
+		return p ? staticString(p.value) : null;
+	};
+	if (obj === "dataLayer" && prop === "push") return fromObj(args[0]);
+	if (!(prop && (TRACK_CALLEES.has(prop) || obj && TRACK_OBJECTS.has(obj) && [
+		"track",
+		"capture",
+		"logEvent"
+	].includes(prop)))) return null;
+	if (prop === "gtag" || prop === "sendGAEvent" && staticString(args[0]) === "event") return staticString(args[1]);
+	if (prop === "logEvent" && args[0] && staticString(args[0]) === null) return staticString(args[1]);
+	return staticString(args[0]) ?? fromObj(args[0]);
+}
+/** 画面遷移: 遷移先のパス(名前にならなければ null)。遷移でなければ undefined */
+function navPath(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	const a0 = call.arguments[0];
+	if (obj && /router|navigation|nav/i.test(obj) && (prop === "push" || prop === "replace") || prop === "redirect" || prop === "navigate" || prop === "permanentRedirect" || obj === "location" && (prop === "assign" || prop === "replace") || obj === "window" && prop === "open") return normalizePath(pathTemplate(a0));
+	if (obj && /router|history/i.test(obj) && prop === "back" || prop === "back") return "back";
+	if (obj && /router/i.test(obj) && prop === "refresh") return "refresh";
+}
+/** API の呼び出し: API のパス(名前にならなければ null)。API でなければ undefined */
+function apiPath(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	if (prop === "fetch" || prop === "axios" || obj && /^(axios|api|client|http|ky|\$fetch)$/.test(obj) && /^(get|post|put|patch|delete|request)$/.test(prop ?? "")) {
+		const p = normalizePath(pathTemplate(call.arguments[0]));
+		return p?.startsWith("/") ? p : null;
+	}
+}
+function analyzeCall(call, ctx, out) {
+	const tracked = trackName(call);
+	if (tracked) {
+		out.push({
+			kind: "track",
+			name: tracked
+		});
+		return;
+	}
+	const nav = navPath(call);
+	if (nav !== void 0) {
+		if (nav) out.push({
+			kind: "nav",
+			name: nav
+		});
+		return;
+	}
+	const api = apiPath(call);
+	if (api !== void 0) {
+		if (api) out.push({
+			kind: "api",
+			name: api
+		});
+		return;
+	}
+	const { obj, prop } = calleeParts(call.callee);
+	if (prop && [
+		"startTransition",
+		"setTimeout",
+		"requestAnimationFrame",
+		"then",
+		"finally",
+		"catch"
+	].includes(prop)) {
+		const cu = unwrap(call.callee);
+		if (cu.type === "MemberExpression") walkExpr(cu.object, ctx, out);
+		for (const a of call.arguments) if (/Function/.test(a.type)) walkFn(a, ctx, out);
+		return;
+	}
+	if (prop === "dispatch") {
+		const a = unwrap(call.arguments[0]);
+		if (a?.type === "CallExpression") {
+			const c = calleeParts(a.callee).prop;
+			if (c) out.push({
+				kind: "call",
+				name: c
+			});
+		} else if (a?.type === "ObjectExpression") {
+			const p = a.properties.find((p) => keyName(p) === "type");
+			const s = p && staticString(p.value);
+			if (s) out.push({
+				kind: "call",
+				name: s
+			});
+		}
+		return;
+	}
+	if (!prop || NOISE_CALLS.has(prop) || obj && NOISE_MEMBER.has(prop)) {
+		for (const a of call.arguments) walkExpr(a, ctx, out);
+		return;
+	}
+	if (obj && NOISE_OBJECTS.has(obj)) return;
+	if (/^set[A-Z]/.test(prop)) {
+		const arg = literalArg(call.arguments[0]);
+		const promote = arg !== null && arg !== "false" && arg !== "null";
+		out.push(arg && usable(`${prop}:${arg}`) ? {
+			kind: promote ? "setterArg" : "setter",
+			name: `${prop}:${arg}`
+		} : {
+			kind: "setter",
+			name: prop
+		});
+		return;
+	}
+	if (GENERIC_MEMBER_PROP.has(prop) && !obj) {
+		const init = unwrap(ctx.binding(prop, call)?.init);
+		const key = init?.type === "CallExpression" ? normalizePath(pathTemplate(init.arguments[0])) : null;
+		if (key?.startsWith("/")) out.push({
+			kind: "api",
+			name: key
+		});
+		return;
+	}
+	if (GENERIC_MEMBER_PROP.has(prop)) {
+		if (obj && ![
+			"props",
+			"this",
+			"state",
+			"store",
+			"ref",
+			"current"
+		].includes(obj)) out.push({
+			kind: "call",
+			name: obj
+		});
+		else if (prop.startsWith("on") && !GENERIC_HANDLER.test(prop)) out.push({
+			kind: "call",
+			name: prop
+		});
+		return;
+	}
+	if (obj === "clipboard" || obj === "navigator") {
+		out.push({
+			kind: "call",
+			name: `clipboard.${prop}`
+		});
+		return;
+	}
+	if (obj === "window" && [
+		"print",
+		"scrollTo",
+		"close"
+	].includes(prop)) {
+		out.push({
+			kind: "call",
+			name: prop
+		});
+		return;
+	}
+	if (GENERIC_HANDLER.test(prop)) return;
+	const arg = literalArg(call.arguments[0]);
+	out.push({
+		kind: obj ? "mcall" : "call",
+		name: arg && usable(`${prop}:${arg}`) ? `${prop}:${arg}` : prop
+	});
+}
+function walkExpr(e, ctx, out) {
+	const n = unwrap(e);
+	if (!n) return;
+	switch (n.type) {
+		case "CallExpression":
+		case "OptionalCallExpression":
+			analyzeCall(n, ctx, out);
+			return;
+		case "LogicalExpression":
+			walkExpr(n.left, ctx, out);
+			walkExpr(n.right, ctx, out);
+			return;
+		case "ConditionalExpression":
+			walkExpr(n.consequent, ctx, out);
+			walkExpr(n.alternate, ctx, out);
+			return;
+		case "SequenceExpression":
+			for (const x of n.expressions) walkExpr(x, ctx, out);
+			return;
+		case "UnaryExpression":
+			walkExpr(n.argument, ctx, out);
+			return;
+		case "AssignmentExpression": {
+			const { obj, prop } = calleeParts(unwrap(n.left));
+			if (prop === "href" && /location/.test(obj ?? "")) {
+				const p = normalizePath(pathTemplate(n.right));
+				if (p) out.push({
+					kind: "nav",
+					name: p
+				});
+			} else walkExpr(n.right, ctx, out);
+			return;
+		}
+	}
+}
+function walkStmts(stmts, ctx, out) {
+	for (const st of stmts) switch (st.type) {
+		case "ExpressionStatement":
+			walkExpr(st.expression, ctx, out);
+			break;
+		case "ReturnStatement":
+			walkExpr(st.argument, ctx, out);
+			break;
+		case "IfStatement":
+			walkExpr(st.test, ctx, out);
+			walkStmts([st.consequent], ctx, out);
+			if (st.alternate) walkStmts([st.alternate], ctx, out);
+			break;
+		case "BlockStatement":
+			walkStmts(st.body, ctx, out);
+			break;
+		case "TryStatement":
+			walkStmts(st.block.body, ctx, out);
+			break;
+		case "VariableDeclaration": for (const d of st.declarations) walkExpr(d.init, ctx, out);
+	}
+}
+function walkFn(fn, ctx, out) {
+	if (fn.body.type === "BlockStatement") walkStmts(fn.body.body, ctx, out);
+	else walkExpr(fn.body, ctx, out);
+}
+function pick(cands) {
+	for (const k of PRIORITY) {
+		const xs = cands.filter((x) => x.kind === k && usable(x.name));
+		const found = LAST.has(k) ? xs[xs.length - 1] : xs[0];
+		if (found) return found;
+	}
+	return null;
+}
+function fromBody(fn, ctx) {
+	const out = [];
+	walkFn(fn, ctx, out);
+	const c = pick(out);
+	return c ? {
+		name: c.name,
+		source: c.kind
+	} : null;
+}
+/** ハンドラの式 → 名前 */
+function handlerName(expr, ctx, depth = 0) {
+	const n = unwrap(expr);
+	if (!n || depth > 3) return null;
+	if (n.type === "Identifier") {
+		const b = ctx.binding(n.name, n);
+		const init = unwrap(b?.init);
+		if (b?.kind === "destructure" && b.pattern && init?.type === "CallExpression" && /^(useActionState|useFormState)$/.test(calleeParts(init.callee).prop ?? "")) {
+			const a0 = init.arguments[0];
+			return a0?.type === "Identifier" ? {
+				name: a0.name,
+				source: "action"
+			} : null;
+		}
+		if (!GENERIC_HANDLER.test(n.name)) return {
+			name: n.name,
+			source: "handler"
+		};
+		if (init && /Function/.test(init.type)) return fromBody(init, ctx);
+		if (init?.type === "CallExpression" && /^(useCallback|useMemo)$/.test(calleeParts(init.callee).prop ?? "") && /Function/.test(init.arguments[0]?.type)) return fromBody(init.arguments[0], ctx);
+		return null;
+	}
+	if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+		const { obj, prop } = calleeParts(n);
+		if (!prop) return null;
+		if (GENERIC_MEMBER_PROP.has(prop)) return obj && ![
+			"props",
+			"this",
+			"state"
+		].includes(obj) ? {
+			name: obj,
+			source: "handler"
+		} : null;
+		if (/^set[A-Z]/.test(prop)) return {
+			name: prop,
+			source: "setter"
+		};
+		return GENERIC_HANDLER.test(prop) ? null : {
+			name: prop,
+			source: "handler"
+		};
+	}
+	if (/Function/.test(n.type)) return fromBody(n, ctx);
+	if (n.type === "CallExpression") {
+		const { obj, prop } = calleeParts(n.callee);
+		if (prop === "bind" && obj) return GENERIC_HANDLER.test(obj) ? null : {
+			name: obj,
+			source: "action"
+		};
+		if (prop && /^(useCallback|useMemo)$/.test(prop)) return handlerName(n.arguments[0], ctx, depth + 1);
+		const arg = staticString(n.arguments[0]);
+		if (prop && arg && usable(`${prop}:${arg}`)) return {
+			name: `${prop}:${arg}`,
+			source: "handler"
+		};
+		if (prop && !GENERIC_HANDLER.test(prop)) return (n.arguments[0] ? handlerName(n.arguments[0], ctx, depth + 1) : null) ?? {
+			name: prop,
+			source: "handler"
+		};
+		return n.arguments[0] ? handlerName(n.arguments[0], ctx, depth + 1) : null;
+	}
+	return null;
+}
+function tagName(o) {
+	const nm = o.name;
+	if (nm.type === "JSXIdentifier") return nm.name;
+	if (nm.type === "JSXMemberExpression") {
+		const parts = [];
+		let x = nm;
+		while (x.type === "JSXMemberExpression") {
+			parts.unshift(x.property.name);
+			x = x.object;
+		}
+		parts.unshift(x.name);
+		return parts.join(".");
+	}
+	return "";
+}
+function jsxAttr(o, name) {
+	return o.attributes.find((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === name);
+}
+function attrExpr(o, name) {
+	const a = jsxAttr(o, name);
+	return a ? a.value ?? {
+		type: "BooleanLiteral",
+		value: true
+	} : null;
+}
+function attrStatic(o, name) {
+	const e = attrExpr(o, name);
+	return e ? staticString(e) : null;
+}
+/** クリックされうる要素: ネイティブの要素、クリックの role、クリックのハンドラ、クリックらしいコンポーネント */
+function isClickable(o) {
+	const tag = tagName(o);
+	const last = tag.split(".").pop() ?? "";
+	const has = (p) => !!jsxAttr(o, p);
+	const role = attrStatic(o, "role");
+	if (NATIVE_CLICKABLE.has(tag)) return true;
+	if (role && CLICK_ROLES.has(role)) return true;
+	if (HANDLER_PROPS.some((p) => p !== "onChange" && has(p))) return true;
+	if (/^[A-Z]/.test(last)) {
+		if (has("href") || has("onChange") || has("formAction") || has("value") && VALUE_ELEMENTS.test(last)) return true;
+		if (CLICKISH_COMPONENT.test(last)) return true;
+	}
+	return false;
+}
+/** 要素を含むコンポーネント(名前が大文字で始まる関数・クラス) */
+function enclosingComponent(ctx, n) {
+	for (const a of ctx.ancestors(n)) {
+		if (a.type === "FunctionDeclaration" && a.id && /^[A-Z]/.test(a.id.name)) return {
+			name: a.id.name,
+			fn: a
+		};
+		if (/Function/.test(a.type)) {
+			let p = ctx.parent.get(a);
+			while (p && p.type === "CallExpression" && /^(forwardRef|memo)$/.test(calleeParts(p.callee).prop ?? "")) p = ctx.parent.get(p);
+			if (p?.type === "VariableDeclarator" && p.id.type === "Identifier" && /^[A-Z]/.test(p.id.name)) return {
+				name: p.id.name,
+				fn: a
+			};
+		}
+		if (a.type === "ClassDeclaration" && a.id) return {
+			name: a.id.name,
+			fn: a
+		};
+	}
+	return null;
+}
+/** 要素がコンポーネントの根か(return の直下 / 式本体。条件式・&& の枝を含む) */
+function isRootOf(ctx, el, fn) {
+	let p = ctx.parent.get(el);
+	while (p && [
+		"ParenthesizedExpression",
+		"ConditionalExpression",
+		"LogicalExpression"
+	].includes(p.type)) p = ctx.parent.get(p);
+	if (p === fn) return true;
+	if (p?.type === "ReturnStatement") {
+		for (const a of ctx.ancestors(p)) if (/Function|ClassMethod/.test(a.type)) return a === fn || fn.type === "ClassDeclaration" && ctx.ancestors(a).includes(fn);
+	}
+	return false;
+}
+function enclosingJsx(ctx, el, pred) {
+	for (const a of ctx.ancestors(el)) if (a.type === "JSXElement" && pred(a.openingElement)) return a.openingElement;
+	return null;
+}
+/** items.map(...) の中の要素なら配列の変数名 */
+function enclosingMapArray(ctx, el) {
+	for (const a of ctx.ancestors(el)) {
+		if (a.type === "CallExpression" && calleeParts(a.callee).prop === "map") {
+			const o = unwrap(unwrap(a.callee).object);
+			if (o?.type === "Identifier") return o.name;
+			if (o?.type === "MemberExpression" && !o.computed) return o.property.name;
+			return null;
+		}
+		if (a.type === "FunctionDeclaration") return null;
+	}
+	return null;
+}
+function nameOf(ctx, el) {
+	const o = el.openingElement;
+	const tag = tagName(o);
+	const last = tag.split(".").pop() ?? "";
+	const ok = (name, source) => usable(name) ? {
+		name,
+		source
+	} : null;
+	const value = VALUE_ELEMENTS.test(last) ? attrStatic(o, "value") : null;
+	const withValue = (r) => value && usable(`${r.name}:${value}`) && !r.name.includes(":") ? {
+		name: `${r.name}:${value}`,
+		source: `${r.source}+value`
+	} : r;
+	for (const p of HANDLER_PROPS) {
+		const e = attrExpr(o, p);
+		if (!e) continue;
+		const r = handlerName(e, ctx);
+		if (r && usable(r.name)) return withValue(r);
+	}
+	const fa = attrExpr(o, "formAction");
+	if (fa) {
+		const r = handlerName(fa, ctx);
+		if (r && usable(r.name)) return {
+			name: r.name,
+			source: "action"
+		};
+	}
+	for (const p of [
+		"id",
+		"data-gtm-click",
+		"data-gtm",
+		"data-gtm-id",
+		"name"
+	]) {
+		if (p === "name" && tag !== "input" && tag !== "select" && tag !== "button") continue;
+		const r = ok(attrStatic(o, p), p === "name" ? "name-attr" : "id");
+		if (r) return r;
+	}
+	for (const p of ["href", "to"]) {
+		const e = attrExpr(o, p);
+		if (e) {
+			const r = ok(normalizePath(pathTemplate(e)), "path");
+			if (r) return r;
+		}
+	}
+	if (value) {
+		const group = enclosingJsx(ctx, el, (g) => GROUP_HANDLER_PROPS.some((p) => jsxAttr(g, p)));
+		if (group) for (const p of GROUP_HANDLER_PROPS) {
+			const e = attrExpr(group, p);
+			if (!e) continue;
+			const r = handlerName(e, ctx);
+			if (r && usable(r.name)) return withValue(r);
+		}
+		if (usable(value)) return {
+			name: value,
+			source: "value"
+		};
+	}
+	const type = attrStatic(o, "type");
+	if (tag === "button" && (type === null || type === "submit") || tag === "input" && type === "submit" || /Submit/.test(last)) {
+		const form = enclosingJsx(ctx, el, (f) => tagName(f) === "form" || /Form$/.test(tagName(f)));
+		if (form) for (const p of ["action", "onSubmit"]) {
+			const e = attrExpr(form, p);
+			if (!e) continue;
+			const r = handlerName(e, ctx);
+			if (r && usable(r.name)) return {
+				name: r.name,
+				source: "form"
+			};
+		}
+	}
+	const arr = enclosingMapArray(ctx, el);
+	if (arr && !GENERIC_ARRAY.test(arr)) {
+		const r = ok(arr, "map-array");
+		if (r) return r;
+	}
+	if (/^[A-Z]/.test(last) && !tag.includes(".") && !GENERIC_COMPONENT.test(last) && !/^(Select|Tabs|TabsList|Dialog|Menu)/.test(last)) {
+		const r = ok(last, "component");
+		if (r) return r;
+	}
+	const enc = enclosingComponent(ctx, el);
+	if (enc && !GENERIC_COMPONENT.test(enc.name)) {
+		const r = ok(enc.name, isRootOf(ctx, el, enc.fn) ? "own-component" : "context");
+		if (r) return r;
+	}
+	if (arr) {
+		const r = ok(arr, "map-array");
+		if (r) return r;
+	}
+	return {
+		name: null,
+		source: "none"
+	};
+}
+/** プログラム中の JSX 要素ごとに名前を決める(既定ではクリックされうる要素だけを返す) */
+function extractFromProgram(program, options = {}) {
+	const ctx = new Ctx(program);
+	const out = [];
+	const visit = (n) => {
+		if (n.type === "JSXElement") {
+			const o = n.openingElement;
+			const clickable = isClickable(o);
+			if (clickable || options.all) {
+				const { name, source } = nameOf(ctx, n);
+				let receiver = null;
+				const enc = enclosingComponent(ctx, n);
+				if (enc && /^[a-z]/.test(tagName(o)) && isRootOf(ctx, n, enc.fn)) {
+					const p0 = enc.fn.params?.[0];
+					receiver = p0?.type === "ObjectPattern" ? {
+						kind: "pattern",
+						pattern: p0
+					} : p0?.type === "Identifier" ? {
+						kind: "ident",
+						name: p0.name
+					} : { kind: "none" };
+				}
+				out.push({
+					element: n,
+					tag: tagName(o),
+					name,
+					source,
+					label: labelOf(n),
+					clickable,
+					receiver
+				});
+			}
+		}
+		for (const c of children(n)) visit(c);
+	};
+	visit(program);
+	return out;
+}
+//#endregion
+//#region ../build-names/src/element-name/transform.ts
+/** 書く属性。@auspex-ai/core の ELEMENT_REF_ATTR(読む側)と同じ値(test/element-names.test.ts で一致を確かめる) */
+const REF_ATTR = "data-auspex-ref";
+/** ラベル(NAL-124)の参照。@auspex-ai/core の LABEL_REF_ATTR(読む側)と同じ値(test/element-names.test.ts で一致を確かめる) */
+const LABEL_REF_ATTR = "data-auspex-label-ref";
+/** 手書きは常に消す。アイコンの属性(#50 段階 2)も同じ理由 */
+const HAND_WRITTEN = /* @__PURE__ */ new Set([
+	REF_ATTR,
+	LABEL_REF_ATTR,
+	"data-auspex-name",
+	require_transform.ICON_REF_ATTR,
+	require_transform.LEGACY_ICON_ATTR
+]);
+/** 定義側で受け取った参照を入れる変数(この名前がソースにあれば変換済みとみなす) */
+const RECEIVED = "__auspexRef";
+/** 同じく、ラベルの参照を入れる変数 */
+const RECEIVED_LABEL = "__auspexLabelRef";
+const startOf = (n) => n.start ?? 0;
+const endOf = (n) => n.end ?? 0;
+/** JSX を含みうるファイルか(解析する前の絞り込み) */
+function mayHaveElements(source, file) {
+	return !file.endsWith(".ts") && /<[A-Za-z]/.test(source) && !source.includes(RECEIVED);
+}
+/** 手書きの属性を消す対象になりうるソースか(mayHaveElements とは別の判定。.ts など JSX を含まないファイルも) */
+function mayHaveHandWritten(source) {
+	return source.includes("data-auspex-ref") || source.includes("data-auspex-label-ref") || source.includes("data-auspex-name") || source.includes("data-auspex-icon");
+}
+function passedValue(receiver, attr, received) {
+	if (receiver.kind === "pattern") return received;
+	if (receiver.kind === "ident") return `${receiver.name}?.[${JSON.stringify(attr)}]`;
+	return null;
+}
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+/** オブジェクトリテラルのプロパティのキーが、リテラルで書かれた手書きの属性名か */
+function isHandWrittenKey(p) {
+	if (p.type === "SpreadElement") return false;
+	const k = p.key;
+	if (k.type === "StringLiteral") return HAND_WRITTEN.has(k.value);
+	return !p.computed && k.type === "Identifier" && HAND_WRITTEN.has(k.name);
+}
+/** JSX の属性と、オブジェクトリテラルのリテラルのキー(スプレッド・createElement・jsx() の props を含む)から手書きの属性を消す */
+function removeHandWritten(node, s) {
+	if (node.type === "JSXOpeningElement") {
+		for (const a of node.attributes) if (a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && HAND_WRITTEN.has(a.name.name)) s.remove(startOf(a), endOf(a));
+	}
+	if (node.type === "ObjectExpression") {
+		const props = node.properties;
+		for (let i = 0; i < props.length; i++) {
+			const p = props[i];
+			if (!p || !isHandWrittenKey(p)) continue;
+			let j = i;
+			while (j + 1 < props.length && props[j + 1] && isHandWrittenKey(props[j + 1])) j++;
+			const first = props[i];
+			const last = props[j];
+			const next = props[j + 1];
+			const prev = props[i - 1];
+			if (next) s.remove(startOf(first), startOf(next));
+			else if (prev) s.remove(endOf(prev), endOf(last));
+			else s.remove(startOf(first), endOf(last));
+			i = j;
+		}
+	}
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const v = node[key];
+		for (const c of Array.isArray(v) ? v : [v]) if (c && typeof c.type === "string") removeHandWritten(c, s);
+	}
+}
+/** 手書きの属性の削除だけを `s` に積む(strip のみのモード。JSX を含まないファイルも) */
+function stripHandWritten(program, s) {
+	removeHandWritten(program, s);
+}
+/**
+* 要素の参照の書き込みを `s` に積む(手書きの属性の削除は stripHandWritten で別に行う)。書いた名前とラベルを返す。
+* `refOf` は名前(kind = 'element')・ラベル(kind = 'label')から参照を計算する(鍵はここに渡らない)。
+* ラベルの参照(data-auspex-label-ref)も要素の参照と同じ仕組みで書く
+*/
+function applyElementNames(program, s, refOf) {
+	const written = /* @__PURE__ */ new Set();
+	const writtenLabels = /* @__PURE__ */ new Set();
+	const patched = /* @__PURE__ */ new Set();
+	for (const { element, tag, name, label, receiver } of extractFromProgram(program)) {
+		const dom = /^[a-z]/.test(tag);
+		const attrs = [];
+		const write = (attr, received, own) => {
+			const passed = receiver ? passedValue(receiver, attr, received) : null;
+			const fallback = own ?? (dom ? "\"\"" : null);
+			const value = passed && fallback ? `${passed} ?? ${fallback}` : passed ?? fallback;
+			return value === null ? null : { value };
+		};
+		const refValue = write(REF_ATTR, RECEIVED, name === null ? null : JSON.stringify(refOf(name, "element")));
+		const labelValue = write(LABEL_REF_ATTR, RECEIVED_LABEL, label === null ? null : JSON.stringify(refOf(label, "label")));
+		if (refValue === null && labelValue === null) continue;
+		if (refValue && name !== null) written.add(name);
+		if (labelValue && label !== null) writtenLabels.add(label);
+		if (receiver?.kind === "pattern" && !patched.has(receiver.pattern)) {
+			s.appendRight(startOf(receiver.pattern) + 1, ` ${JSON.stringify(REF_ATTR)}: ${RECEIVED}, ${JSON.stringify(LABEL_REF_ATTR)}: ${RECEIVED_LABEL},`);
+			patched.add(receiver.pattern);
+		}
+		if (refValue) attrs.push(` ${REF_ATTR}={${refValue.value}}`);
+		if (labelValue) attrs.push(` ${LABEL_REF_ATTR}={${labelValue.value}}`);
+		s.appendLeft(endOf(element.openingElement.name), attrs.join(""));
+	}
+	return {
+		names: [...written],
+		labels: [...writtenLabels]
+	};
+}
+//#endregion
+//#region ../build-names/src/transform.ts
+/** 変換が不要なら null */
+function transformNames(source, file, options = {}) {
+	const refOf = options.elementNames === "strip" ? void 0 : options.refOf;
+	const icons = refOf !== void 0 && options.iconNames !== false && require_transform.mayHaveIcons(source);
+	const elements = refOf !== void 0 && options.elementAttrs !== false && mayHaveElements(source, file);
+	const strip = mayHaveHandWritten(source);
+	if (!icons && !elements && !strip) return null;
+	const program = require_transform.parseSource(source, file);
+	if (!program) return null;
+	const s = new magic_string.MagicString(source);
+	if (strip) stripHandWritten(program, s);
+	const { names, labels } = elements && refOf ? applyElementNames(program, s, (name, kind) => refOf(name, kind)) : {
+		names: [],
+		labels: []
+	};
+	const iconNames = icons && refOf ? require_transform.applyIconNames(program, source, file, s, (name) => refOf(name, "icon")) : [];
+	if (!s.hasChanged()) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: file,
+			includeContent: true
+		}),
+		names,
+		icons: iconNames,
+		labels
+	};
+}
+//#endregion
+//#region src/icon-name/loader.ts
+function iconNameLoader(source, inputMap) {
+	const file = this.resourcePath;
+	const skip = /[\\/]node_modules[\\/]/.test(file) || /\.svg(\.|$)/i.test(file);
+	const options = this.getOptions?.() ?? {};
+	const nameOptions = { elementNames: "strip" };
+	if (options.iconNames !== void 0) nameOptions.iconNames = options.iconNames;
+	if (options.elementAttrs !== void 0) nameOptions.elementAttrs = options.elementAttrs;
+	const refOf = skip ? null : require_transform.refOfFromEnv(options);
+	if (refOf) {
+		nameOptions.elementNames = "refs";
+		nameOptions.refOf = refOf;
+	}
+	const out = skip ? null : transformNames(source, file, nameOptions);
+	if (out && (out.names.length > 0 || out.icons.length > 0 || out.labels.length > 0) && options.fragmentsDir) require_transform.writeFragment(node_path.default.resolve(this.rootContext ?? process.cwd(), options.fragmentsDir), file, {
+		names: out.names,
+		icons: out.icons,
+		...out.labels.length > 0 ? { labels: out.labels } : {}
+	});
+	if (!out) this.callback(null, source, inputMap);
+	else this.callback(null, out.code, out.map);
+}
+//#endregion
+module.exports = iconNameLoader;