boss-css 0.0.1 → 0.0.2

package/dist/compile/prepared.cjs

@@ -0,0 +1,88 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_jsx = require('./jsx.cjs');
+let _swc_core = require("@swc/core");
+
+//#region src/compile/prepared.ts
+function scanPrepared(source, options) {
+	const parsed = (0, _swc_core.parseSync)(source, {
+		syntax: options.isTs ? "typescript" : "ecmascript",
+		tsx: options.isTs && options.isJsx,
+		jsx: !options.isTs && options.isJsx
+	});
+	const definitions = [];
+	const usages = [];
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach(visit);
+			return;
+		}
+		const current = node;
+		if (isPreparedAssignment(current)) {
+			const prepared = extractPreparedDefinition(current.expression);
+			if (prepared) definitions.push(prepared);
+		}
+		if (current.type === "JSXElement") {
+			const preparedUsage = extractPreparedUsage(current);
+			if (preparedUsage) usages.push(preparedUsage);
+		}
+		for (const key of Object.keys(current)) visit(current[key]);
+	};
+	visit(parsed);
+	return {
+		definitions,
+		usages
+	};
+}
+const extractPreparedDefinition = (expression) => {
+	const assignment = expression;
+	const name = assignment.left?.property?.value;
+	const objectExpression = assignment.right ? getPreparedObjectExpression(assignment.right) : null;
+	if (!name || !objectExpression) return null;
+	const definition = require_jsx.buildPreparedDefinition(objectExpression);
+	if (!definition) return null;
+	return {
+		name,
+		definition,
+		inlineable: require_jsx.isPreparedDefinitionStatic(definition)
+	};
+};
+const extractPreparedUsage = (element) => {
+	const name = element.opening.name;
+	if (name.type !== "JSXMemberExpression" || name.object.type !== "Identifier" || name.object.value !== "$$" || name.property.type !== "Identifier" || !/^[A-Z]/.test(name.property.value)) return null;
+	const hasSpread = element.opening.attributes.some((attr) => attr.type === "SpreadElement");
+	return {
+		name: name.property.value,
+		hasSpread
+	};
+};
+const isPreparedAssignmentExpression = (node) => {
+	if (node.type !== "AssignmentExpression") return false;
+	const assignment = node;
+	if (assignment.operator && assignment.operator !== "=") return false;
+	const left = assignment.left;
+	if (!left || left.type !== "MemberExpression") return false;
+	if (left.object?.type !== "Identifier" || left.object.value !== "$$") return false;
+	const property = left.property;
+	if (!property || property.type !== "Identifier") return false;
+	if (!property.value || !/^[A-Z]/.test(property.value)) return false;
+	return Boolean(assignment.right && getPreparedObjectExpression(assignment.right));
+};
+const isPreparedAssignment = (node) => {
+	if (node.type !== "ExpressionStatement") return false;
+	const statement = node;
+	return Boolean(statement.expression && isPreparedAssignmentExpression(statement.expression));
+};
+const getPreparedObjectExpression = (expression) => {
+	if (expression.type === "CallExpression" && expression.arguments.length === 1) {
+		const callee = expression.callee;
+		if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$") {
+			const arg = expression.arguments[0].expression;
+			if (arg.type === "ObjectExpression") return arg;
+		}
+	}
+	return null;
+};
+
+//#endregion
+exports.scanPrepared = scanPrepared;

package/dist/compile/prepared.mjs

