@drfed/web 0.0.0-stage → 0.1.0-dev.0

package/.output/server/_ssr/JNCCF6MP-BAZlBnvx.mjs

@@ -0,0 +1,419 @@
+import { $ as splitProps, I as createEffect, K as mergeProps, L as createMemo, N as createComponent, V as createSignal, a as Dynamic } from "../_libs/solid-js.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/JNCCF6MP-BAZlBnvx.js
+function removeItemFromArray(array, item) {
+	const updatedArray = [...array];
+	const index = updatedArray.indexOf(item);
+	if (index !== -1) updatedArray.splice(index, 1);
+	return updatedArray;
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function createGenerateId(baseId) {
+	return (suffix) => `${baseId()}-${suffix}`;
+}
+function contains(parent, child) {
+	if (!parent) return false;
+	return parent === child || parent.contains(child);
+}
+function getActiveElement(node, activeDescendant = false) {
+	const { activeElement } = getDocument(node);
+	if (!activeElement?.nodeName) return null;
+	if (isFrame(activeElement) && activeElement.contentDocument) return getActiveElement(activeElement.contentDocument.body, activeDescendant);
+	if (activeDescendant) {
+		const id = activeElement.getAttribute("aria-activedescendant");
+		if (id) {
+			const element = getDocument(activeElement).getElementById(id);
+			if (element) return element;
+		}
+	}
+	return activeElement;
+}
+function getWindow(node) {
+	return getDocument(node).defaultView || window;
+}
+function getDocument(node) {
+	return node ? node.ownerDocument || node : document;
+}
+function isFrame(element) {
+	return element.tagName === "IFRAME";
+}
+var EventKey = /* @__PURE__ */ ((EventKey2) => {
+	EventKey2["Escape"] = "Escape";
+	EventKey2["Enter"] = "Enter";
+	EventKey2["Tab"] = "Tab";
+	EventKey2["Space"] = " ";
+	EventKey2["ArrowDown"] = "ArrowDown";
+	EventKey2["ArrowLeft"] = "ArrowLeft";
+	EventKey2["ArrowRight"] = "ArrowRight";
+	EventKey2["ArrowUp"] = "ArrowUp";
+	EventKey2["End"] = "End";
+	EventKey2["Home"] = "Home";
+	EventKey2["PageDown"] = "PageDown";
+	EventKey2["PageUp"] = "PageUp";
+	return EventKey2;
+})(EventKey || {});
+function testUserAgent(re) {
+	if (typeof window === "undefined" || window.navigator == null) return false;
+	return window.navigator.userAgentData?.brands.some((brand) => re.test(brand.brand)) || re.test(window.navigator.userAgent);
+}
+function testPlatform(re) {
+	return typeof window !== "undefined" && window.navigator != null ? re.test(window.navigator.userAgentData?.platform || window.navigator.platform) : false;
+}
+function isMac() {
+	return testPlatform(/^Mac/i);
+}
+function isIPhone() {
+	return testPlatform(/^iPhone/i);
+}
+function isIPad() {
+	return testPlatform(/^iPad/i) || isMac() && navigator.maxTouchPoints > 1;
+}
+function isIOS() {
+	return isIPhone() || isIPad();
+}
+function isAppleDevice() {
+	return isMac() || isIOS();
+}
+function isWebKit() {
+	return testUserAgent(/AppleWebKit/i) && !isChrome();
+}
+function isChrome() {
+	return testUserAgent(/Chrome/i);
+}
+function callHandler(event, handler) {
+	if (handler) if (isFunction(handler)) handler(event);
+	else handler[0](handler[1], event);
+	return event?.defaultPrevented;
+}
+function composeEventHandlers(handlers) {
+	return (event) => {
+		for (const handler of handlers) callHandler(event, handler);
+	};
+}
+function isCtrlKey(e) {
+	if (isMac()) return e.metaKey && !e.ctrlKey;
+	return e.ctrlKey && !e.metaKey;
+}
+function focusWithoutScrolling(element) {
+	if (!element) return;
+	if (supportsPreventScroll()) element.focus({ preventScroll: true });
+	else {
+		const scrollableElements = getScrollableElements(element);
+		element.focus();
+		restoreScrollPosition(scrollableElements);
+	}
+}
+var supportsPreventScrollCached = null;
+function supportsPreventScroll() {
+	if (supportsPreventScrollCached == null) {
+		supportsPreventScrollCached = false;
+		try {
+			document.createElement("div").focus({ get preventScroll() {
+				supportsPreventScrollCached = true;
+				return true;
+			} });
+		} catch (e) {}
+	}
+	return supportsPreventScrollCached;
+}
+function getScrollableElements(element) {
+	let parent = element.parentNode;
+	const scrollableElements = [];
+	const rootScrollingElement = document.scrollingElement || document.documentElement;
+	while (parent instanceof HTMLElement && parent !== rootScrollingElement) {
+		if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
+			element: parent,
+			scrollTop: parent.scrollTop,
+			scrollLeft: parent.scrollLeft
+		});
+		parent = parent.parentNode;
+	}
+	if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
+		element: rootScrollingElement,
+		scrollTop: rootScrollingElement.scrollTop,
+		scrollLeft: rootScrollingElement.scrollLeft
+	});
+	return scrollableElements;
+}
+function restoreScrollPosition(scrollableElements) {
+	for (const { element, scrollTop, scrollLeft } of scrollableElements) {
+		element.scrollTop = scrollTop;
+		element.scrollLeft = scrollLeft;
+	}
+}
+var focusableElements = [
+	"input:not([type='hidden']):not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"button:not([disabled])",
+	"a[href]",
+	"area[href]",
+	"[tabindex]",
+	"iframe",
+	"object",
+	"embed",
+	"audio[controls]",
+	"video[controls]",
+	"[contenteditable]:not([contenteditable='false'])"
+];
+var tabbableElements = [...focusableElements, "[tabindex]:not([tabindex=\"-1\"]):not([disabled])"];
+var FOCUSABLE_ELEMENT_SELECTOR = `${focusableElements.join(":not([hidden]),")},[tabindex]:not([disabled]):not([hidden])`;
+var TABBABLE_ELEMENT_SELECTOR = tabbableElements.join(":not([hidden]):not([tabindex=\"-1\"]),");
+function getAllTabbableIn(container, includeContainer) {
+	const tabbableElements2 = Array.from(container.querySelectorAll(FOCUSABLE_ELEMENT_SELECTOR)).filter(isTabbable);
+	if (includeContainer && isTabbable(container)) tabbableElements2.unshift(container);
+	tabbableElements2.forEach((element, i) => {
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			const allFrameTabbable = getAllTabbableIn(frameBody, false);
+			tabbableElements2.splice(i, 1, ...allFrameTabbable);
+		}
+	});
+	return tabbableElements2;
+}
+function isTabbable(element) {
+	return isFocusable(element) && !hasNegativeTabIndex(element);
+}
+function isFocusable(element) {
+	return element.matches(FOCUSABLE_ELEMENT_SELECTOR) && isElementVisible(element);
+}
+function hasNegativeTabIndex(element) {
+	return Number.parseInt(element.getAttribute("tabindex") || "0", 10) < 0;
+}
+function isElementVisible(element, childElement) {
+	return element.nodeName !== "#comment" && isStyleVisible(element) && isAttributeVisible(element, childElement) && (!element.parentElement || isElementVisible(element.parentElement, element));
+}
+function isStyleVisible(element) {
+	if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) return false;
+	const { display, visibility } = element.style;
+	let isVisible = display !== "none" && visibility !== "hidden" && visibility !== "collapse";
+	if (isVisible) {
+		if (!element.ownerDocument.defaultView) return isVisible;
+		const { getComputedStyle } = element.ownerDocument.defaultView;
+		const { display: computedDisplay, visibility: computedVisibility } = getComputedStyle(element);
+		isVisible = computedDisplay !== "none" && computedVisibility !== "hidden" && computedVisibility !== "collapse";
+	}
+	return isVisible;
+}
+function isAttributeVisible(element, childElement) {
+	return !element.hasAttribute("hidden") && (element.nodeName === "DETAILS" && childElement && childElement.nodeName !== "SUMMARY" ? element.hasAttribute("open") : true);
+}
+function isElementInScope(element, scope) {
+	return scope.some((node) => node.contains(element));
+}
+function getFocusableTreeWalker(root, opts, scope) {
+	const selector = opts?.tabbable ? TABBABLE_ELEMENT_SELECTOR : FOCUSABLE_ELEMENT_SELECTOR;
+	const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, { acceptNode(node) {
+		if (opts?.from?.contains(node)) return NodeFilter.FILTER_REJECT;
+		if (node.matches(selector) && isElementVisible(node) && (!scope || isElementInScope(node, scope)) && (!opts?.accept || opts.accept(node))) return NodeFilter.FILTER_ACCEPT;
+		return NodeFilter.FILTER_SKIP;
+	} });
+	if (opts?.from) walker.currentNode = opts.from;
+	return walker;
+}
+function noop() {}
+function snapValueToStep(value, min, max, step) {
+	const remainder = (value - (Number.isNaN(min) ? 0 : min)) % step;
+	let snappedValue = Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder;
+	if (!Number.isNaN(min)) {
+		if (snappedValue < min) snappedValue = min;
+		else if (!Number.isNaN(max) && snappedValue > max) snappedValue = min + Math.floor((max - min) / step) * step;
+	} else if (!Number.isNaN(max) && snappedValue > max) snappedValue = Math.floor(max / step) * step;
+	const string = step.toString();
+	const index = string.indexOf(".");
+	const precision = index >= 0 ? string.length - index : 0;
+	if (precision > 0) {
+		const pow = 10 ** precision;
+		snappedValue = Math.round(snappedValue * pow) / pow;
+	}
+	return snappedValue;
+}
+var getPrecision = (n) => {
+	let e = 1;
+	let precision = 0;
+	while (Math.round(n * e) / e !== n) {
+		e *= 10;
+		precision++;
+	}
+	return precision;
+};
+function mergeDefaultProps(defaultProps, props) {
+	return mergeProps(defaultProps, props);
+}
+var transitionsByElement = /* @__PURE__ */ new Map();
+var transitionCallbacks = /* @__PURE__ */ new Set();
+function setupGlobalEvents() {
+	if (typeof window === "undefined" || document.body === null) return;
+	const onTransitionStart = (e) => {
+		if (!e.target) return;
+		let transitions = transitionsByElement.get(e.target);
+		if (!transitions) {
+			transitions = /* @__PURE__ */ new Set();
+			transitionsByElement.set(e.target, transitions);
+			e.target.addEventListener("transitioncancel", onTransitionEnd);
+		}
+		transitions.add(e.propertyName);
+	};
+	const onTransitionEnd = (e) => {
+		if (!e.target) return;
+		const properties = transitionsByElement.get(e.target);
+		if (!properties) return;
+		properties.delete(e.propertyName);
+		if (properties.size === 0) {
+			e.target.removeEventListener("transitioncancel", onTransitionEnd);
+			transitionsByElement.delete(e.target);
+		}
+		if (transitionsByElement.size === 0) {
+			for (const cb of transitionCallbacks) cb();
+			transitionCallbacks.clear();
+		}
+	};
+	document.body.addEventListener("transitionrun", onTransitionStart);
+	document.body.addEventListener("transitionend", onTransitionEnd);
+}
+if (typeof document !== "undefined") if (document.readyState !== "loading") setupGlobalEvents();
+else document.addEventListener("DOMContentLoaded", setupGlobalEvents);
+function scrollIntoView(scrollView, element) {
+	const offsetX = relativeOffset(scrollView, element, "left");
+	const offsetY = relativeOffset(scrollView, element, "top");
+	const width = element.offsetWidth;
+	const height = element.offsetHeight;
+	let x = scrollView.scrollLeft;
+	let y = scrollView.scrollTop;
+	const maxX = x + scrollView.offsetWidth;
+	const maxY = y + scrollView.offsetHeight;
+	if (offsetX <= x) x = offsetX;
+	else if (offsetX + width > maxX) x += offsetX + width - maxX;
+	if (offsetY <= y) y = offsetY;
+	else if (offsetY + height > maxY) y += offsetY + height - maxY;
+	scrollView.scrollLeft = x;
+	scrollView.scrollTop = y;
+}
+function relativeOffset(ancestor, child, axis) {
+	const prop = axis === "left" ? "offsetLeft" : "offsetTop";
+	let sum = 0;
+	while (child.offsetParent) {
+		sum += child[prop];
+		if (child.offsetParent === ancestor) break;
+		if (child.offsetParent.contains(ancestor)) {
+			sum -= ancestor[prop];
+			break;
+		}
+		child = child.offsetParent;
+	}
+	return sum;
+}
+var visuallyHiddenStyles = {
+	border: "0",
+	clip: "rect(0 0 0 0)",
+	"clip-path": "inset(50%)",
+	height: "1px",
+	margin: "0 -1px -1px 0",
+	overflow: "hidden",
+	padding: "0",
+	position: "absolute",
+	width: "1px",
+	"white-space": "nowrap"
+};
+function createTagName(ref, fallback) {
+	const [tagName, setTagName] = createSignal(stringOrUndefined(fallback?.()));
+	createEffect(() => {
+		setTagName(ref()?.tagName.toLowerCase() || stringOrUndefined(fallback?.()));
+	});
+	return tagName;
+}
+function stringOrUndefined(value) {
+	return isString(value) ? value : void 0;
+}
+function Polymorphic(props) {
+	const [local, others] = splitProps(props, ["as"]);
+	if (!local.as) throw new Error("[kobalte]: Polymorphic is missing the required `as` prop.");
+	return createComponent(Dynamic, mergeProps(others, { get component() {
+		return local.as;
+	} }));
+}
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+__export({}, {
+	Button: () => Button,
+	Root: () => ButtonRoot
+});
+var BUTTON_INPUT_TYPES = [
+	"button",
+	"color",
+	"file",
+	"image",
+	"reset",
+	"submit"
+];
+function isButton(element) {
+	const tagName = element.tagName.toLowerCase();
+	if (tagName === "button") return true;
+	if (tagName === "input" && element.type) return BUTTON_INPUT_TYPES.indexOf(element.type) !== -1;
+	return false;
+}
+function ButtonRoot(props) {
+	let ref;
+	const [local, others] = splitProps(mergeDefaultProps({ type: "button" }, props), [
+		"ref",
+		"type",
+		"disabled"
+	]);
+	const tagName = createTagName(() => ref, () => "button");
+	const isNativeButton = createMemo(() => {
+		const elementTagName = tagName();
+		if (elementTagName == null) return false;
+		return isButton({
+			tagName: elementTagName,
+			type: local.type
+		});
+	});
+	const isNativeInput = createMemo(() => {
+		return tagName() === "input";
+	});
+	const isNativeLink = createMemo(() => {
+		return tagName() === "a" && false;
+	});
+	return createComponent(Polymorphic, mergeProps({
+		as: "button",
+		get type() {
+			return isNativeButton() || isNativeInput() ? local.type : void 0;
+		},
+		get role() {
+			return !isNativeButton() && !isNativeLink() ? "button" : void 0;
+		},
+		get tabIndex() {
+			return !isNativeButton() && !isNativeLink() && !local.disabled ? 0 : void 0;
+		},
+		get disabled() {
+			return isNativeButton() || isNativeInput() ? local.disabled : void 0;
+		},
+		get ["aria-disabled"]() {
+			return !isNativeButton() && !isNativeInput() && local.disabled ? true : void 0;
+		},
+		get ["data-disabled"]() {
+			return local.disabled ? "" : void 0;
+		}
+	}, others));
+}
+var Button = ButtonRoot;
+function createRegisterId(setter) {
+	return (id) => {
+		setter(id);
+		return () => setter(void 0);
+	};
+}
+//#endregion
+export { scrollIntoView as A, isMac as C, mergeDefaultProps as D, isWebKit as E, visuallyHiddenStyles as M, noop as O, isFunction as S, isString as T, getPrecision as _, __export as a, isCtrlKey as b, contains as c, createTagName as d, focusWithoutScrolling as f, getFocusableTreeWalker as g, getDocument as h, Polymorphic as i, snapValueToStep as j, removeItemFromArray as k, createGenerateId as l, getAllTabbableIn as m, ButtonRoot as n, callHandler as o, getActiveElement as p, EventKey as r, composeEventHandlers as s, Button as t, createRegisterId as u, getWindow as v, isNumber as w, isFocusable as x, isAppleDevice as y };

