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

package/.output/server/_ssr/actors-CMWf-xQU.mjs

@@ -0,0 +1,1160 @@
+import { r as __toESM } from "../_runtime.mjs";
+import { n as require_relay_runtime } from "../_libs/relay-runtime.mjs";
+import { $ as splitProps, A as batch, D as Show, F as createContext, H as createUniqueId, I as createEffect, K as mergeProps, L as createMemo, N as createComponent, V as createSignal, _ as ssrElement, g as ssrAttribute, h as ssr, nt as useContext, q as on, u as escape, v as ssrHydrationKey, y as ssrStyle } from "../_libs/solid-js.mjs";
+import { n as Title } from "./dist-D6rgyh-L.mjs";
+import { i as combineStyle, s as navigateWithToast } from "./Toast-Bb1gcxED.mjs";
+import { D as mergeDefaultProps, M as visuallyHiddenStyles, _ as getPrecision, a as __export, i as Polymorphic, j as snapValueToStep, l as createGenerateId, n as ButtonRoot, o as callHandler, s as composeEventHandlers, t as Button } from "./JNCCF6MP-BAZlBnvx.mjs";
+import { a as integer, c as minValue, d as object, h as pipe, u as number } from "../_libs/valibot.mjs";
+import { i as createMutation, o as createPreloadedQuery } from "../_libs/solid-relay+tiny-invariant.mjs";
+import { s as node$3 } from "./ssr.mjs";
+import { n as Form, r as createForm, t as Field } from "./dist-I7KRMRbA.mjs";
+import { a as FormControlErrorMessage, d as createFormControl, f as createFormControlField, g as useFormControlContext, i as FormControlDescription, m as form_module_default, n as FORM_CONTROL_PROP_NAMES, o as FormControlLabel, p as createFormResetListener, r as FormControlContext, s as access, t as FORM_CONTROL_FIELD_PROP_NAMES, u as createControllableSignal } from "./form.module-CTvIl1lm.mjs";
+import { a as useLocale, n as announce, r as clearAnnouncer } from "./LP6E37CW-D2Ih_b_K.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/actors-CMWf-xQU.js
+var import_relay_runtime = /* @__PURE__ */ __toESM(require_relay_runtime());
+/**
+* @generated SignedSource<<a0adbd723962824209886a67c97e521e>>
+* @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": "instance"
+	}, {
+		"defaultValue": null,
+		"kind": "LocalArgument",
+		"name": "size"
+	}], v1 = [{
+		"kind": "Variable",
+		"name": "instance",
+		"variableName": "instance"
+	}, {
+		"kind": "Variable",
+		"name": "size",
+		"variableName": "size"
+	}], v2 = {
+		"alias": "resultType",
+		"args": null,
+		"kind": "ScalarField",
+		"name": "__typename",
+		"storageKey": null
+	}, v3 = {
+		"kind": "InlineFragment",
+		"selections": [{
+			"alias": null,
+			"args": null,
+			"concreteType": "Actor",
+			"kind": "LinkedField",
+			"name": "actors",
+			"plural": true,
+			"selections": [
+				{
+					"alias": null,
+					"args": null,
+					"kind": "ScalarField",
+					"name": "id",
+					"storageKey": null
+				},
+				{
+					"alias": null,
+					"args": null,
+					"kind": "ScalarField",
+					"name": "uuid",
+					"storageKey": null
+				},
+				{
+					"alias": null,
+					"args": null,
+					"kind": "ScalarField",
+					"name": "username",
+					"storageKey": null
+				},
+				{
+					"alias": null,
+					"args": null,
+					"kind": "ScalarField",
+					"name": "handle",
+					"storageKey": null
+				},
+				{
+					"alias": null,
+					"args": null,
+					"kind": "ScalarField",
+					"name": "iri",
+					"storageKey": null
+				}
+			],
+			"storageKey": null
+		}],
+		"type": "CreateActorsSuccess",
+		"abstractKey": null
+	}, v4 = {
+		"kind": "InlineFragment",
+		"selections": [{
+			"alias": null,
+			"args": null,
+			"kind": "ScalarField",
+			"name": "type",
+			"storageKey": null
+		}, {
+			"alias": null,
+			"args": null,
+			"kind": "ScalarField",
+			"name": "message",
+			"storageKey": null
+		}],
+		"type": "CreateActorsError",
+		"abstractKey": null
+	};
+	return {
+		"fragment": {
+			"argumentDefinitions": v0,
+			"kind": "Fragment",
+			"metadata": null,
+			"name": "GenerateActorsMutation",
+			"selections": [{
+				"alias": null,
+				"args": v1,
+				"concreteType": null,
+				"kind": "LinkedField",
+				"name": "generateActors",
+				"plural": false,
+				"selections": [
+					v2,
+					v3,
+					v4
+				],
+				"storageKey": null
+			}],
+			"type": "Mutation",
+			"abstractKey": null
+		},
+		"kind": "Request",
+		"operation": {
+			"argumentDefinitions": v0,
+			"kind": "Operation",
+			"name": "GenerateActorsMutation",
+			"selections": [{
+				"alias": null,
+				"args": v1,
+				"concreteType": null,
+				"kind": "LinkedField",
+				"name": "generateActors",
+				"plural": false,
+				"selections": [
+					{
+						"alias": null,
+						"args": null,
+						"kind": "ScalarField",
+						"name": "__typename",
+						"storageKey": null
+					},
+					v2,
+					v3,
+					v4
+				],
+				"storageKey": null
+			}]
+		},
+		"params": {
+			"cacheID": "655241cbf60ac070f89be8c87cabe9d4",
+			"id": null,
+			"metadata": {},
+			"name": "GenerateActorsMutation",
+			"operationKind": "mutation",
+			"text": "mutation GenerateActorsMutation(\n  $instance: ID!\n  $size: Int!\n) {\n  generateActors(instance: $instance, size: $size) {\n    __typename\n    resultType: __typename\n    ... on CreateActorsSuccess {\n      actors {\n        id\n        uuid\n        username\n        handle\n        iri\n      }\n    }\n    ... on CreateActorsError {\n      type\n      message\n    }\n  }\n}\n"
+		}
+	};
+}();
+node.hash = "c9e9c50790753aeefacb0eb60b5e6adf";
+var SPIN_BUTTON_INTL_TRANSLATIONS = { empty: "Empty" };
+function SpinButtonRoot(props) {
+	const [local, others] = splitProps(mergeDefaultProps({ translations: SPIN_BUTTON_INTL_TRANSLATIONS }, props), [
+		"style",
+		"translations",
+		"value",
+		"textValue",
+		"minValue",
+		"maxValue",
+		"validationState",
+		"onIncrement",
+		"onIncrementPage",
+		"onDecrement",
+		"onDecrementPage",
+		"onDecrementToMin",
+		"onIncrementToMax",
+		"onKeyDown",
+		"onFocus",
+		"onBlur"
+	]);
+	let isFocused = false;
+	const textValue = createMemo(() => {
+		if (local.textValue === "") return local.translations?.empty;
+		return (local.textValue || `${local.value}`).replace("-", "−");
+	});
+	const onKeyDown = (e) => {
+		callHandler(e, local.onKeyDown);
+		if (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || props.readOnly) return;
+		switch (e.key) {
+			case "PageUp": if (local.onIncrementPage) {
+				e.preventDefault();
+				local.onIncrementPage();
+				break;
+			}
+			case "ArrowUp":
+			case "Up":
+				if (local.onIncrement) {
+					e.preventDefault();
+					local.onIncrement();
+				}
+				break;
+			case "PageDown": if (local.onDecrementPage) {
+				e.preventDefault();
+				local.onDecrementPage();
+				break;
+			}
+			case "ArrowDown":
+			case "Down":
+				if (local.onDecrement) {
+					e.preventDefault();
+					local.onDecrement();
+				}
+				break;
+			case "Home":
+				if (local.onDecrementToMin) {
+					e.preventDefault();
+					local.onDecrementToMin();
+				}
+				break;
+			case "End":
+				if (local.onIncrementToMax) {
+					e.preventDefault();
+					local.onIncrementToMax();
+				}
+				break;
+		}
+	};
+	const onFocus = (e) => {
+		callHandler(e, local.onFocus);
+		isFocused = true;
+	};
+	const onBlur = (e) => {
+		callHandler(e, local.onBlur);
+		isFocused = false;
+	};
+	createEffect(on(textValue, (textValue2) => {
+		if (isFocused) {
+			clearAnnouncer("assertive");
+			announce(textValue2 ?? "", "assertive");
+		}
+	}));
+	return createComponent(Polymorphic, mergeProps({
+		as: "div",
+		role: "spinbutton",
+		get style() {
+			return combineStyle({ "touch-action": "none" }, local.style);
+		},
+		get ["aria-valuenow"]() {
+			return local.value != null && !Number.isNaN(local.value) ? local.value : void 0;
+		},
+		get ["aria-valuetext"]() {
+			return textValue();
+		},
+		get ["aria-valuemin"]() {
+			return local.minValue;
+		},
+		get ["aria-valuemax"]() {
+			return local.maxValue;
+		},
+		get ["aria-required"]() {
+			return props.required || void 0;
+		},
+		get ["aria-disabled"]() {
+			return props.disabled || void 0;
+		},
+		get ["aria-readonly"]() {
+			return props.readOnly || void 0;
+		},
+		get ["aria-invalid"]() {
+			return local.validationState === "invalid" || void 0;
+		},
+		onKeyDown,
+		onFocus,
+		onBlur
+	}, others));
+}
+var $1dfb119a85e764e5$var$formatterCache = /* @__PURE__ */ new Map();
+var $1dfb119a85e764e5$var$supportsSignDisplay = false;
+try {
+	$1dfb119a85e764e5$var$supportsSignDisplay = new Intl.NumberFormat("de-DE", { signDisplay: "exceptZero" }).resolvedOptions().signDisplay === "exceptZero";
+} catch {}
+var $1dfb119a85e764e5$var$supportsUnit = false;
+try {
+	$1dfb119a85e764e5$var$supportsUnit = new Intl.NumberFormat("de-DE", {
+		style: "unit",
+		unit: "degree"
+	}).resolvedOptions().style === "unit";
+} catch {}
+var $1dfb119a85e764e5$var$UNITS = { degree: { narrow: {
+	default: "°",
+	"ja-JP": " 度",
+	"zh-TW": "度",
+	"sl-SI": " °"
+} } };
+var $1dfb119a85e764e5$export$cc77c4ff7e8673c5 = class {
+	constructor(locale, options = {}) {
+		this.numberFormatter = $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options);
+		this.options = options;
+	}
+	/**
+	* Formats a number value as a string, according to the locale and options provided to the
+	* constructor.
+	*/
+	format(value) {
+		let res = "";
+		if (!$1dfb119a85e764e5$var$supportsSignDisplay && this.options.signDisplay != null) res = $1dfb119a85e764e5$export$711b50b3c525e0f2(this.numberFormatter, this.options.signDisplay, value);
+		else res = this.numberFormatter.format(value);
+		if (this.options.style === "unit" && !$1dfb119a85e764e5$var$supportsUnit) {
+			let { unit, unitDisplay = "short", locale } = this.resolvedOptions();
+			if (!unit) return res;
+			let values = $1dfb119a85e764e5$var$UNITS[unit]?.[unitDisplay];
+			res += values[locale] || values.default;
+		}
+		return res;
+	}
+	/** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+	formatToParts(value) {
+		return this.numberFormatter.formatToParts(value);
+	}
+	/** Formats a number range as a string. */
+	formatRange(start, end) {
+		if (typeof this.numberFormatter.formatRange === "function") return this.numberFormatter.formatRange(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		return `${this.format(start)} \u{2013} ${this.format(end)}`;
+	}
+	/** Formats a number range as an array of parts. */
+	formatRangeToParts(start, end) {
+		if (typeof this.numberFormatter.formatRangeToParts === "function") return this.numberFormatter.formatRangeToParts(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		let startParts = this.numberFormatter.formatToParts(start);
+		let endParts = this.numberFormatter.formatToParts(end);
+		return [
+			...startParts.map((p) => ({
+				...p,
+				source: "startRange"
+			})),
+			{
+				type: "literal",
+				value: " – ",
+				source: "shared"
+			},
+			...endParts.map((p) => ({
+				...p,
+				source: "endRange"
+			}))
+		];
+	}
+	/** Returns the resolved formatting options based on the values passed to the constructor. */
+	resolvedOptions() {
+		let options = this.numberFormatter.resolvedOptions();
+		if (!$1dfb119a85e764e5$var$supportsSignDisplay && this.options.signDisplay != null) options = {
+			...options,
+			signDisplay: this.options.signDisplay
+		};
+		if (!$1dfb119a85e764e5$var$supportsUnit && this.options.style === "unit") options = {
+			...options,
+			style: "unit",
+			unit: this.options.unit,
+			unitDisplay: this.options.unitDisplay
+		};
+		return options;
+	}
+};
+function $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options = {}) {
+	let { numberingSystem } = options;
+	if (numberingSystem && locale.includes("-nu-")) {
+		if (!locale.includes("-u-")) locale += "-u-";
+		locale += `-nu-${numberingSystem}`;
+	}
+	if (options.style === "unit" && !$1dfb119a85e764e5$var$supportsUnit) {
+		let { unit, unitDisplay = "short" } = options;
+		if (!unit) throw new Error("unit option must be provided with style: \"unit\"");
+		if (!$1dfb119a85e764e5$var$UNITS[unit]?.[unitDisplay]) throw new Error(`Unsupported unit ${unit} with unitDisplay = ${unitDisplay}`);
+		options = {
+			...options,
+			style: "decimal"
+		};
+	}
+	let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	if ($1dfb119a85e764e5$var$formatterCache.has(cacheKey)) return $1dfb119a85e764e5$var$formatterCache.get(cacheKey);
+	let numberFormatter = new Intl.NumberFormat(locale, options);
+	$1dfb119a85e764e5$var$formatterCache.set(cacheKey, numberFormatter);
+	return numberFormatter;
+}
+function $1dfb119a85e764e5$export$711b50b3c525e0f2(numberFormat, signDisplay, num) {
+	if (signDisplay === "auto") return numberFormat.format(num);
+	else if (signDisplay === "never") return numberFormat.format(Math.abs(num));
+	else {
+		let needsPositiveSign = false;
+		if (signDisplay === "always") needsPositiveSign = num > 0 || Object.is(num, 0);
+		else if (signDisplay === "exceptZero") if (Object.is(num, -0) || Object.is(num, 0)) num = Math.abs(num);
+		else needsPositiveSign = num > 0;
+		if (needsPositiveSign) {
+			let negative = numberFormat.format(-num);
+			let noSign = numberFormat.format(num);
+			let minus = negative.replace(noSign, "").replace(/\u200e|\u061C/, "");
+			if ([...minus].length !== 1) console.warn("@react-aria/i18n polyfill for NumberFormat signDisplay: Unsupported case");
+			return negative.replace(noSign, "!!!").replace(minus, "+").replace("!!!", noSign);
+		} else return numberFormat.format(num);
+	}
+}
+var $eb76cf4feb040f77$var$CURRENCY_SIGN_REGEX = /* @__PURE__ */ new RegExp("^.*\\(.*\\).*$");
+var $eb76cf4feb040f77$var$NUMBERING_SYSTEMS = [
+	"latn",
+	"arab",
+	"hanidec",
+	"deva",
+	"beng",
+	"fullwide"
+];
+var $eb76cf4feb040f77$export$cd11ab140839f11d = class {
+	constructor(locale, options = {}) {
+		this.locale = locale;
+		this.options = options;
+	}
+	/**
+	* Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+	*/
+	parse(value) {
+		return $eb76cf4feb040f77$var$getNumberParserImpl(this.locale, this.options, value).parse(value);
+	}
+	/**
+	* Returns whether the given string could potentially be a valid number. This should be used to
+	* validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+	* of the minus/plus sign characters can be checked.
+	*/
+	isValidPartialNumber(value, minValue, maxValue) {
+		return $eb76cf4feb040f77$var$getNumberParserImpl(this.locale, this.options, value).isValidPartialNumber(value, minValue, maxValue);
+	}
+	/**
+	* Returns a numbering system for which the given string is valid in the current locale.
+	* If no numbering system could be detected, the default numbering system for the current
+	* locale is returned.
+	*/
+	getNumberingSystem(value) {
+		return $eb76cf4feb040f77$var$getNumberParserImpl(this.locale, this.options, value).options.numberingSystem;
+	}
+};
+var $eb76cf4feb040f77$var$numberParserCache = /* @__PURE__ */ new Map();
+function $eb76cf4feb040f77$var$getNumberParserImpl(locale, options, value) {
+	let defaultParser = $eb76cf4feb040f77$var$getCachedNumberParser(locale, options);
+	if (!locale.includes("-nu-") && !defaultParser.isValidPartialNumber(value)) {
+		for (let numberingSystem of $eb76cf4feb040f77$var$NUMBERING_SYSTEMS) if (numberingSystem !== defaultParser.options.numberingSystem) {
+			let parser = $eb76cf4feb040f77$var$getCachedNumberParser(locale + (locale.includes("-u-") ? "-nu-" : "-u-nu-") + numberingSystem, options);
+			if (parser.isValidPartialNumber(value)) return parser;
+		}
+	}
+	return defaultParser;
+}
+function $eb76cf4feb040f77$var$getCachedNumberParser(locale, options) {
+	let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	let parser = $eb76cf4feb040f77$var$numberParserCache.get(cacheKey);
+	if (!parser) {
+		parser = new $eb76cf4feb040f77$var$NumberParserImpl(locale, options);
+		$eb76cf4feb040f77$var$numberParserCache.set(cacheKey, parser);
+	}
+	return parser;
+}
+var $eb76cf4feb040f77$var$NumberParserImpl = class {
+	constructor(locale, options = {}) {
+		this.locale = locale;
+		if (options.roundingIncrement !== 1 && options.roundingIncrement != null) {
+			if (options.maximumFractionDigits == null && options.minimumFractionDigits == null) {
+				options.maximumFractionDigits = 0;
+				options.minimumFractionDigits = 0;
+			} else if (options.maximumFractionDigits == null) options.maximumFractionDigits = options.minimumFractionDigits;
+			else if (options.minimumFractionDigits == null) options.minimumFractionDigits = options.maximumFractionDigits;
+		}
+		this.formatter = new Intl.NumberFormat(locale, options);
+		this.options = this.formatter.resolvedOptions();
+		this.symbols = $eb76cf4feb040f77$var$getSymbols(locale, this.formatter, this.options, options);
+		if (this.options.style === "percent" && ((this.options.minimumFractionDigits ?? 0) > 18 || (this.options.maximumFractionDigits ?? 0) > 18)) console.warn("NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.");
+	}
+	parse(value) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		let fullySanitizedValue = this.sanitize(value);
+		if (!isGroupSymbolAllowed && this.symbols.group && fullySanitizedValue.includes(this.symbols.group)) return NaN;
+		else if (this.symbols.group) fullySanitizedValue = fullySanitizedValue.replaceAll(this.symbols.group, "");
+		if (this.symbols.decimal) fullySanitizedValue = fullySanitizedValue.replace(this.symbols.decimal, ".");
+		if (this.symbols.minusSign) fullySanitizedValue = fullySanitizedValue.replace(this.symbols.minusSign, "-");
+		fullySanitizedValue = fullySanitizedValue.replace(this.symbols.numeral, this.symbols.index);
+		if (this.options.style === "percent") {
+			let isNegative = fullySanitizedValue.indexOf("-");
+			fullySanitizedValue = fullySanitizedValue.replace("-", "");
+			fullySanitizedValue = fullySanitizedValue.replace("+", "");
+			let index = fullySanitizedValue.indexOf(".");
+			if (index === -1) index = fullySanitizedValue.length;
+			fullySanitizedValue = fullySanitizedValue.replace(".", "");
+			if (index - 2 === 0) fullySanitizedValue = `0.${fullySanitizedValue}`;
+			else if (index - 2 === -1) fullySanitizedValue = `0.0${fullySanitizedValue}`;
+			else if (index - 2 === -2) fullySanitizedValue = "0.00";
+			else fullySanitizedValue = `${fullySanitizedValue.slice(0, index - 2)}.${fullySanitizedValue.slice(index - 2)}`;
+			if (isNegative > -1) fullySanitizedValue = `-${fullySanitizedValue}`;
+		}
+		let newValue = fullySanitizedValue ? +fullySanitizedValue : NaN;
+		if (isNaN(newValue)) return NaN;
+		if (this.options.style === "percent") {
+			let options = {
+				...this.options,
+				style: "decimal",
+				minimumFractionDigits: Math.min((this.options.minimumFractionDigits ?? 0) + 2, 20),
+				maximumFractionDigits: Math.min((this.options.maximumFractionDigits ?? 0) + 2, 20)
+			};
+			return new $eb76cf4feb040f77$export$cd11ab140839f11d(this.locale, options).parse(new $1dfb119a85e764e5$export$cc77c4ff7e8673c5(this.locale, options).format(newValue));
+		}
+		if (this.options.currencySign === "accounting" && $eb76cf4feb040f77$var$CURRENCY_SIGN_REGEX.test(value)) newValue = -1 * newValue;
+		return newValue;
+	}
+	sanitize(value) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		if (this.symbols.noNumeralUnits.length > 0 && this.symbols.noNumeralUnits.find((obj) => obj.unit === value)) return this.symbols.noNumeralUnits.find((obj) => obj.unit === value).value.toString();
+		value = value.replace(this.symbols.literals, "");
+		if (this.symbols.minusSign) value = value.replace("-", this.symbols.minusSign);
+		if (this.options.numberingSystem === "arab") {
+			if (this.symbols.decimal) {
+				value = $eb76cf4feb040f77$var$replaceAll(value, ",", this.symbols.decimal);
+				value = $eb76cf4feb040f77$var$replaceAll(value, String.fromCharCode(1548), this.symbols.decimal);
+			}
+			if (this.symbols.group && isGroupSymbolAllowed) value = $eb76cf4feb040f77$var$replaceAll(value, ".", this.symbols.group);
+		}
+		if (this.symbols.group === "’" && value.includes("'") && isGroupSymbolAllowed) value = $eb76cf4feb040f77$var$replaceAll(value, "'", this.symbols.group);
+		if (this.symbols.group === "'" && value.includes("’") && isGroupSymbolAllowed) value = $eb76cf4feb040f77$var$replaceAll(value, "’", this.symbols.group);
+		if (this.options.locale === "fr-FR" && this.symbols.group && isGroupSymbolAllowed) {
+			value = $eb76cf4feb040f77$var$replaceAll(value, " ", this.symbols.group);
+			value = $eb76cf4feb040f77$var$replaceAll(value, /\u00A0/g, this.symbols.group);
+		}
+		return value;
+	}
+	isValidPartialNumber(value, minValue = -Infinity, maxValue = Infinity) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		value = this.sanitize(value);
+		if (this.symbols.minusSign && value.startsWith(this.symbols.minusSign) && minValue < 0) value = value.slice(this.symbols.minusSign.length);
+		else if (this.symbols.plusSign && value.startsWith(this.symbols.plusSign) && maxValue > 0) value = value.slice(this.symbols.plusSign.length);
+		if (this.symbols.decimal && value.indexOf(this.symbols.decimal) > -1 && this.options.maximumFractionDigits === 0) return false;
+		if (this.symbols.group && isGroupSymbolAllowed) value = $eb76cf4feb040f77$var$replaceAll(value, this.symbols.group, "");
+		value = value.replace(this.symbols.numeral, "");
+		if (this.symbols.decimal) value = value.replace(this.symbols.decimal, "");
+		return value.length === 0;
+	}
+};
+var $eb76cf4feb040f77$var$nonLiteralParts = /* @__PURE__ */ new Set([
+	"decimal",
+	"fraction",
+	"integer",
+	"minusSign",
+	"plusSign",
+	"group"
+]);
+var $eb76cf4feb040f77$var$pluralNumbers = [
+	0,
+	4,
+	2,
+	1,
+	11,
+	20,
+	3,
+	7,
+	100,
+	21,
+	.1,
+	1.1
+];
+function $eb76cf4feb040f77$var$getSymbols(locale, formatter, intlOptions, originalOptions) {
+	let symbolFormatter = new Intl.NumberFormat(locale, {
+		...intlOptions,
+		minimumSignificantDigits: 1,
+		maximumSignificantDigits: 21,
+		roundingIncrement: 1,
+		roundingPriority: "auto",
+		roundingMode: "halfExpand",
+		useGrouping: true
+	});
+	let allParts = symbolFormatter.formatToParts(-10000.111);
+	let posAllParts = symbolFormatter.formatToParts(10000.111);
+	let pluralParts = $eb76cf4feb040f77$var$pluralNumbers.map((n) => symbolFormatter.formatToParts(n));
+	let noNumeralUnits = pluralParts.map((p, i) => {
+		let unit = p.find((p) => p.type === "unit");
+		if (unit && !p.some((p) => p.type === "integer" || p.type === "fraction")) return {
+			unit: unit.value,
+			value: $eb76cf4feb040f77$var$pluralNumbers[i]
+		};
+		return null;
+	}).filter((p) => !!p);
+	let minusSign = allParts.find((p) => p.type === "minusSign")?.value ?? "-";
+	let plusSign = posAllParts.find((p) => p.type === "plusSign")?.value;
+	if (!plusSign && (originalOptions?.signDisplay === "exceptZero" || originalOptions?.signDisplay === "always")) plusSign = "+";
+	let decimal = new Intl.NumberFormat(locale, {
+		...intlOptions,
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2
+	}).formatToParts(.001).find((p) => p.type === "decimal")?.value;
+	let group = allParts.find((p) => p.type === "group")?.value;
+	let allPartsLiterals = allParts.filter((p) => !$eb76cf4feb040f77$var$nonLiteralParts.has(p.type)).map((p) => $eb76cf4feb040f77$var$escapeRegex(p.value));
+	let pluralPartsLiterals = pluralParts.flatMap((p) => p.filter((p) => !$eb76cf4feb040f77$var$nonLiteralParts.has(p.type)).map((p) => $eb76cf4feb040f77$var$escapeRegex(p.value)));
+	let sortedLiterals = [.../* @__PURE__ */ new Set([...allPartsLiterals, ...pluralPartsLiterals])].sort((a, b) => b.length - a.length);
+	let literals = sortedLiterals.length === 0 ? /* @__PURE__ */ new RegExp("\\p{White_Space}|\\p{Cf}", "gu") : new RegExp(`${sortedLiterals.join("|")}|\\p{White_Space}|\\p{Cf}`, "gu");
+	let numerals = [...new Intl.NumberFormat(intlOptions.locale, { useGrouping: false }).format(9876543210)].reverse();
+	let indexes = new Map(numerals.map((d, i) => [d, i]));
+	let numeral = new RegExp(`[${numerals.join("")}]`, "g");
+	let index = (d) => String(indexes.get(d));
+	return {
+		minusSign,
+		plusSign,
+		decimal,
+		group,
+		literals,
+		numeral,
+		numerals,
+		index,
+		noNumeralUnits
+	};
+}
+function $eb76cf4feb040f77$var$replaceAll(str, find, replace) {
+	if (str.replaceAll) return str.replaceAll(find, replace);
+	return str.split(find).join(replace);
+}
+function $eb76cf4feb040f77$var$escapeRegex(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var _tmpl$$1 = [
+	"<div",
+	" style=\"",
+	"\" aria-hidden=\"true\">",
+	"</div>"
+];
+__export({}, {
+	DecrementTrigger: () => NumberFieldDecrementTrigger,
+	Description: () => FormControlDescription,
+	ErrorMessage: () => FormControlErrorMessage,
+	HiddenInput: () => NumberFieldHiddenInput,
+	IncrementTrigger: () => NumberFieldIncrementTrigger,
+	Input: () => NumberFieldInput,
+	Label: () => FormControlLabel,
+	NumberField: () => NumberField,
+	Root: () => NumberFieldRoot,
+	useNumberFieldContext: () => useNumberFieldContext
+});
+var NumberFieldContext = createContext();
+function useNumberFieldContext() {
+	const context = useContext(NumberFieldContext);
+	if (context === void 0) throw new Error("[kobalte]: `useNumberFieldContext` must be used within a `NumberField` component");
+	return context;
+}
+function NumberFieldVaryTrigger(props) {
+	const formControlContext = useFormControlContext();
+	const context = useNumberFieldContext();
+	const [local, others] = splitProps(props, ["numberFieldVaryType", "onClick"]);
+	return createComponent(ButtonRoot, mergeProps({
+		tabIndex: -1,
+		get disabled() {
+			return formControlContext.isDisabled() || context.rawValue() === (local.numberFieldVaryType === "increment" ? context.maxValue() : context.minValue());
+		},
+		get ["aria-controls"]() {
+			return formControlContext.fieldId();
+		},
+		onClick: (e) => {
+			callHandler(e, local.onClick);
+			context.varyValue(context.step() * (local.numberFieldVaryType === "increment" ? 1 : -1));
+			context.inputRef()?.focus({ preventScroll: true });
+		}
+	}, others));
+}
+function NumberFieldDecrementTrigger(props) {
+	return createComponent(NumberFieldVaryTrigger, mergeProps({ numberFieldVaryType: "decrement" }, props));
+}
+function NumberFieldHiddenInput(props) {
+	const context = useNumberFieldContext();
+	const [local, others] = splitProps(props, ["ref", "onChange"]);
+	const formControlContext = useFormControlContext();
+	return ssr(_tmpl$$1, ssrHydrationKey(), ssrStyle(visuallyHiddenStyles), ssrElement("input", mergeProps({
+		type: "text",
+		tabIndex: -1,
+		style: { "font-size": "16px" },
+		get name() {
+			return formControlContext.name();
+		},
+		get value() {
+			return Number.isNaN(context.rawValue()) ? "" : context.rawValue();
+		},
+		get required() {
+			return formControlContext.isRequired();
+		},
+		get disabled() {
+			return formControlContext.isDisabled();
+		},
+		get readOnly() {
+			return formControlContext.isReadOnly();
+		}
+	}, others), void 0, false));
+}
+function NumberFieldIncrementTrigger(props) {
+	return createComponent(NumberFieldVaryTrigger, mergeProps({ numberFieldVaryType: "increment" }, props));
+}
+function NumberFieldInput(props) {
+	const formControlContext = useFormControlContext();
+	const context = useNumberFieldContext();
+	const [local, formControlFieldProps, others] = splitProps(mergeDefaultProps({
+		id: context.generateId("input"),
+		inputMode: "decimal",
+		autocomplete: "off",
+		autocorrect: "off",
+		spellcheck: false
+	}, props), [
+		"ref",
+		"onInput",
+		"onChange",
+		"onWheel",
+		"as"
+	], FORM_CONTROL_FIELD_PROP_NAMES);
+	const { fieldProps } = createFormControlField(formControlFieldProps);
+	return createComponent(SpinButtonRoot, mergeProps({
+		type: "text",
+		get id() {
+			return fieldProps.id();
+		},
+		get value() {
+			return context.value();
+		},
+		get validationState() {
+			return formControlContext.validationState();
+		},
+		get required() {
+			return formControlContext.isRequired();
+		},
+		get disabled() {
+			return formControlContext.isDisabled();
+		},
+		get readOnly() {
+			return formControlContext.isReadOnly();
+		},
+		get textValue() {
+			return context.textValue();
+		},
+		get minValue() {
+			return context.minValue();
+		},
+		get maxValue() {
+			return context.maxValue();
+		},
+		onIncrement: () => {
+			context.varyValue(context.step());
+		},
+		onIncrementPage: () => {
+			context.varyValue(context.largeStep());
+		},
+		onIncrementToMax: () => {
+			context.setValue(context.maxValue());
+			context.format();
+		},
+		onDecrement: () => {
+			context.varyValue(-context.step());
+		},
+		onDecrementPage: () => {
+			context.varyValue(-context.largeStep());
+		},
+		onDecrementToMin: () => {
+			context.setValue(context.minValue());
+			context.format();
+		},
+		get translations() {
+			return context.translations();
+		},
+		onChange: (e) => {
+			callHandler(e, local.onChange);
+			context.format();
+		},
+		onWheel: (e) => {
+			callHandler(e, local.onWheel);
+			if (!context.changeOnWheel() || document.activeElement !== context.inputRef()) return;
+			e.preventDefault();
+			if (e.deltaY < 0) context.varyValue(context.step());
+			else context.varyValue(-context.step());
+		},
+		get onInput() {
+			return composeEventHandlers([local.onInput, context.onInput]);
+		},
+		get ["aria-label"]() {
+			return fieldProps.ariaLabel();
+		},
+		get ["aria-labelledby"]() {
+			return fieldProps.ariaLabelledBy();
+		},
+		get ["aria-describedby"]() {
+			return fieldProps.ariaDescribedBy();
+		}
+	}, () => formControlContext.dataset(), { as: (props2) => createComponent(Polymorphic, mergeProps({
+		get as() {
+			return local.as || "input";
+		},
+		get value() {
+			return Number.isNaN(context.rawValue()) || context.value() === void 0 ? "" : context.formatNumber(context.rawValue());
+		},
+		get required() {
+			return formControlContext.isRequired();
+		},
+		get disabled() {
+			return formControlContext.isDisabled();
+		},
+		get readOnly() {
+			return formControlContext.isReadOnly();
+		}
+	}, props2, others)) }));
+}
+function NumberFieldRoot(props) {
+	let ref;
+	const mergedProps = mergeDefaultProps({
+		id: `NumberField-${createUniqueId()}`,
+		format: true,
+		minValue: Number.MIN_SAFE_INTEGER,
+		maxValue: Number.MAX_SAFE_INTEGER,
+		step: 1,
+		changeOnWheel: true
+	}, props);
+	const [local, formControlProps, others] = splitProps(mergedProps, [
+		"ref",
+		"value",
+		"defaultValue",
+		"onChange",
+		"rawValue",
+		"onRawValueChange",
+		"translations",
+		"format",
+		"formatOptions",
+		"textValue",
+		"minValue",
+		"maxValue",
+		"step",
+		"largeStep",
+		"changeOnWheel",
+		"translations",
+		"allowedInput"
+	], FORM_CONTROL_PROP_NAMES);
+	const { locale } = useLocale();
+	const numberParser = createMemo(() => {
+		return new $eb76cf4feb040f77$export$cd11ab140839f11d(locale(), local.formatOptions);
+	});
+	const numberFormatter = createMemo(() => {
+		return new $1dfb119a85e764e5$export$cc77c4ff7e8673c5(locale(), local.formatOptions);
+	});
+	const formatNumber = (number) => local.format ? numberFormatter().format(number) : number.toString();
+	const parseRawValue = (value2) => local.format && typeof value2 !== "number" ? numberParser().parse(value2 ?? "") : Number(value2 ?? "");
+	const isValidPartialValue = (value2) => local.format && typeof value2 !== "number" ? numberParser().isValidPartialNumber(value2 ?? "", mergedProps.minValue, mergedProps.maxValue) : !Number.isNaN(Number(value2));
+	const [value, setValue] = createControllableSignal({
+		value: () => local.value,
+		defaultValue: () => local.defaultValue ?? local.rawValue,
+		onChange: (value2) => {
+			local.onChange?.(typeof value2 === "number" ? formatNumber(value2) : value2);
+			local.onRawValueChange?.(parseRawValue(value2));
+		}
+	});
+	if (value() !== void 0) local.onRawValueChange?.(parseRawValue(value()));
+	function isAllowedInput(char) {
+		if (local.allowedInput !== void 0) return local.allowedInput.test(char);
+		return true;
+	}
+	const { formControlContext } = createFormControl(formControlProps);
+	createFormResetListener(() => ref, () => {
+		setValue(local.defaultValue ?? "");
+	});
+	const [inputRef, setInputRef] = createSignal();
+	const [hiddenInputRef, setHiddenInputRef] = createSignal();
+	const onInput = (e) => {
+		if (formControlContext.isReadOnly() || formControlContext.isDisabled()) return;
+		const target = e.target;
+		let cursorPosition = target.selectionStart;
+		if (isValidPartialValue(target.value)) {
+			if (e.inputType !== "insertText" || isAllowedInput(e.data || "")) setValue(target.value);
+		} else if (e.inputType === "deleteContentBackward") {
+			if (cursorPosition !== null) cursorPosition += 1;
+		}
+		const v = value();
+		if (v !== target.value) {
+			target.value = String(v ?? "");
+			if (cursorPosition !== null) {
+				target.selectionStart = cursorPosition;
+				target.selectionEnd = cursorPosition;
+			}
+		}
+	};
+	const context = {
+		value,
+		setValue,
+		rawValue: () => parseRawValue(value()),
+		generateId: createGenerateId(() => access(formControlProps.id)),
+		formatNumber,
+		format: () => {
+			if (!local.format) return;
+			let rawValue = context.rawValue();
+			if (Number.isNaN(rawValue)) {
+				if (hiddenInputRef()) hiddenInputRef().value = "";
+				local.onRawValueChange?.(rawValue);
+				return;
+			}
+			if (context.minValue()) rawValue = Math.max(rawValue, context.minValue());
+			if (context.maxValue()) rawValue = Math.min(rawValue, context.maxValue());
+			const formattedValue = context.formatNumber(rawValue);
+			if (value() != formattedValue) setValue(formattedValue);
+			if (inputRef()) inputRef().value = formattedValue;
+			if (hiddenInputRef()) hiddenInputRef().value = String(rawValue);
+		},
+		onInput,
+		textValue: () => local.textValue,
+		minValue: () => local.minValue,
+		maxValue: () => local.maxValue,
+		step: () => local.step,
+		largeStep: () => local.largeStep ?? local.step * 10,
+		changeOnWheel: () => local.changeOnWheel,
+		translations: () => local.translations,
+		inputRef,
+		setInputRef,
+		hiddenInputRef,
+		setHiddenInputRef,
+		varyValue: (offset) => {
+			let rawValue = context.rawValue() ?? 0;
+			if (Number.isNaN(rawValue)) rawValue = 0;
+			batch(() => {
+				let newValue = rawValue;
+				const operation = offset > 0 ? "+" : "-";
+				const localStep = Math.abs(offset);
+				const min = props.minValue === void 0 ? NaN : context.minValue();
+				const max = props.maxValue === void 0 ? NaN : context.maxValue();
+				newValue = snapValueToStep(rawValue, min, max, localStep);
+				if (!(operation === "+" && newValue > rawValue || operation === "-" && newValue < rawValue)) newValue = snapValueToStep(handleDecimalOperation(operation, rawValue, localStep), min, max, localStep);
+				context.setValue(newValue);
+				context.format();
+			});
+		}
+	};
+	createEffect(on(() => local.rawValue, (rawValue) => {
+		if (rawValue !== context.rawValue()) {
+			if (Number.isNaN(rawValue)) return;
+			batch(() => {
+				setValue(rawValue ?? "");
+				context.format();
+			});
+		}
+	}, { defer: true }));
+	return createComponent(FormControlContext.Provider, {
+		value: formControlContext,
+		get children() {
+			return createComponent(NumberFieldContext.Provider, {
+				value: context,
+				get children() {
+					return createComponent(Polymorphic, mergeProps({
+						as: "div",
+						role: "group",
+						get id() {
+							return access(formControlProps.id);
+						}
+					}, () => formControlContext.dataset(), others));
+				}
+			});
+		}
+	});
+}
+function handleDecimalOperation(operator, value1, value2) {
+	let result = operator === "+" ? value1 + value2 : value1 - value2;
+	if (Number.isFinite(value1) && Number.isFinite(value2) && (value2 % 1 !== 0 || value1 % 1 !== 0)) {
+		const offsetPrecision = getPrecision(value2);
+		const valuePrecision = getPrecision(value1);
+		const multiplier = 10 ** Math.max(offsetPrecision, valuePrecision);
+		const multipliedOffset = Math.round(value2 * multiplier);
+		const multipliedValue = Math.round(value1 * multiplier);
+		result = (operator === "+" ? multipliedValue + multipliedOffset : multipliedValue - multipliedOffset) / multiplier;
+	}
+	return result;
+}
+var NumberField = Object.assign(NumberFieldRoot, {
+	Description: FormControlDescription,
+	ErrorMessage: FormControlErrorMessage,
+	HiddenInput: NumberFieldHiddenInput,
+	Input: NumberFieldInput,
+	IncrementTrigger: NumberFieldIncrementTrigger,
+	DecrementTrigger: NumberFieldDecrementTrigger,
+	Label: FormControlLabel
+});
+var { graphql } = import_relay_runtime?.default?.default?.__esModule ? import_relay_runtime.default.default : import_relay_runtime?.default?.__esModule ? import_relay_runtime.default : import_relay_runtime;
+var _tmpl$ = [
+	"<p",
+	" class=\"",
+	"\" role=\"alert\">",
+	"</p>"
+];
+var _tmpl$2 = [
+	"<main",
+	"><!--$-->",
+	"<!--/--><section",
+	" aria-labelledby=\"create-actors-title\"><header",
+	"><h1 id=\"create-actors-title\">Create Actors</h1><p>Selected Instance: <!--$-->",
+	"<!--/--></p></header><!--$-->",
+	"<!--/--><!--$-->",
+	"<!--/--></section></main>"
+];
+var _tmpl$3 = [
+	"<span",
+	" class=\"",
+	"\" role=\"alert\">",
+	"</span>"
+];
+var id$$ = "src/routes/workspace/create/[instance_id]/actors.tsx?pick=default&pick=$css&lang.tsx";
+var getHostQuery = node$3;
+var generateActorsMutation = node;
+var generateActorsSchema = object({ size: pipe(number("Enter the number of actors."), integer("The number of actors must be a whole number."), minValue(1, "Create at least one actor.")) });
+function CreateActorsPage(props) {
+	const [errorMessage, setErrorMessage] = createSignal();
+	const [commitGenerateActors, isGeneratingActors] = createMutation(generateActorsMutation);
+	const data = createPreloadedQuery(getHostQuery, () => props.data);
+	const generateActorsForm = createForm({
+		schema: generateActorsSchema,
+		initialInput: { size: 1 }
+	});
+	const submit = ({ size }) => {
+		const { id: instance, host, localInstance } = data()?.instance ?? {};
+		const slug = localInstance?.slug;
+		if (instance === void 0 || slug === void 0) {
+			setErrorMessage("Instance not found.");
+			return;
+		}
+		setErrorMessage(void 0);
+		commitGenerateActors({
+			variables: {
+				instance,
+				size
+			},
+			onCompleted: (response, errors) => {
+				const graphQLErrors = errors ?? [];
+				if (graphQLErrors.length > 0) {
+					setErrorMessage(graphQLErrors.map((error) => error.message).join("\n"));
+					return;
+				}
+				const result = response.generateActors;
+				switch (result.resultType) {
+					case "CreateActorsSuccess":
+						navigateWithToast(`/instance/${encodeURIComponent(slug)}`, `Successfully created actors on ${host}.`, "success");
+						return;
+					case "CreateActorsError": switch (result.type) {
+						case "InvalidSize":
+							setErrorMessage("Enter at least one actor.");
+							return;
+						case "InstanceNotFound":
+							setErrorMessage("The selected instance could not be found or is no longer available.");
+							return;
+						case "InvalidInstanceHost":
+						case "TooManyActors":
+							setErrorMessage(result.message);
+							return;
+						case "%future added value":
+							setErrorMessage("The server returned an unsupported actor-generation error.");
+							return;
+						default:
+							setErrorMessage("Unable to generate actors.");
+							return;
+					}
+					case "%other":
+						setErrorMessage("Unable to generate actors.");
+						return;
+					default: setErrorMessage("Unable to generate actors.");
+				}
+			},
+			onError: (error) => {
+				setErrorMessage(error.message);
+			}
+		});
+	};
+	return ssr(_tmpl$2, ssrHydrationKey() + ssrAttribute("class", escape(form_module_default.page, true), false), escape(createComponent(Title, { children: "Create Actors" })), ssrAttribute("class", escape(form_module_default.panel, true), false), ssrAttribute("class", escape(form_module_default.header, true), false), escape(data()?.instance?.host), escape(createComponent(Form, {
+		get ["class"]() {
+			return form_module_default.form;
+		},
+		of: generateActorsForm,
+		onSubmit: submit,
+		get children() {
+			return [createComponent(Field, {
+				of: generateActorsForm,
+				path: ["size"],
+				children: (field) => createComponent(NumberField, {
+					get ["class"]() {
+						return form_module_default.field;
+					},
+					get name() {
+						return field.props.name;
+					},
+					get value() {
+						return Number.isNaN(field.input) ? "" : field.input ?? "";
+					},
+					minValue: 1,
+					onRawValueChange: (value) => {
+						field.onInput(Number.isNaN(value) ? void 0 : value);
+					},
+					get children() {
+						return [
+							createComponent(NumberField.Label, {
+								get ["class"]() {
+									return form_module_default.field;
+								},
+								children: "Size"
+							}),
+							createComponent(NumberField.Input, {
+								get onFocus() {
+									return field.props.onFocus;
+								},
+								get onBlur() {
+									return field.props.onBlur;
+								},
+								get ["class"]() {
+									return form_module_default.input;
+								},
+								get ["aria-invalid"]() {
+									return Boolean(field.errors);
+								}
+							}),
+							createComponent(NumberField.Description, {
+								get ["class"]() {
+									return form_module_default.hint;
+								},
+								get children() {
+									return ["DrFed generates actors in ", data()?.instance?.host];
+								}
+							}),
+							createComponent(Show, {
+								get when() {
+									return field.errors;
+								},
+								children: (errors) => ssr(_tmpl$3, ssrHydrationKey(), `${escape(form_module_default.notice, true)} ${escape(form_module_default.error, true)}`, escape(errors()[0]))
+							})
+						];
+					}
+				})
+			}), createComponent(Button, {
+				get ["class"]() {
+					return form_module_default.button;
+				},
+				type: "submit",
+				get disabled() {
+					return isGeneratingActors() || data()?.instance?.localInstance?.slug === void 0;
+				},
+				children: "Create Actors"
+			})];
+		}
+	})), escape(createComponent(Show, {
+		get when() {
+			return errorMessage();
+		},
+		get children() {
+			return ssr(_tmpl$, ssrHydrationKey(), `${escape(form_module_default.notice, true)} ${escape(form_module_default.error, true)}`, escape(errorMessage()));
+		}
+	})));
+}
+//#endregion
+export { CreateActorsPage as default, id$$ };