@soda-gql/babel 0.11.0

package/dist/transformer-C9UM_hw8.cjs

@@ -0,0 +1,652 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let __soda_gql_builder_plugin_support = require("@soda-gql/builder/plugin-support");
+let neverthrow = require("neverthrow");
+let __babel_types = require("@babel/types");
+__babel_types = __toESM(__babel_types);
+let __babel_core = require("@babel/core");
+let __soda_gql_common = require("@soda-gql/common");
+let __soda_gql_builder = require("@soda-gql/builder");
+
+//#region packages/babel/src/ast/analysis.ts
+const extractGqlCall = ({ nodePath, filename, metadata, getArtifact }) => {
+	const callExpression = nodePath.node;
+	const meta = metadata.get(callExpression);
+	if (!meta) return (0, neverthrow.err)(createMetadataMissingError({ filename }));
+	const canonicalId = (0, __soda_gql_builder_plugin_support.resolveCanonicalId)(filename, meta.astPath);
+	const artifact = getArtifact(canonicalId);
+	if (!artifact) return (0, neverthrow.err)(createArtifactMissingError({
+		filename,
+		canonicalId
+	}));
+	if (artifact.type === "fragment") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		type: "fragment",
+		artifact
+	});
+	if (artifact.type === "operation") return (0, neverthrow.ok)({
+		nodePath,
+		canonicalId,
+		type: "operation",
+		artifact
+	});
+	return (0, neverthrow.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/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 (0, neverthrow.ok)(__babel_types.nullLiteral());
+	if (typeof value === "string") return (0, neverthrow.ok)(__babel_types.stringLiteral(value));
+	if (typeof value === "number") return (0, neverthrow.ok)(__babel_types.numericLiteral(value));
+	if (typeof value === "boolean") return (0, neverthrow.ok)(__babel_types.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 (0, neverthrow.ok)(__babel_types.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(__babel_types.objectProperty(__babel_types.identifier(key), result.value));
+		}
+		return (0, neverthrow.ok)(__babel_types.objectExpression(properties));
+	}
+	return (0, neverthrow.err)(createUnsupportedValueTypeError(typeof value));
+};
+const clone = (node) => __babel_types.cloneNode(node, true);
+const cloneCallExpression = (node) => __babel_types.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) => __babel_types.objectExpression(Object.entries(properties).map(([key, value]) => __babel_types.objectProperty(__babel_types.identifier(key), value)));
+
+//#endregion
+//#region packages/babel/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) => __babel_core.types.isVariableDeclaration(statement) && statement.declarations.some((decl) => {
+		if (!__babel_core.types.isIdentifier(decl.id) || decl.id.name !== "__soda_gql_runtime") return false;
+		if (!decl.init || !__babel_core.types.isCallExpression(decl.init)) return false;
+		const callExpr = decl.init;
+		if (!__babel_core.types.isIdentifier(callExpr.callee) || callExpr.callee.name !== "require") return false;
+		const arg = callExpr.arguments[0];
+		return arg && __babel_core.types.isStringLiteral(arg) && arg.value === RUNTIME_MODULE;
+	}))) return;
+	const requireCall = __babel_core.types.callExpression(__babel_core.types.identifier("require"), [__babel_core.types.stringLiteral(RUNTIME_MODULE)]);
+	const variableDeclaration = __babel_core.types.variableDeclaration("const", [__babel_core.types.variableDeclarator(__babel_core.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 && __babel_core.types.isImportDeclaration(existing)) {
+		if (!existing.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "gqlRuntime")) existing.specifiers = [...existing.specifiers, __babel_core.types.importSpecifier(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("gqlRuntime"))];
+		return;
+	}
+	programPath.node.body.unshift(__babel_core.types.importDeclaration([__babel_core.types.importSpecifier(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("gqlRuntime"))], __babel_core.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 (__babel_core.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 (__babel_core.types.isCallExpression(expr)) {
+		if (__babel_core.types.isIdentifier(expr.callee) && expr.callee.name === "require") {
+			const arg = expr.arguments[0];
+			if (arg && __babel_core.types.isStringLiteral(arg)) return arg.value;
+		}
+		if (__babel_core.types.isIdentifier(expr.callee) && (expr.callee.name === "Object" || expr.callee.name.startsWith("__import"))) {
+			const arg = expr.arguments[0];
+			if (arg && __babel_core.types.isCallExpression(arg)) {
+				if (__babel_core.types.isIdentifier(arg.callee) && arg.callee.name === "require") {
+					const requireArg = arg.arguments[0];
+					if (requireArg && __babel_core.types.isStringLiteral(requireArg)) return requireArg.value;
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region packages/babel/src/ast/metadata.ts
+const collectGqlDefinitionMetadata = ({ programPath, filename, createTracker }) => {
+	const exportBindings = collectExportBindings(programPath.node);
+	const tracker = (createTracker ?? __soda_gql_common.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 (__babel_core.types.isExportNamedDeclaration(statement) && statement.declaration) {
+			const { declaration } = statement;
+			if (__babel_core.types.isVariableDeclaration(declaration)) {
+				for (const declarator of declaration.declarations) if (__babel_core.types.isIdentifier(declarator.id)) bindings.set(declarator.id.name, declarator.id.name);
+				continue;
+			}
+			if ((__babel_core.types.isFunctionDeclaration(declaration) || __babel_core.types.isClassDeclaration(declaration)) && declaration.id) bindings.set(declaration.id.name, declaration.id.name);
+			continue;
+		}
+		if (__babel_core.types.isExpressionStatement(statement) && __babel_core.types.isAssignmentExpression(statement.expression)) {
+			const exportName = getCommonJsExportName(statement.expression.left);
+			if (exportName) bindings.set(exportName, exportName);
+		}
+	}
+	return bindings;
+};
+const getCommonJsExportName = (node) => {
+	if (!__babel_core.types.isMemberExpression(node) || node.computed) return null;
+	const isExports = __babel_core.types.isIdentifier(node.object, { name: "exports" });
+	const isModuleExports = __babel_core.types.isMemberExpression(node.object) && __babel_core.types.isIdentifier(node.object.object, { name: "module" }) && __babel_core.types.isIdentifier(node.object.property, { name: "exports" });
+	if (!isExports && !isModuleExports) return null;
+	if (__babel_core.types.isIdentifier(node.property)) return node.property.name;
+	if (__babel_core.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) => __babel_core.types.isCallExpression(node) && __babel_core.types.isMemberExpression(node.callee) && isGqlReference(node.callee.object) && node.arguments.length > 0 && __babel_core.types.isArrowFunctionExpression(node.arguments[0]);
+const isGqlReference = (expr) => {
+	if (__babel_core.types.isIdentifier(expr, { name: "gql" })) return true;
+	if (!__babel_core.types.isMemberExpression(expr) || expr.computed) return false;
+	if (__babel_core.types.isIdentifier(expr.property) && expr.property.name === "gql" || __babel_core.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 (__babel_core.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() && __babel_core.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() && __babel_core.types.isIdentifier(path.node.key)) {
+		const name = path.node.key.name;
+		return tracker.enterScope({
+			segment: name,
+			kind: "method",
+			stableKey: `member:${name}`
+		});
+	}
+	if (path.isClassProperty() && __babel_core.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 = __babel_core.types.isIdentifier(key) ? key.name : __babel_core.types.isStringLiteral(key) ? key.value : null;
+		if (name) return tracker.enterScope({
+			segment: name,
+			kind: "property",
+			stableKey: `prop:${name}`
+		});
+	}
+	return null;
+};
+
+//#endregion
+//#region packages/babel/src/ast/runtime.ts
+const buildFragmentRuntimeCall = ({ artifact }) => {
+	const prebuildProps = { typename: __babel_core.types.stringLiteral(artifact.prebuild.typename) };
+	if (artifact.prebuild.key !== void 0) prebuildProps.key = __babel_core.types.stringLiteral(artifact.prebuild.key);
+	return (0, neverthrow.ok)(__babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("fragment")), [buildObjectExpression({ prebuild: buildObjectExpression(prebuildProps) })]));
+};
+const buildOperationRuntimeComponents = ({ artifact }) => {
+	const runtimeCall = __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("operation")), [buildObjectExpression({
+		prebuild: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("JSON"), __babel_core.types.identifier("parse")), [__babel_core.types.stringLiteral(JSON.stringify(artifact.prebuild))]),
+		runtime: buildObjectExpression({})
+	})]);
+	return (0, neverthrow.ok)({
+		referenceCall: __babel_core.types.callExpression(__babel_core.types.memberExpression(__babel_core.types.identifier("gqlRuntime"), __babel_core.types.identifier("getOperation")), [__babel_core.types.stringLiteral(artifact.prebuild.operationName)]),
+		runtimeCall
+	});
+};
+
+//#endregion
+//#region packages/babel/src/ast/transformer.ts
+const transformCallExpression = ({ callPath, filename, metadata, getArtifact }) => {
+	if (!metadata.has(callPath.node)) return (0, neverthrow.ok)({ transformed: false });
+	const gqlCallResult = extractGqlCall({
+		nodePath: callPath,
+		filename,
+		metadata,
+		getArtifact
+	});
+	if (gqlCallResult.isErr()) return (0, neverthrow.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 (0, neverthrow.err)(result.error);
+		callPath.replaceWith(result.value);
+		return (0, neverthrow.ok)({ transformed: true });
+	}
+	if (gqlCall.type === "operation") {
+		const result = buildOperationRuntimeComponents({
+			...gqlCall,
+			filename
+		});
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		const { referenceCall, runtimeCall } = result.value;
+		callPath.replaceWith(referenceCall);
+		return (0, neverthrow.ok)({
+			transformed: true,
+			runtimeCall
+		});
+	}
+	return (0, neverthrow.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 packages/babel/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, config }) => {
+	const graphqlSystemIdentifyHelper = (0, __soda_gql_builder.createGraphqlSystemIdentifyHelper)(config);
+	/**
+	* Check if a node is a require() or __webpack_require__() call.
+	*/
+	const isRequireCall = (node) => {
+		if (!types.isCallExpression(node)) return false;
+		const callee = node.callee;
+		return types.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] ${(0, __soda_gql_builder_plugin_support.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.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
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'buildFragmentRuntimeCall', {
+  enumerable: true,
+  get: function () {
+    return buildFragmentRuntimeCall;
+  }
+});
+Object.defineProperty(exports, 'buildLiteralFromValue', {
+  enumerable: true,
+  get: function () {
+    return buildLiteralFromValue;
+  }
+});
+Object.defineProperty(exports, 'buildObjectExpression', {
+  enumerable: true,
+  get: function () {
+    return buildObjectExpression;
+  }
+});
+Object.defineProperty(exports, 'buildOperationRuntimeComponents', {
+  enumerable: true,
+  get: function () {
+    return buildOperationRuntimeComponents;
+  }
+});
+Object.defineProperty(exports, 'clone', {
+  enumerable: true,
+  get: function () {
+    return clone;
+  }
+});
+Object.defineProperty(exports, 'cloneCallExpression', {
+  enumerable: true,
+  get: function () {
+    return cloneCallExpression;
+  }
+});
+Object.defineProperty(exports, 'collectGqlDefinitionMetadata', {
+  enumerable: true,
+  get: function () {
+    return collectGqlDefinitionMetadata;
+  }
+});
+Object.defineProperty(exports, 'createTransformer', {
+  enumerable: true,
+  get: function () {
+    return createTransformer;
+  }
+});
+Object.defineProperty(exports, 'ensureGqlRuntimeImport', {
+  enumerable: true,
+  get: function () {
+    return ensureGqlRuntimeImport;
+  }
+});
+Object.defineProperty(exports, 'ensureGqlRuntimeRequire', {
+  enumerable: true,
+  get: function () {
+    return ensureGqlRuntimeRequire;
+  }
+});
+Object.defineProperty(exports, 'extractGqlCall', {
+  enumerable: true,
+  get: function () {
+    return extractGqlCall;
+  }
+});
+Object.defineProperty(exports, 'insertRuntimeCalls', {
+  enumerable: true,
+  get: function () {
+    return insertRuntimeCalls;
+  }
+});
+Object.defineProperty(exports, 'removeGraphqlSystemImports', {
+  enumerable: true,
+  get: function () {
+    return removeGraphqlSystemImports;
+  }
+});
+Object.defineProperty(exports, 'stripTypeAnnotations', {
+  enumerable: true,
+  get: function () {
+    return stripTypeAnnotations;
+  }
+});
+Object.defineProperty(exports, 'transformCallExpression', {
+  enumerable: true,
+  get: function () {
+    return transformCallExpression;
+  }
+});
+//# sourceMappingURL=transformer-C9UM_hw8.cjs.map