package/.output/server/_ssr/LP6E37CW-D2Ih_b_K.mjs

@@ -0,0 +1,163 @@
+import { F as createContext, J as onCleanup, L as createMemo, V as createSignal, Y as onMount, nt as useContext } from "../_libs/solid-js.mjs";
+import { M as visuallyHiddenStyles } from "./JNCCF6MP-BAZlBnvx.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/LP6E37CW-D2Ih_b_K.js
+var LIVEREGION_TIMEOUT_DELAY = 7e3;
+var liveAnnouncer = null;
+var DATA_LIVE_ANNOUNCER_ATTR = "data-live-announcer";
+function announce(message, assertiveness = "assertive", timeout = LIVEREGION_TIMEOUT_DELAY) {
+	if (!liveAnnouncer) liveAnnouncer = new LiveAnnouncer();
+	liveAnnouncer.announce(message, assertiveness, timeout);
+}
+function clearAnnouncer(assertiveness) {
+	if (liveAnnouncer) liveAnnouncer.clear(assertiveness);
+}
+var LiveAnnouncer = class {
+	node;
+	assertiveLog;
+	politeLog;
+	constructor() {
+		this.node = document.createElement("div");
+		this.node.dataset.liveAnnouncer = "true";
+		Object.assign(this.node.style, visuallyHiddenStyles);
+		this.assertiveLog = this.createLog("assertive");
+		this.node.appendChild(this.assertiveLog);
+		this.politeLog = this.createLog("polite");
+		this.node.appendChild(this.politeLog);
+		document.body.prepend(this.node);
+	}
+	createLog(ariaLive) {
+		const node = document.createElement("div");
+		node.setAttribute("role", "log");
+		node.setAttribute("aria-live", ariaLive);
+		node.setAttribute("aria-relevant", "additions");
+		return node;
+	}
+	destroy() {
+		if (!this.node) return;
+		document.body.removeChild(this.node);
+		this.node = null;
+	}
+	announce(message, assertiveness = "assertive", timeout = LIVEREGION_TIMEOUT_DELAY) {
+		if (!this.node) return;
+		const node = document.createElement("div");
+		node.textContent = message;
+		if (assertiveness === "assertive") this.assertiveLog.appendChild(node);
+		else this.politeLog.appendChild(node);
+		if (message !== "") setTimeout(() => {
+			node.remove();
+		}, timeout);
+	}
+	clear(assertiveness) {
+		if (!this.node) return;
+		if (!assertiveness || assertiveness === "assertive") this.assertiveLog.innerHTML = "";
+		if (!assertiveness || assertiveness === "polite") this.politeLog.innerHTML = "";
+	}
+};
+var RTL_SCRIPTS = /* @__PURE__ */ new Set([
+	"Avst",
+	"Arab",
+	"Armi",
+	"Syrc",
+	"Samr",
+	"Mand",
+	"Thaa",
+	"Mend",
+	"Nkoo",
+	"Adlm",
+	"Rohg",
+	"Hebr"
+]);
+var RTL_LANGS = /* @__PURE__ */ new Set([
+	"ae",
+	"ar",
+	"arc",
+	"bcc",
+	"bqi",
+	"ckb",
+	"dv",
+	"fa",
+	"glk",
+	"he",
+	"ku",
+	"mzn",
+	"nqo",
+	"pnb",
+	"ps",
+	"sd",
+	"ug",
+	"ur",
+	"yi"
+]);
+function isRTL(locale) {
+	if (Intl.Locale) {
+		const script = new Intl.Locale(locale).maximize().script ?? "";
+		return RTL_SCRIPTS.has(script);
+	}
+	const lang = locale.split("-")[0];
+	return RTL_LANGS.has(lang);
+}
+function getReadingDirection(locale) {
+	return isRTL(locale) ? "rtl" : "ltr";
+}
+function getDefaultLocale() {
+	let locale = typeof navigator !== "undefined" && (navigator.language || navigator.userLanguage) || "en-US";
+	try {
+		Intl.DateTimeFormat.supportedLocalesOf([locale]);
+	} catch (_err) {
+		locale = "en-US";
+	}
+	return {
+		locale,
+		direction: getReadingDirection(locale)
+	};
+}
+var currentLocale = getDefaultLocale();
+var listeners = /* @__PURE__ */ new Set();
+function updateLocale() {
+	currentLocale = getDefaultLocale();
+	for (const listener of listeners) listener(currentLocale);
+}
+function createDefaultLocale() {
+	const defaultSSRLocale = {
+		locale: "en-US",
+		direction: "ltr"
+	};
+	const [defaultClientLocale, setDefaultClientLocale] = createSignal(currentLocale);
+	const defaultLocale = createMemo(() => defaultSSRLocale);
+	onMount(() => {
+		if (listeners.size === 0) window.addEventListener("languagechange", updateLocale);
+		listeners.add(setDefaultClientLocale);
+		onCleanup(() => {
+			listeners.delete(setDefaultClientLocale);
+			if (listeners.size === 0) window.removeEventListener("languagechange", updateLocale);
+		});
+	});
+	return {
+		locale: () => defaultLocale().locale,
+		direction: () => defaultLocale().direction
+	};
+}
+var I18nContext = createContext();
+function useLocale() {
+	const defaultLocale = createDefaultLocale();
+	return useContext(I18nContext) || defaultLocale;
+}
+var cache = /* @__PURE__ */ new Map();
+function createCollator(options) {
+	const { locale } = useLocale();
+	const cacheKey = createMemo(() => {
+		return locale() + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	});
+	return createMemo(() => {
+		const key = cacheKey();
+		let collator;
+		if (cache.has(key)) collator = cache.get(key);
+		if (!collator) {
+			collator = new Intl.Collator(locale(), options);
+			cache.set(key, collator);
+		}
+		return collator;
+	});
+}
+//#endregion
+export { useLocale as a, createCollator as i, announce as n, clearAnnouncer as r, DATA_LIVE_ANNOUNCER_ATTR as t };

