@soda-gql/babel-transformer 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1382 @@
+import { formatPluginError, resolveCanonicalId } from "@soda-gql/plugin-common";
+import { err, ok } from "neverthrow";
+import * as t from "@babel/types";
+import { types } from "@babel/core";
+import { createCanonicalTracker } from "@soda-gql/common";
+import _generate from "@babel/generator";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import { createGraphqlSystemIdentifyHelper } from "@soda-gql/builder";
+
+//#region packages/babel-transformer/src/ast/analysis.ts
+const extractGqlCall = ({ nodePath, filename, metadata, getArtifact }) => {
+	const callExpression = nodePath.node;
+	const meta = metadata.get(callExpression);
+	if (!meta) return err(createMetadataMissingError({ filename }));
+	const canonicalId = resolveCanonicalId(filename, meta.astPath);
+	const artifact = getArtifact(canonicalId);
+	if (!artifact) return err(createArtifactMissingError({
+		filename,
+		canonicalId
+	}));
+	if (artifact.type === "fragment") return ok({
+		nodePath,
+		canonicalId,
+		type: "fragment",
+		artifact
+	});
+	if (artifact.type === "operation") return ok({
+		nodePath,
+		canonicalId,
+		type: "operation",
+		artifact
+	});
+	return err(createUnsupportedArtifactTypeError({
+		filename,
+		canonicalId,
+		artifactType: artifact.type
+	}));
+};
+const createMetadataMissingError = ({ filename }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_METADATA_NOT_FOUND",
+	message: `No GraphQL metadata found for ${filename}`,
+	cause: { filename },
+	filename
+});
+const createArtifactMissingError = ({ filename, canonicalId }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_ANALYSIS_ARTIFACT_NOT_FOUND",
+	message: `No builder artifact found for canonical ID ${canonicalId}`,
+	cause: {
+		filename,
+		canonicalId
+	},
+	filename,
+	canonicalId
+});
+const createUnsupportedArtifactTypeError = ({ filename, canonicalId, artifactType }) => ({
+	type: "PluginError",
+	stage: "analysis",
+	code: "SODA_GQL_UNSUPPORTED_ARTIFACT_TYPE",
+	message: `Unsupported builder artifact type "${artifactType}" for canonical ID ${canonicalId}`,
+	cause: {
+		filename,
+		canonicalId,
+		artifactType
+	},
+	filename,
+	canonicalId,
+	artifactType
+});
+
+//#endregion
+//#region packages/babel-transformer/src/ast/ast.ts
+const createUnsupportedValueTypeError = (valueType) => ({
+	type: "PluginError",
+	stage: "transform",
+	code: "SODA_GQL_TRANSFORM_UNSUPPORTED_VALUE_TYPE",
+	message: `Unsupported value type: ${valueType}`,
+	cause: { valueType },
+	valueType
+});
+const buildLiteralFromValue = (value) => {
+	if (value === null) return ok(t.nullLiteral());
+	if (typeof value === "string") return ok(t.stringLiteral(value));
+	if (typeof value === "number") return ok(t.numericLiteral(value));
+	if (typeof value === "boolean") return ok(t.booleanLiteral(value));
+	if (Array.isArray(value)) {
+		const elements = [];
+		for (const item of value) {
+			const result = buildLiteralFromValue(item);
+			if (result.isErr()) return result;
+			elements.push(result.value);
+		}
+		return ok(t.arrayExpression(elements));
+	}
+	if (typeof value === "object") {
+		const properties = [];
+		for (const [key, val] of Object.entries(value)) {
+			const result = buildLiteralFromValue(val);
+			if (result.isErr()) return result;
+			properties.push(t.objectProperty(t.identifier(key), result.value));
+		}
+		return ok(t.objectExpression(properties));
+	}
+	return err(createUnsupportedValueTypeError(typeof value));
+};
+const clone = (node) => t.cloneNode(node, true);
+const cloneCallExpression = (node) => t.callExpression(clone(node.callee), node.arguments.map(clone));
+const stripTypeAnnotations = (node) => {
+	if ("typeParameters" in node) delete node.typeParameters;
+	if ("typeAnnotation" in node) delete node.typeAnnotation;
+	if ("returnType" in node) delete node.returnType;
+};
+const buildObjectExpression = (properties) => t.objectExpression(Object.entries(properties).map(([key, value]) => t.objectProperty(t.identifier(key), value)));
+
+//#endregion
+//#region packages/babel-transformer/src/ast/imports.ts
+const RUNTIME_MODULE = "@soda-gql/runtime";
+/**
+* Ensure that the gqlRuntime require exists in the program for CJS output.
+* Injects: const __soda_gql_runtime = require("@soda-gql/runtime");
+*/
+const ensureGqlRuntimeRequire = (programPath) => {
+	if (programPath.node.body.find((statement) => types.isVariableDeclaration(statement) && statement.declarations.some((decl) => {
+		if (!types.isIdentifier(decl.id) || decl.id.name !== "__soda_gql_runtime") return false;
+		if (!decl.init || !types.isCallExpression(decl.init)) return false;
+		const callExpr = decl.init;
+		if (!types.isIdentifier(callExpr.callee) || callExpr.callee.name !== "require") return false;
+		const arg = callExpr.arguments[0];
+		return arg && types.isStringLiteral(arg) && arg.value === RUNTIME_MODULE;
+	}))) return;
+	const requireCall = types.callExpression(types.identifier("require"), [types.stringLiteral(RUNTIME_MODULE)]);
+	const variableDeclaration = types.variableDeclaration("const", [types.variableDeclarator(types.identifier("__soda_gql_runtime"), requireCall)]);
+	programPath.node.body.unshift(variableDeclaration);
+};
+/**
+* Ensure that the gqlRuntime import exists in the program.
+* gqlRuntime is always imported from @soda-gql/runtime.
+*/
+const ensureGqlRuntimeImport = (programPath) => {
+	const existing = programPath.node.body.find((statement) => statement.type === "ImportDeclaration" && statement.source.value === RUNTIME_MODULE);
+	if (existing && types.isImportDeclaration(existing)) {
+		if (!existing.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "gqlRuntime")) existing.specifiers = [...existing.specifiers, types.importSpecifier(types.identifier("gqlRuntime"), types.identifier("gqlRuntime"))];
+		return;
+	}
+	programPath.node.body.unshift(types.importDeclaration([types.importSpecifier(types.identifier("gqlRuntime"), types.identifier("gqlRuntime"))], types.stringLiteral(RUNTIME_MODULE)));
+};
+/**
+* Remove the graphql-system import (runtimeModule) and gql-related exports from the program.
+* After transformation, gqlRuntime is imported from @soda-gql/runtime instead,
+* so the original graphql-system import should be completely removed.
+*
+* This handles both ESM imports and CommonJS require() statements.
+*/
+const removeGraphqlSystemImports = (programPath, graphqlSystemIdentifyHelper, filename) => {
+	const toRemove = [];
+	programPath.traverse({
+		ImportDeclaration(path) {
+			if (types.isStringLiteral(path.node.source)) {
+				if (graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+					filePath: filename,
+					specifier: path.node.source.value
+				})) toRemove.push(path);
+			}
+		},
+		VariableDeclaration(path) {
+			if (path.node.declarations.every((decl) => {
+				const specifier = extractRequireTargetSpecifier(decl.init);
+				if (!specifier) return false;
+				return graphqlSystemIdentifyHelper.isGraphqlSystemImportSpecifier({
+					filePath: filename,
+					specifier
+				});
+			})) toRemove.push(path);
+		}
+	});
+	for (const path of toRemove) path.remove();
+};
+/**
+* Check if an expression is a require() call and extract its target specifier.
+* Handles multiple patterns:
+* - require("@/graphql-system")
+* - Object(require("@/graphql-system")) (interop helper pattern)
+*/
+const extractRequireTargetSpecifier = (expr) => {
+	if (!expr) return;
+	if (types.isCallExpression(expr)) {
+		if (types.isIdentifier(expr.callee) && expr.callee.name === "require") {
+			const arg = expr.arguments[0];
+			if (arg && types.isStringLiteral(arg)) return arg.value;
+		}
+		if (types.isIdentifier(expr.callee) && (expr.callee.name === "Object" || expr.callee.name.startsWith("__import"))) {
+			const arg = expr.arguments[0];
+			if (arg && types.isCallExpression(arg)) {
+				if (types.isIdentifier(arg.callee) && arg.callee.name === "require") {
+					const requireArg = arg.arguments[0];
+					if (requireArg && types.isStringLiteral(requireArg)) return requireArg.value;
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region packages/babel-transformer/src/ast/metadata.ts
+const collectGqlDefinitionMetadata = ({ programPath, filename, createTracker }) => {
+	const exportBindings = collectExportBindings(programPath.node);
+	const tracker = (createTracker ?? createCanonicalTracker)({
+		filePath: filename,
+		getExportName: (localName) => exportBindings.get(localName)
+	});
+	const getAnonymousName = createAnonymousNameFactory();
+	const scopeHandles = /* @__PURE__ */ new WeakMap();
+	const metadata = /* @__PURE__ */ new WeakMap();
+	programPath.traverse({
+		enter(path) {
+			if (path.isCallExpression() && isGqlDefinitionCall(path.node)) {
+				const depthBeforeRegister = tracker.currentDepth();
+				const { astPath } = tracker.registerDefinition();
+				const isTopLevel = depthBeforeRegister <= 1;
+				const exportInfo = isTopLevel ? resolveTopLevelExport(path, exportBindings) : null;
+				metadata.set(path.node, {
+					astPath,
+					isTopLevel,
+					isExported: exportInfo?.isExported ?? false,
+					exportBinding: exportInfo?.exportBinding
+				});
+				path.skip();
+				return;
+			}
+			const handle = maybeEnterScope(path, tracker, getAnonymousName);
+			if (handle) scopeHandles.set(path, handle);
+		},
+		exit(path) {
+			const handle = scopeHandles.get(path);
+			if (handle) {
+				tracker.exitScope(handle);
+				scopeHandles.delete(path);
+			}
+		}
+	});
+	return metadata;
+};
+const collectExportBindings = (program) => {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (types.isExportNamedDeclaration(statement) && statement.declaration) {
+			const { declaration } = statement;
+			if (types.isVariableDeclaration(declaration)) {
+				for (const declarator of declaration.declarations) if (types.isIdentifier(declarator.id)) bindings.set(declarator.id.name, declarator.id.name);
+				continue;
+			}
+			if ((types.isFunctionDeclaration(declaration) || types.isClassDeclaration(declaration)) && declaration.id) bindings.set(declaration.id.name, declaration.id.name);
+			continue;
+		}
+		if (types.isExpressionStatement(statement) && types.isAssignmentExpression(statement.expression)) {
+			const exportName = getCommonJsExportName(statement.expression.left);
+			if (exportName) bindings.set(exportName, exportName);
+		}
+	}
+	return bindings;
+};
+const getCommonJsExportName = (node) => {
+	if (!types.isMemberExpression(node) || node.computed) return null;
+	const isExports = types.isIdentifier(node.object, { name: "exports" });
+	const isModuleExports = types.isMemberExpression(node.object) && types.isIdentifier(node.object.object, { name: "module" }) && types.isIdentifier(node.object.property, { name: "exports" });
+	if (!isExports && !isModuleExports) return null;
+	if (types.isIdentifier(node.property)) return node.property.name;
+	if (types.isStringLiteral(node.property)) return node.property.value;
+	return null;
+};
+const createAnonymousNameFactory = () => {
+	const counters = /* @__PURE__ */ new Map();
+	return (kind) => {
+		const count = counters.get(kind) ?? 0;
+		counters.set(kind, count + 1);
+		return `${kind}#${count}`;
+	};
+};
+const isGqlDefinitionCall = (node) => types.isCallExpression(node) && types.isMemberExpression(node.callee) && isGqlReference(node.callee.object) && node.arguments.length > 0 && types.isArrowFunctionExpression(node.arguments[0]);
+const isGqlReference = (expr) => {
+	if (types.isIdentifier(expr, { name: "gql" })) return true;
+	if (!types.isMemberExpression(expr) || expr.computed) return false;
+	if (types.isIdentifier(expr.property) && expr.property.name === "gql" || types.isStringLiteral(expr.property) && expr.property.value === "gql") return true;
+	return isGqlReference(expr.object);
+};
+const resolveTopLevelExport = (callPath, exportBindings) => {
+	const declarator = callPath.parentPath;
+	if (declarator?.isVariableDeclarator()) {
+		const { id } = declarator.node;
+		if (types.isIdentifier(id)) {
+			const exportBinding = exportBindings.get(id.name);
+			if (exportBinding) return {
+				isExported: true,
+				exportBinding
+			};
+		}
+	}
+	const assignment = callPath.parentPath;
+	if (assignment?.isAssignmentExpression()) {
+		const exportName = getCommonJsExportName(assignment.node.left);
+		if (exportName && exportBindings.has(exportName)) return {
+			isExported: true,
+			exportBinding: exportName
+		};
+	}
+	return null;
+};
+const maybeEnterScope = (path, tracker, getAnonymousName) => {
+	if (path.isAssignmentExpression()) {
+		const exportName = getCommonJsExportName(path.node.left);
+		if (exportName) return tracker.enterScope({
+			segment: exportName,
+			kind: "variable",
+			stableKey: `var:${exportName}`
+		});
+	}
+	if (path.isVariableDeclarator() && types.isIdentifier(path.node.id)) {
+		const name = path.node.id.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "variable",
+			stableKey: `var:${name}`
+		});
+	}
+	if (path.isArrowFunctionExpression()) {
+		const name = getAnonymousName("arrow");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: "arrow"
+		});
+	}
+	if (path.isFunctionDeclaration() || path.isFunctionExpression()) {
+		const name = path.node.id?.name ?? getAnonymousName("function");
+		return tracker.enterScope({
+			segment: name,
+			kind: "function",
+			stableKey: `func:${name}`
+		});
+	}
+	if (path.isClassDeclaration()) {
+		const name = path.node.id?.name ?? getAnonymousName("class");
+		return tracker.enterScope({
+			segment: name,
+			kind: "class",
+			stableKey: `class:${name}`
+		});
+	}
+	if (path.isClassMethod() && types.isIdentifier(path.node.key)) {
+		const name = path.node.key.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "method",
+			stableKey: `member:${name}`
+		});
+	}
+	if (path.isClassProperty() && types.isIdentifier(path.node.key)) {
+		const name = path.node.key.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `member:${name}`
+		});
+	}
+	if (path.isObjectProperty()) {
+		const key = path.node.key;
+		const name = types.isIdentifier(key) ? key.name : types.isStringLiteral(key) ? key.value : null;
+		if (name) return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `prop:${name}`
+		});
+	}
+	return null;
+};
+
+//#endregion
+//#region packages/babel-transformer/src/ast/runtime.ts
+const buildFragmentRuntimeCall = ({ artifact }) => {
+	return ok(types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("fragment")), [buildObjectExpression({ prebuild: buildObjectExpression({ typename: types.stringLiteral(artifact.prebuild.typename) }) })]));
+};
+const buildOperationRuntimeComponents = ({ artifact }) => {
+	const runtimeCall = types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("operation")), [buildObjectExpression({
+		prebuild: types.callExpression(types.memberExpression(types.identifier("JSON"), types.identifier("parse")), [types.stringLiteral(JSON.stringify(artifact.prebuild))]),
+		runtime: buildObjectExpression({})
+	})]);
+	return ok({
+		referenceCall: types.callExpression(types.memberExpression(types.identifier("gqlRuntime"), types.identifier("getOperation")), [types.stringLiteral(artifact.prebuild.operationName)]),
+		runtimeCall
+	});
+};
+
+//#endregion
+//#region packages/babel-transformer/src/ast/transformer.ts
+const transformCallExpression = ({ callPath, filename, metadata, getArtifact }) => {
+	if (!metadata.has(callPath.node)) return ok({ transformed: false });
+	const gqlCallResult = extractGqlCall({
+		nodePath: callPath,
+		filename,
+		metadata,
+		getArtifact
+	});
+	if (gqlCallResult.isErr()) return err(gqlCallResult.error);
+	const gqlCall = gqlCallResult.value;
+	return replaceWithRuntimeCall(callPath, gqlCall, filename);
+};
+const replaceWithRuntimeCall = (callPath, gqlCall, filename) => {
+	if (gqlCall.type === "fragment") {
+		const result = buildFragmentRuntimeCall({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return err(result.error);
+		callPath.replaceWith(result.value);
+		return ok({ transformed: true });
+	}
+	if (gqlCall.type === "operation") {
+		const result = buildOperationRuntimeComponents({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return err(result.error);
+		const { referenceCall, runtimeCall } = result.value;
+		callPath.replaceWith(referenceCall);
+		return ok({
+			transformed: true,
+			runtimeCall
+		});
+	}
+	return ok({ transformed: false });
+};
+const insertRuntimeCalls = (programPath, runtimeCalls) => {
+	if (runtimeCalls.length === 0) return;
+	programPath.traverse({ ImportDeclaration(importDeclPath) {
+		if (importDeclPath.node.source.value === "@soda-gql/runtime") importDeclPath.insertAfter([...runtimeCalls]);
+	} });
+};
+
+//#endregion
+//#region node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+	let delta = num - relative;
+	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+	do {
+		let clamped = delta & 31;
+		delta >>>= 5;
+		if (delta > 0) clamped |= 32;
+		builder.write(intToChar[clamped]);
+	} while (delta > 0);
+	return num;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			genColumn = encodeInteger(writer, segment[0], genColumn);
+			if (segment.length === 1) continue;
+			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+			sourceLine = encodeInteger(writer, segment[2], sourceLine);
+			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			if (segment.length === 4) continue;
+			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+		}
+	}
+	return writer.flush();
+}
+
+//#endregion
+//#region node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url$1 = parseAbsoluteUrl("http:" + input);
+		url$1.scheme = "";
+		url$1.type = 6;
+		return url$1;
+	}
+	if (isAbsolutePath(input)) {
+		const url$1 = parseAbsoluteUrl("http://foo.com" + input);
+		url$1.scheme = "";
+		url$1.host = "";
+		url$1.type = 5;
+		return url$1;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+
+//#endregion
+//#region node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN$1 = 0;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN$1] - b[COLUMN$1];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN$1] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse$1(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse$1(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve$1 = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve$1);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast$1(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast$1(map))._decoded || (_a._decoded = decode(cast$1(map)._encoded));
+}
+function traceSegment(map, line, column) {
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return null;
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast$1(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+	return index === -1 ? null : segments[index];
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+
+//#endregion
+//#region node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+var SetArray = class {
+	constructor() {
+		this._indexes = { __proto__: null };
+		this.array = [];
+	}
+};
+function cast(set) {
+	return set;
+}
+function get(setarr, key) {
+	return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+	const index = get(setarr, key);
+	if (index !== void 0) return index;
+	const { array, _indexes: indexes } = cast(setarr);
+	return indexes[key] = array.push(key) - 1;
+}
+function remove(setarr, key) {
+	const index = get(setarr, key);
+	if (index === void 0) return;
+	const { array, _indexes: indexes } = cast(setarr);
+	for (let i = index + 1; i < array.length; i++) {
+		const k = array[i];
+		array[i - 1] = k;
+		indexes[k]--;
+	}
+	indexes[key] = void 0;
+	array.pop();
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var NO_NAME = -1;
+var GenMapping = class {
+	constructor({ file, sourceRoot } = {}) {
+		this._names = new SetArray();
+		this._sources = new SetArray();
+		this._sourcesContent = [];
+		this._mappings = [];
+		this.file = file;
+		this.sourceRoot = sourceRoot;
+		this._ignoreList = new SetArray();
+	}
+};
+function cast2(map) {
+	return map;
+}
+var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+	return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
+};
+function setSourceContent(map, source, content) {
+	const { _sources: sources, _sourcesContent: sourcesContent } = cast2(map);
+	const index = put(sources, source);
+	sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+	const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast2(map);
+	const index = put(sources, source);
+	if (index === sourcesContent.length) sourcesContent[index] = null;
+	if (ignore) put(ignoreList, index);
+	else remove(ignoreList, index);
+}
+function toDecodedMap(map) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast2(map);
+	removeEmptyFinalLines(mappings);
+	return {
+		version: 3,
+		file: map.file || void 0,
+		names: names.array,
+		sourceRoot: map.sourceRoot || void 0,
+		sources: sources.array,
+		sourcesContent,
+		mappings,
+		ignoreList: ignoreList.array
+	};
+}
+function toEncodedMap(map) {
+	const decoded = toDecodedMap(map);
+	return Object.assign({}, decoded, { mappings: encode(decoded.mappings) });
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = cast2(map);
+	const line = getIndex(mappings, genLine);
+	const index = getColumnIndex(line, genColumn);
+	if (!source) {
+		if (skipable && skipSourceless(line, index)) return;
+		return insert(line, index, [genColumn]);
+	}
+	assert(sourceLine);
+	assert(sourceColumn);
+	const sourcesIndex = put(sources, source);
+	const namesIndex = name ? put(names, name) : NO_NAME;
+	if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+	if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) return;
+	return insert(line, index, name ? [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn,
+		namesIndex
+	] : [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn
+	]);
+}
+function assert(_val) {}
+function getIndex(arr, index) {
+	for (let i = arr.length; i <= index; i++) arr[i] = [];
+	return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+	let index = line.length;
+	for (let i = index - 1; i >= 0; index = i--) if (genColumn >= line[i][COLUMN]) break;
+	return index;
+}
+function insert(array, index, value) {
+	for (let i = array.length; i > index; i--) array[i] = array[i - 1];
+	array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+	const { length } = mappings;
+	let len = length;
+	for (let i = len - 1; i >= 0; len = i, i--) if (mappings[i].length > 0) break;
+	if (len < length) mappings.length = len;
+}
+function skipSourceless(line, index) {
+	if (index === 0) return true;
+	return line[index - 1].length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+	if (index === 0) return false;
+	const prev = line[index - 1];
+	if (prev.length === 1) return false;
+	return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+
+//#endregion
+//#region node_modules/@ampproject/remapping/dist/remapping.mjs
+const SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false);
+const EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+	return {
+		source,
+		line,
+		column,
+		name,
+		content,
+		ignore
+	};
+}
+function Source(map, sources, source, content, ignore) {
+	return {
+		map,
+		sources,
+		source,
+		content,
+		ignore
+	};
+}
+/**
+* MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+* (which may themselves be SourceMapTrees).
+*/
+function MapSource(map, sources) {
+	return Source(map, sources, "", null, false);
+}
+/**
+* A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+* segment tracing ends at the `OriginalSource`.
+*/
+function OriginalSource(source, content, ignore) {
+	return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+/**
+* traceMappings is only called on the root level SourceMapTree, and begins the process of
+* resolving each mapping in terms of the original source files.
+*/
+function traceMappings(tree) {
+	const gen = new GenMapping({ file: tree.map.file });
+	const { sources: rootSources, map } = tree;
+	const rootNames = map.names;
+	const rootMappings = decodedMappings(map);
+	for (let i = 0; i < rootMappings.length; i++) {
+		const segments = rootMappings[i];
+		for (let j = 0; j < segments.length; j++) {
+			const segment = segments[j];
+			const genCol = segment[0];
+			let traced = SOURCELESS_MAPPING;
+			if (segment.length !== 1) {
+				const source$1 = rootSources[segment[1]];
+				traced = originalPositionFor(source$1, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : "");
+				if (traced == null) continue;
+			}
+			const { column, line, name, content, source, ignore } = traced;
+			maybeAddSegment(gen, i, genCol, source, line, column, name);
+			if (source && content != null) setSourceContent(gen, source, content);
+			if (ignore) setIgnore(gen, source, true);
+		}
+	}
+	return gen;
+}
+/**
+* originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+* child SourceMapTrees, until we find the original source map.
+*/
+function originalPositionFor(source, line, column, name) {
+	if (!source.map) return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+	const segment = traceSegment(source.map, line, column);
+	if (segment == null) return null;
+	if (segment.length === 1) return SOURCELESS_MAPPING;
+	return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+function asArray(value) {
+	if (Array.isArray(value)) return value;
+	return [value];
+}
+/**
+* Recursively builds a tree structure out of sourcemap files, with each node
+* being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+* `OriginalSource`s and `SourceMapTree`s.
+*
+* Every sourcemap is composed of a collection of source files and mappings
+* into locations of those source files. When we generate a `SourceMapTree` for
+* the sourcemap, we attempt to load each source file's own sourcemap. If it
+* does not have an associated sourcemap, it is considered an original,
+* unmodified source file.
+*/
+function buildSourceMapTree(input, loader) {
+	const maps = asArray(input).map((m) => new TraceMap(m, ""));
+	const map = maps.pop();
+	for (let i = 0; i < maps.length; i++) if (maps[i].sources.length > 1) throw new Error(`Transformation map ${i} must have exactly one source file.\nDid you specify these with the most recent transformation maps first?`);
+	let tree = build(map, loader, "", 0);
+	for (let i = maps.length - 1; i >= 0; i--) tree = MapSource(maps[i], [tree]);
+	return tree;
+}
+function build(map, loader, importer, importerDepth) {
+	const { resolvedSources, sourcesContent, ignoreList } = map;
+	const depth = importerDepth + 1;
+	return MapSource(map, resolvedSources.map((sourceFile, i) => {
+		const ctx = {
+			importer,
+			depth,
+			source: sourceFile || "",
+			content: void 0,
+			ignore: void 0
+		};
+		const sourceMap = loader(ctx.source, ctx);
+		const { source, content, ignore } = ctx;
+		if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);
+		return OriginalSource(source, content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null, ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false);
+	}));
+}
+/**
+* A SourceMap v3 compatible sourcemap, which only includes fields that were
+* provided to it.
+*/
+var SourceMap = class {
+	constructor(map, options) {
+		const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+		this.version = out.version;
+		this.file = out.file;
+		this.mappings = out.mappings;
+		this.names = out.names;
+		this.ignoreList = out.ignoreList;
+		this.sourceRoot = out.sourceRoot;
+		this.sources = out.sources;
+		if (!options.excludeContent) this.sourcesContent = out.sourcesContent;
+	}
+	toString() {
+		return JSON.stringify(this);
+	}
+};
+/**
+* Traces through all the mappings in the root sourcemap, through the sources
+* (and their sourcemaps), all the way back to the original source location.
+*
+* `loader` will be called every time we encounter a source file. If it returns
+* a sourcemap, we will recurse into that sourcemap to continue the trace. If
+* it returns a falsey value, that source file is treated as an original,
+* unmodified source file.
+*
+* Pass `excludeContent` to exclude any self-containing source file content
+* from the output sourcemap.
+*
+* Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+* VLQ encoded) mappings.
+*/
+function remapping(input, loader, options) {
+	const opts = typeof options === "object" ? options : {
+		excludeContent: !!options,
+		decodedMappings: false
+	};
+	return new SourceMap(traceMappings(buildSourceMapTree(input, loader)), opts);
+}
+
+//#endregion
+//#region packages/babel-transformer/src/transformer.ts
+/**
+* Creates a Babel transformer with a single transform() method.
+* This matches the pattern used in the TypeScript plugin.
+*/
+const createTransformer = ({ programPath, types: types$1, config }) => {
+	const graphqlSystemIdentifyHelper = createGraphqlSystemIdentifyHelper(config);
+	/**
+	* Check if a node is a require() or __webpack_require__() call.
+	*/
+	const isRequireCall = (node) => {
+		if (!types$1.isCallExpression(node)) return false;
+		const callee = node.callee;
+		return types$1.isIdentifier(callee) && (callee.name === "require" || callee.name === "__webpack_require__");
+	};
+	/**
+	* Find the last statement that loads a module (import or require).
+	* Handles both ESM imports and CommonJS require() calls.
+	*/
+	const findLastModuleLoader = () => {
+		const bodyPaths = programPath.get("body");
+		let lastLoader = null;
+		for (const path of bodyPaths) {
+			if (path.isImportDeclaration()) {
+				lastLoader = path;
+				continue;
+			}
+			if (path.isVariableDeclaration()) {
+				for (const declarator of path.node.declarations) if (declarator.init && isRequireCall(declarator.init)) {
+					lastLoader = path;
+					break;
+				}
+				continue;
+			}
+			if (path.isExpressionStatement()) {
+				if (isRequireCall(path.node.expression)) lastLoader = path;
+			}
+		}
+		return lastLoader;
+	};
+	return { transform: (context) => {
+		const metadata = collectGqlDefinitionMetadata({
+			programPath,
+			filename: context.filename
+		});
+		const runtimeCalls = [];
+		let transformed = false;
+		programPath.traverse({ CallExpression: (callPath) => {
+			const result = transformCallExpression({
+				callPath,
+				filename: context.filename,
+				metadata,
+				getArtifact: context.artifactLookup
+			});
+			if (result.isErr()) {
+				console.error(`[@soda-gql/babel-transformer] ${formatPluginError(result.error)}`);
+				return;
+			}
+			const transformResult = result.value;
+			if (transformResult.transformed) {
+				transformed = true;
+				if (transformResult.runtimeCall) runtimeCalls.push(transformResult.runtimeCall);
+			}
+		} });
+		if (!transformed) return {
+			transformed: false,
+			runtimeArtifacts: void 0
+		};
+		ensureGqlRuntimeImport(programPath);
+		if (runtimeCalls.length > 0) {
+			const statements = runtimeCalls.map((expr) => types$1.expressionStatement(expr));
+			const lastLoaderPath = findLastModuleLoader();
+			if (lastLoaderPath) lastLoaderPath.insertAfter(statements);
+			else programPath.unshiftContainer("body", statements);
+		}
+		programPath.scope.crawl();
+		removeGraphqlSystemImports(programPath, graphqlSystemIdentifyHelper, context.filename);
+		return {
+			transformed: true,
+			runtimeArtifacts: void 0
+		};
+	} };
+};
+
+//#endregion
+//#region packages/babel-transformer/src/transform.ts
+/**
+* Source-code based transform function for babel-transformer.
+*
+* This provides a similar interface to swc-transformer, taking source code
+* as input and returning transformed source code.
+*/
+const traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
+const generate = typeof _generate === "function" ? _generate : _generate.default;
+/**
+* Create a transformer instance.
+*
+* @param options - Transform options including config and artifact
+* @returns A transformer that can transform source files
+*/
+const createBabelTransformer = (options) => {
+	const { config, artifact, sourceMap = false } = options;
+	return { transform: ({ sourceCode, sourcePath, inputSourceMap }) => {
+		const ast = parse(sourceCode, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			sourceFilename: sourcePath
+		});
+		let programPath = null;
+		traverse(ast, { Program(path) {
+			programPath = path;
+			path.stop();
+		} });
+		if (!programPath) return {
+			transformed: false,
+			sourceCode,
+			sourceMap: void 0
+		};
+		if (!createTransformer({
+			programPath,
+			types,
+			config
+		}).transform({
+			filename: sourcePath,
+			artifactLookup: (canonicalId) => artifact.elements[canonicalId]
+		}).transformed) return {
+			transformed: false,
+			sourceCode,
+			sourceMap: void 0
+		};
+		const output = generate(ast, {
+			sourceMaps: sourceMap,
+			sourceFileName: sourcePath
+		}, sourceCode);
+		let finalSourceMap;
+		if (sourceMap && output.map) if (inputSourceMap) {
+			const merged = remapping([output.map, JSON.parse(inputSourceMap)], () => null);
+			finalSourceMap = JSON.stringify(merged);
+		} else finalSourceMap = JSON.stringify(output.map);
+		return {
+			transformed: true,
+			sourceCode: output.code,
+			sourceMap: finalSourceMap
+		};
+	} };
+};
+/**
+* Transform a single source file (one-shot).
+*
+* For transforming multiple files, use createBabelTransformer() to reuse the artifact.
+*
+* @param input - Transform input including source, path, artifact, and config
+* @returns Transform output
+*/
+const transform = (input) => {
+	return createBabelTransformer({
+		config: input.config,
+		artifact: input.artifact,
+		sourceMap: input.sourceMap
+	}).transform({
+		sourceCode: input.sourceCode,
+		sourcePath: input.sourcePath,
+		inputSourceMap: input.inputSourceMap
+	});
+};
+
+//#endregion
+export { buildFragmentRuntimeCall, buildLiteralFromValue, buildObjectExpression, buildOperationRuntimeComponents, clone, cloneCallExpression, collectGqlDefinitionMetadata, createBabelTransformer, createTransformer, ensureGqlRuntimeImport, ensureGqlRuntimeRequire, extractGqlCall, insertRuntimeCalls, removeGraphqlSystemImports, stripTypeAnnotations, transform, transformCallExpression };
+//# sourceMappingURL=index.mjs.map