@@ -0,0 +1,87 @@
+import { buildPreparedDefinition, isPreparedDefinitionStatic } from "./jsx.mjs";
+import { parseSync } from "@swc/core";
+
+//#region src/compile/prepared.ts
+function scanPrepared(source, options) {
+	const parsed = parseSync(source, {
+		syntax: options.isTs ? "typescript" : "ecmascript",
+		tsx: options.isTs && options.isJsx,
+		jsx: !options.isTs && options.isJsx
+	});
+	const definitions = [];
+	const usages = [];
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach(visit);
+			return;
+		}
+		const current = node;
+		if (isPreparedAssignment(current)) {
+			const prepared = extractPreparedDefinition(current.expression);
+			if (prepared) definitions.push(prepared);
+		}
+		if (current.type === "JSXElement") {
+			const preparedUsage = extractPreparedUsage(current);
+			if (preparedUsage) usages.push(preparedUsage);
+		}
+		for (const key of Object.keys(current)) visit(current[key]);
+	};
+	visit(parsed);
+	return {
+		definitions,
+		usages
+	};
+}
+const extractPreparedDefinition = (expression) => {
+	const assignment = expression;
+	const name = assignment.left?.property?.value;
+	const objectExpression = assignment.right ? getPreparedObjectExpression(assignment.right) : null;
+	if (!name || !objectExpression) return null;
+	const definition = buildPreparedDefinition(objectExpression);
+	if (!definition) return null;
+	return {
+		name,
+		definition,
+		inlineable: isPreparedDefinitionStatic(definition)
+	};
+};
+const extractPreparedUsage = (element) => {
+	const name = element.opening.name;
+	if (name.type !== "JSXMemberExpression" || name.object.type !== "Identifier" || name.object.value !== "$$" || name.property.type !== "Identifier" || !/^[A-Z]/.test(name.property.value)) return null;
+	const hasSpread = element.opening.attributes.some((attr) => attr.type === "SpreadElement");
+	return {
+		name: name.property.value,
+		hasSpread
+	};
+};
+const isPreparedAssignmentExpression = (node) => {
+	if (node.type !== "AssignmentExpression") return false;
+	const assignment = node;
+	if (assignment.operator && assignment.operator !== "=") return false;
+	const left = assignment.left;
+	if (!left || left.type !== "MemberExpression") return false;
+	if (left.object?.type !== "Identifier" || left.object.value !== "$$") return false;
+	const property = left.property;
+	if (!property || property.type !== "Identifier") return false;
+	if (!property.value || !/^[A-Z]/.test(property.value)) return false;
+	return Boolean(assignment.right && getPreparedObjectExpression(assignment.right));
+};
+const isPreparedAssignment = (node) => {
+	if (node.type !== "ExpressionStatement") return false;
+	const statement = node;
+	return Boolean(statement.expression && isPreparedAssignmentExpression(statement.expression));
+};
+const getPreparedObjectExpression = (expression) => {
+	if (expression.type === "CallExpression" && expression.arguments.length === 1) {
+		const callee = expression.callee;
+		if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$") {
+			const arg = expression.arguments[0].expression;
+			if (arg.type === "ObjectExpression") return arg;
+		}
+	}
+	return null;
+};
+
+//#endregion
+export { scanPrepared };

package/dist/compile/runtime.cjs

@@ -0,0 +1,33 @@
+const require_dictionary = require('../api/dictionary.cjs');
+const require_vars = require('../use/token/vars.cjs');
+
+//#region src/compile/runtime.ts
+const createBossValue = (unit) => {
+	return (value) => {
+		if (Array.isArray(value)) return value.map((v) => typeof v === "number" && v !== 0 ? `${v}${unit}` : v).join(" ");
+		if (typeof value === "number") return value !== 0 ? `${value}${unit}` : 0;
+		return value;
+	};
+};
+const createBossTokenVars = (unit, prefix = "") => {
+	const toValue = (value, property) => {
+		const propertyName = property;
+		if (Array.isArray(value)) return value.map((v) => toValue(v, propertyName)).join(" ");
+		if (typeof value === "number" || require_dictionary.isNumericValue(value)) {
+			const numeric = typeof value === "number" ? value : Number(value);
+			if (propertyName && require_dictionary.unitlessProperties.has(propertyName)) return numeric === 0 ? 0 : `${numeric}`;
+			return numeric === 0 ? 0 : `${numeric}${unit}`;
+		}
+		if (value == null) return null;
+		return String(value);
+	};
+	const builder = require_vars.createTokenVars({
+		prefix,
+		toValue
+	});
+	return (input) => builder(input);
+};
+
+//#endregion
+exports.createBossTokenVars = createBossTokenVars;
+exports.createBossValue = createBossValue;