package/.output/server/_ssr/SignInMutation.graphql-BBXmiay6.mjs

@@ -0,0 +1,72 @@
+import { r as __toESM } from "../_runtime.mjs";
+import { n as require_relay_runtime } from "../_libs/relay-runtime.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/SignInMutation.graphql-BBXmiay6.js
+var import_relay_runtime = /* @__PURE__ */ __toESM(require_relay_runtime());
+/**
+* @generated SignedSource<<f922c28fa3ef1530d281ae9db8af9386>>
+* @lightSyntaxTransform
+*/
+var { ConcreteRequest } = import_relay_runtime?.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime?.default?.__esModule ? import_relay_runtime.default : import_relay_runtime;
+var node = function() {
+	var v0 = [{
+		"defaultValue": null,
+		"kind": "LocalArgument",
+		"name": "email"
+	}, {
+		"defaultValue": null,
+		"kind": "LocalArgument",
+		"name": "verifyUrl"
+	}], v1 = [{
+		"alias": null,
+		"args": [{
+			"kind": "Variable",
+			"name": "email",
+			"variableName": "email"
+		}, {
+			"kind": "Variable",
+			"name": "verifyUrl",
+			"variableName": "verifyUrl"
+		}],
+		"concreteType": "LoginChallenge",
+		"kind": "LinkedField",
+		"name": "loginByEmail",
+		"plural": false,
+		"selections": [{
+			"alias": null,
+			"args": null,
+			"kind": "ScalarField",
+			"name": "challengeId",
+			"storageKey": null
+		}],
+		"storageKey": null
+	}];
+	return {
+		"fragment": {
+			"argumentDefinitions": v0,
+			"kind": "Fragment",
+			"metadata": null,
+			"name": "SignInMutation",
+			"selections": v1,
+			"type": "Mutation",
+			"abstractKey": null
+		},
+		"kind": "Request",
+		"operation": {
+			"argumentDefinitions": v0,
+			"kind": "Operation",
+			"name": "SignInMutation",
+			"selections": v1
+		},
+		"params": {
+			"cacheID": "37e10229ff566b2aae936dd6e4f5eeba",
+			"id": null,
+			"metadata": {},
+			"name": "SignInMutation",
+			"operationKind": "mutation",
+			"text": "mutation SignInMutation(\n  $email: Email!\n  $verifyUrl: URITemplate!\n) {\n  loginByEmail(email: $email, verifyUrl: $verifyUrl) {\n    challengeId\n  }\n}\n"
+		}
+	};
+}();
+node.hash = "8c239b3bc42d23561c6a06c26b528dfd";
+//#endregion
+export { node as default };