package/dist/compile/runtime.mjs

@@ -0,0 +1,32 @@
+import { isNumericValue, unitlessProperties } from "../api/dictionary.mjs";
+import { createTokenVars } from "../use/token/vars.mjs";
+
+//#region src/compile/runtime.ts
+const createBossValue = (unit) => {
+	return (value) => {
+		if (Array.isArray(value)) return value.map((v) => typeof v === "number" && v !== 0 ? `${v}${unit}` : v).join(" ");
+		if (typeof value === "number") return value !== 0 ? `${value}${unit}` : 0;
+		return value;
+	};
+};
+const createBossTokenVars = (unit, prefix = "") => {
+	const toValue = (value, property) => {
+		const propertyName = property;
+		if (Array.isArray(value)) return value.map((v) => toValue(v, propertyName)).join(" ");
+		if (typeof value === "number" || isNumericValue(value)) {
+			const numeric = typeof value === "number" ? value : Number(value);
+			if (propertyName && unitlessProperties.has(propertyName)) return numeric === 0 ? 0 : `${numeric}`;
+			return numeric === 0 ? 0 : `${numeric}${unit}`;
+		}
+		if (value == null) return null;
+		return String(value);
+	};
+	const builder = createTokenVars({
+		prefix,
+		toValue
+	});
+	return (input) => builder(input);
+};
+
+//#endregion
+export { createBossTokenVars, createBossValue };

package/dist/compile/transform.cjs

@@ -0,0 +1,371 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_framework = require('../shared/framework.cjs');
+const require_classname = require('./classname.cjs');
+const require_jsx = require('./jsx.cjs');
+const require_customCss = require('../shared/customCss.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let _swc_core = require("@swc/core");
+
+//#region src/compile/transform.ts
+const jsxExtensions = new Set([
+	".jsx",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs"
+]);
+const tsExtensions = new Set([".ts", ".tsx"]);
+const fallbackSpan = {
+	start: 0,
+	end: 0,
+	ctxt: 0
+};
+const ensureSpan = (span) => {
+	if (!span) return fallbackSpan;
+	if (typeof span.ctxt === "number") return span;
+	return {
+		...span,
+		ctxt: 0
+	};
+};
+const createVoidExpression = (span) => {
+	const safeSpan = ensureSpan(span);
+	return {
+		type: "UnaryExpression",
+		span: safeSpan,
+		operator: "void",
+		argument: {
+			type: "NumericLiteral",
+			span: safeSpan,
+			value: 0
+		}
+	};
+};
+async function transformSource(source, options) {
+	const ext = node_path.default.extname(options.filename);
+	const isTs = tsExtensions.has(ext);
+	const isJsx = jsxExtensions.has(ext);
+	const parsed = (0, _swc_core.parseSync)(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const state = {
+		api: options.api,
+		classNameProp: require_framework.getClassNameProp(options.api.framework),
+		compile: options.compile,
+		filename: options.filename,
+		classNameMapper: options.classNameMapper ?? null,
+		needsRuntime: false,
+		needsValueHelper: false,
+		needsTokenVarsHelper: false,
+		replacedElements: 0,
+		preparedLocal: new Map(options.preparedLocal ?? []),
+		preparedGlobal: options.preparedGlobal ?? /* @__PURE__ */ new Map(),
+		preparedRuntime: options.preparedRuntime ?? /* @__PURE__ */ new Set(),
+		customCssBlocks: []
+	};
+	const transformed = await transformProgram(parsed, state);
+	normalizeSpans(transformed);
+	if (state.customCssBlocks.length) state.api.css?.syncCustomBlocks?.(state.filename, state.customCssBlocks);
+	return {
+		code: (0, _swc_core.printSync)(transformed).code,
+		needsRuntime: state.needsRuntime,
+		needsValueHelper: state.needsValueHelper,
+		replacedElements: state.replacedElements
+	};
+}
+const normalizeSpans = (node) => {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		node.forEach(normalizeSpans);
+		return;
+	}
+	const record = node;
+	if (typeof record.type === "string" && record.span && typeof record.ctxt !== "number") record.ctxt = 0;
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "span" && value && typeof value === "object") {
+			const span = value;
+			if (typeof span.start === "number" && typeof span.end === "number" && typeof span.ctxt !== "number") span.ctxt = 0;
+			continue;
+		}
+		normalizeSpans(value);
+	}
+};
+const transformProgram = async (program, state) => {
+	const transformed = await transformNode(program, state);
+	const needsValueHelper = state.needsValueHelper && !hasValueHelper(transformed);
+	const needsTokenVarsHelper = state.needsTokenVarsHelper && !hasTokenVarsHelper(transformed);
+	if (needsValueHelper || needsTokenVarsHelper) {
+		const helper = createRuntimeHelpersProgram({
+			unit: state.api.unit ?? "px",
+			prefix: state.api.selectorPrefix ?? "",
+			needsValueHelper,
+			needsTokenVarsHelper
+		});
+		if ("body" in transformed) transformed.body = [...helper.body, ...transformed.body];
+	}
+	if (!state.needsRuntime && "body" in transformed) transformed.body = transformed.body.filter((node) => {
+		if (node.type !== "ImportDeclaration") return true;
+		const source = node.source.value;
+		return !isBossImport(source);
+	});
+	return transformed;
+};
+const transformNode = async (node, state, context = {}) => {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) {
+		const mapped = [];
+		for (const child of node) {
+			const next = await transformNode(child, state, context);
+			if (next === null) continue;
+			mapped.push(next);
+		}
+		return mapped;
+	}
+	const current = node;
+	const mapToken = state.classNameMapper ? (token) => state.classNameMapper?.get(token) : void 0;
+	let keepPreparedMarker = false;
+	if (current.type === "ExpressionStatement") {
+		const expression = current.expression;
+		if (expression) {
+			const cssText = require_customCss.extractCustomCssText(expression, state.api);
+			if (cssText != null) {
+				const span = ensureSpan(expression.span);
+				state.customCssBlocks.push({
+					start: span.start,
+					end: span.end,
+					cssText
+				});
+				return null;
+			}
+		}
+	}
+	if (current.type === "CallExpression" || current.type === "TaggedTemplateExpression") {
+		const cssText = require_customCss.extractCustomCssText(current, state.api);
+		if (cssText != null) {
+			const span = ensureSpan(current.span);
+			state.customCssBlocks.push({
+				start: span.start,
+				end: span.end,
+				cssText
+			});
+			return createVoidExpression(span);
+		}
+	}
+	if (isPreparedAssignment(current)) {
+		const prepared = parsePreparedDefinition(current.expression);
+		if (prepared) {
+			state.preparedLocal.set(prepared.name, prepared.definition);
+			if (state.preparedRuntime.has(prepared.name)) {
+				state.needsRuntime = true;
+				keepPreparedMarker = true;
+			} else return null;
+		}
+	}
+	if (isPreparedAssignmentExpression(current)) {
+		const prepared = parsePreparedDefinition(current);
+		if (prepared) {
+			state.preparedLocal.set(prepared.name, prepared.definition);
+			state.needsRuntime = true;
+			keepPreparedMarker = true;
+		}
+	}
+	if (state.classNameMapper && !context.inModuleSpecifier) {
+		if (current.type === "StringLiteral") {
+			const literal = current;
+			const rewritten = require_classname.rewriteClassNameTokensWithMap(literal.value, mapToken);
+			if (rewritten !== literal.value) {
+				literal.value = rewritten;
+				literal.raw = JSON.stringify(rewritten);
+			}
+		}
+		if (current.type === "TemplateLiteral" && Array.isArray(current.expressions) && current.expressions.length === 0 && Array.isArray(current.quasis) && current.quasis.length) {
+			const firstQuasi = current.quasis[0];
+			if (firstQuasi) {
+				const cooked = firstQuasi.cooked ?? "";
+				const rewritten = require_classname.rewriteClassNameTokensWithMap(cooked, mapToken);
+				if (rewritten !== cooked) {
+					firstQuasi.cooked = rewritten;
+					firstQuasi.raw = rewritten;
+				}
+			}
+		}
+	}
+	const isBossElement = current.type === "JSXElement" && isBossJsxElement(current);
+	const isBossMarkerCall = (() => {
+		if (current.type !== "CallExpression") return false;
+		const call = current;
+		if (call.callee.type !== "MemberExpression") return false;
+		if (call.callee.object?.type !== "Identifier" || call.callee.object.value !== "$$") return false;
+		if (call.callee.property?.type !== "Identifier" || call.callee.property.value !== "$") return false;
+		return true;
+	})();
+	for (const key of Object.keys(current)) {
+		let childContext = context.inJsxChild && current.type !== "JSXElement" ? {
+			...context,
+			inJsxChild: false
+		} : context;
+		if (isBossElement) childContext = {
+			...childContext,
+			inBossElement: true
+		};
+		if (current.type === "JSXElement" && key === "children") childContext = {
+			...childContext,
+			inJsxChild: true
+		};
+		if (keepPreparedMarker) {
+			if (current.type === "ExpressionStatement" && key === "expression") childContext = {
+				...childContext,
+				keepBossMarker: true
+			};
+			if (current.type === "AssignmentExpression" && key === "right") childContext = {
+				...childContext,
+				keepBossMarker: true
+			};
+		}
+		if (isBossMarkerCall && key === "callee") childContext = {
+			...childContext,
+			inBossMarkerCall: true
+		};
+		if (current.type === "JSXAttribute" && key === "value") {
+			const attrName = getJsxAttributeName(current);
+			const isBossProp = Boolean(context.inBossElement && attrName && state.api.dictionary.resolve(attrName).descriptor);
+			childContext = {
+				...childContext,
+				inBossPropValue: isBossProp
+			};
+		}
+		if (current.type === "CallExpression" && key === "arguments") {
+			const callee = current.callee;
+			const args = current.arguments;
+			if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$" && args.length === 1 && args[0].expression.type === "ObjectExpression") childContext = {
+				...childContext,
+				inBossPropValue: true
+			};
+		}
+		if ((current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source") childContext = {
+			...childContext,
+			inModuleSpecifier: true
+		};
+		current[key] = await transformNode(current[key], state, childContext);
+	}
+	if (current.type === "JSXElement") {
+		const element = current;
+		require_classname.rewriteClassNameTokensInElement(element, state.classNameProp, mapToken);
+		return require_jsx.transformJsxElement(element, state, context);
+	}
+	if (current.type === "CallExpression") {
+		const expr = current;
+		const callee = expr.callee;
+		const isBossMarker = callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$";
+		if (isBossMarker && context.keepBossMarker) return current;
+		if (isBossMarker && expr.arguments.length === 1 && expr.arguments[0].expression.type === "ObjectExpression") return expr.arguments[0].expression;
+		if (isBossMarker && expr.arguments.length === 1) {
+			const arg = expr.arguments[0].expression;
+			if (arg.type === "StringLiteral") {
+				const rewritten = require_classname.rewriteClassNameTokensWithMap(arg.value, mapToken);
+				arg.value = rewritten;
+				arg.raw = JSON.stringify(rewritten);
+			} else if (arg.type === "TemplateLiteral" && arg.expressions.length === 0) {
+				const rewritten = require_classname.rewriteClassNameTokensWithMap(arg.quasis[0].cooked ?? "", mapToken);
+				arg.quasis[0].cooked = rewritten;
+				arg.quasis[0].raw = rewritten;
+			}
+			return arg;
+		}
+		if (callee.type === "Identifier" && callee.value === "$$") state.needsRuntime = true;
+	}
+	if (current.type === "MemberExpression") {
+		if (context.inBossPropValue) return current;
+		if (context.inBossMarkerCall) return current;
+		const member = current;
+		if (member.object?.type === "Identifier" && member.object.value === "$$") state.needsRuntime = true;
+	}
+	return current;
+};
+const isBossJsxElement = (node) => {
+	const name = node.opening.name;
+	if (name.type === "Identifier" && name.value === "$$") return true;
+	if (name.type === "JSXMemberExpression" && name.object.type === "Identifier" && name.object.value === "$$") return true;
+	return false;
+};
+const getJsxAttributeName = (node) => {
+	if (node.name?.type === "Identifier") return node.name.value;
+	return null;
+};
+const createRuntimeHelpersProgram = ({ unit, prefix, needsValueHelper, needsTokenVarsHelper }) => {
+	const imports = [];
+	const lines = [];
+	if (needsValueHelper) {
+		imports.push("createBossValue");
+		lines.push(`const __bossValue = createBossValue(${JSON.stringify(unit)});`);
+	}
+	if (needsTokenVarsHelper) {
+		imports.push("createBossTokenVars");
+		lines.push(`const __bossTokenVars = createBossTokenVars(${JSON.stringify(unit)}, ${JSON.stringify(prefix)});`);
+	}
+	return (0, _swc_core.parseSync)(`import { ${imports.join(", ")} } from "boss-css/compile/runtime";
+${lines.join("\n")}`, { syntax: "ecmascript" });
+};
+const hasValueHelper = (program) => {
+	if (!("body" in program)) return false;
+	return program.body.some((node) => {
+		if (node.type !== "VariableDeclaration") return false;
+		return node.declarations.some((decl) => decl.id.type === "Identifier" && decl.id.value === "__bossValue");
+	});
+};
+const hasTokenVarsHelper = (program) => {
+	if (!("body" in program)) return false;
+	return program.body.some((node) => {
+		if (node.type !== "VariableDeclaration") return false;
+		return node.declarations.some((decl) => decl.id.type === "Identifier" && decl.id.value === "__bossTokenVars");
+	});
+};
+const isBossImport = (source) => {
+	if (source === "boss-css/compile/runtime") return false;
+	return source.includes(".bo$$/server") || source === "boss-css" || source.startsWith("boss-css/") || source === "boss-css/parser/jsx/runtime" || source === "boss-css/runtime" || source.startsWith("boss-css/runtime/") || source.startsWith("@boss-css/");
+};
+const isPreparedAssignmentExpression = (node) => {
+	if (node.type !== "AssignmentExpression") return false;
+	const assignment = node;
+	if (assignment.operator && assignment.operator !== "=") return false;
+	const left = assignment.left;
+	if (!left || left.type !== "MemberExpression") return false;
+	if (left.object?.type !== "Identifier" || left.object.value !== "$$") return false;
+	const property = left.property;
+	if (!property || property.type !== "Identifier") return false;
+	if (!property.value || !/^[A-Z]/.test(property.value)) return false;
+	return Boolean(assignment.right && getPreparedObjectExpression(assignment.right));
+};
+const isPreparedAssignment = (node) => {
+	if (node.type !== "ExpressionStatement") return false;
+	const statement = node;
+	return Boolean(statement.expression && isPreparedAssignmentExpression(statement.expression));
+};
+const parsePreparedDefinition = (expression) => {
+	const assignment = expression;
+	const name = assignment.left?.property?.value;
+	const objectExpression = assignment.right ? getPreparedObjectExpression(assignment.right) : null;
+	if (!name || !objectExpression) return null;
+	const definition = require_jsx.buildPreparedDefinition(objectExpression);
+	if (!definition) return null;
+	return {
+		name,
+		definition
+	};
+};
+const getPreparedObjectExpression = (expression) => {
+	if (expression.type === "CallExpression" && expression.arguments.length === 1) {
+		const callee = expression.callee;
+		if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$") {
+			const arg = expression.arguments[0].expression;
+			if (arg.type === "ObjectExpression") return arg;
+		}
+	}
+	return null;
+};
+
+//#endregion
+exports.transformSource = transformSource;