@qw-ui/core 0.3.0-next.40 → 0.3.0-next.43

package/dist/rate-5XsU2QkY.js

@@ -0,0 +1,631 @@
+import { a as resolveIconName, o as resolveIconState } from "./icon-Cgdbnk1u.js";
+import { createMachine } from "@zag-js/core";
+import { addDomEvent, dataAttr, getAncestorElements, getComputedStyle, getEventKey, getEventPoint, getNodeName, isHTMLElement, isInputElement, observeAttributes, observeChildren, setProperty, visuallyHiddenStyle } from "@zag-js/dom-query";
+//#region src/rate/rate-form.ts
+/**
+* The value content attribute and the value property are the same effective form string.
+* HTML reset reads that attribute, so defaultValue must not be a different initial string.
+* A connected reset still requests the declared default through onReset, then syncs again.
+* Read-only is intentionally not copied onto the proxy.
+*/
+function syncRateInput(options) {
+	const input = options.scope.getById(options.inputId);
+	if (!isInputElement(input)) return;
+	const limits = options.constraints();
+	const current = options.current();
+	setProperty(input, "defaultValue", current);
+	setProperty(input, "value", current);
+	setProperty(input, "required", limits.required);
+	setProperty(input, "disabled", limits.disabled);
+	setProperty(input, "min", limits.min);
+	setProperty(input, "max", limits.max);
+	setProperty(input, "step", limits.step);
+}
+/** Actual form ownership, cancellation and native fieldset disabled rules are tracked in Core. */
+function trackRateForm(options) {
+	let stopped = false, queued = false, lastDisabled;
+	const cleanups = [], pending = /* @__PURE__ */ new Set();
+	const release = () => {
+		cleanups.splice(0).forEach((cleanup) => cleanup());
+	};
+	const sync = () => {
+		if (!stopped) syncRateInput(options);
+	};
+	const refreshSoon = () => {
+		if (stopped || queued) return;
+		queued = true;
+		queueMicrotask(() => {
+			queued = false;
+			refresh();
+		});
+	};
+	function refresh() {
+		if (stopped) return;
+		release();
+		const input = options.scope.getById(options.inputId), root = options.scope.getById(options.rootId);
+		if (!isInputElement(input)) return;
+		const disabled = input.matches(":disabled");
+		if (disabled !== lastDisabled) {
+			lastDisabled = disabled;
+			options.onDisabledChange(disabled);
+		}
+		if (input.form && getNodeName(input.form) === "form") cleanups.push(addDomEvent(input.form, "reset", (event) => {
+			const timer = setTimeout(() => {
+				pending.delete(timer);
+				if (stopped || event.defaultPrevented) return;
+				options.onReset();
+				sync();
+			}, 0);
+			pending.add(timer);
+		}));
+		for (const node of getAncestorElements(input).filter(isHTMLElement)) if (getNodeName(node) === "fieldset") cleanups.push(observeAttributes(node, {
+			attributes: ["disabled"],
+			callback: refreshSoon
+		}));
+		cleanups.push(observeAttributes(input, {
+			attributes: [
+				"disabled",
+				"form",
+				"name",
+				"required"
+			],
+			callback: refreshSoon
+		}));
+		const Observer = input.ownerDocument.defaultView?.MutationObserver;
+		if (Observer) {
+			const observer = new Observer(refreshSoon);
+			for (const node of getAncestorElements(input).filter(isHTMLElement)) observer.observe(node, { childList: true });
+			cleanups.push(() => observer.disconnect());
+		}
+		if (isHTMLElement(root)) cleanups.push(observeChildren(root, { callback: refreshSoon }));
+		sync();
+	}
+	refresh();
+	return () => {
+		stopped = true;
+		release();
+		pending.forEach(clearTimeout);
+		pending.clear();
+	};
+}
+//#endregion
+//#region src/rate/rate.ts
+const RATE_SIZES = [
+	"sm",
+	"md",
+	"lg"
+];
+const RATE_PARTS = [
+	"root",
+	"label",
+	"description",
+	"control",
+	"item",
+	"empty-icon",
+	"filled-icon",
+	"input",
+	"clear",
+	"content"
+];
+function normalizeRateCount(count) {
+	return typeof count === "number" && Number.isSafeInteger(count) && count >= 1 && count <= 1e3 ? count : 5;
+}
+const rawValue = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+function normalizeRateValue(value, count = 5, allowHalf = false, readOnly = false) {
+	const bounded = Math.min(normalizeRateCount(count), rawValue(value));
+	return readOnly ? bounded : Math.round(bounded * (allowHalf ? 2 : 1)) / (allowHalf ? 2 : 1);
+}
+/** Logical item geometry includes gaps; midpoint and gap ties prefer the preceding half/item. */
+function getRatePointValue(x, rects, allowHalf, dir) {
+	if (!Number.isFinite(x)) return null;
+	const items = rects.filter((rect) => Number.isFinite(rect.left) && Number.isFinite(rect.right) && rect.right > rect.left).slice().sort((a, b) => dir === "rtl" ? b.right - a.right : a.left - b.left);
+	if (!items.length) return null;
+	if (dir === "rtl" ? x > items[0].right : x < items[0].left) return 0;
+	if (dir === "rtl" ? x < items.at(-1).left : x > items.at(-1).right) return items.length;
+	let index = 0, distance = Infinity;
+	for (const [i, item] of items.entries()) {
+		const next = x < item.left ? item.left - x : x > item.right ? x - item.right : 0;
+		if (next < distance) {
+			index = i;
+			distance = next;
+		}
+	}
+	const item = items[index], half = dir === "rtl" ? x >= (item.left + item.right) / 2 : x <= (item.left + item.right) / 2;
+	return index + (allowHalf && half ? .5 : 1);
+}
+/**
+* Width of the touch target, measured from its inline start, that reaches `fill` of a centered glyph.
+* Half often matches by centering; other fractions do not. Rendering must clip the glyph box instead.
+*/
+function rateTouchCoverageForGlyphFill(fill, touch, glyph) {
+	if (!Number.isFinite(fill) || !Number.isFinite(touch) || !Number.isFinite(glyph) || !(touch > 0) || glyph < 0 || glyph > touch) throw new RangeError("Rate glyph box must fit inside its touch target");
+	const clamped = Math.min(1, Math.max(0, fill));
+	return ((touch - glyph) / 2 + clamped * glyph) / touch;
+}
+function createRateProps(props) {
+	if (typeof props.label !== "string" || !props.label.trim()) throw new TypeError("Rate requires a nonempty accessible label");
+	if (props.id !== void 0 && (typeof props.id !== "string" || !props.id.trim())) throw new TypeError("Rate requires a nonempty instance id when provided");
+	return {
+		...props,
+		count: normalizeRateCount(props.count),
+		value: props.value === void 0 ? void 0 : rawValue(props.value),
+		defaultValue: rawValue(props.defaultValue),
+		allowHalf: props.allowHalf ?? false,
+		allowClear: props.allowClear ?? true,
+		touchable: props.touchable ?? true,
+		size: RATE_SIZES.includes(props.size) ? props.size : "md",
+		iconName: resolveIconName(props.iconName ?? "star-fill"),
+		emptyIconName: resolveIconName(props.emptyIconName ?? "star"),
+		valueTextTemplate: props.valueTextTemplate?.trim() ? props.valueTextTemplate : "{value} / {count}",
+		clearLabel: props.clearLabel?.trim() ? props.clearLabel : "清除评分"
+	};
+}
+function prefix(id) {
+	return `qw-rate-${id.split("").map((char) => char.charCodeAt(0).toString(16).padStart(4, "0")).join("")}`;
+}
+const rootId = (scope) => {
+	if (!scope.id?.trim()) throw new TypeError("Rate requires a nonempty stable id");
+	return prefix(scope.id);
+};
+const inputId = (scope) => `${rootId(scope)}-input`;
+const controlId = (scope) => `${rootId(scope)}-control`;
+const effective = (params, value = params.context.get("value")) => normalizeRateValue(value, params.prop("count"), params.prop("allowHalf"), params.prop("readOnly"));
+const locked = (params) => !!params.prop("disabled") || params.context.get("inheritedDisabled") || !!params.prop("readOnly");
+const formValue = (params, value) => params.prop("required") && value === 0 ? "" : String(value);
+const glyphFill = (value) => Math.round(Math.max(0, Math.min(1, value)) * 1e6) / 1e6;
+const constraints = (params) => ({
+	required: !!params.prop("required"),
+	disabled: !!params.prop("disabled"),
+	min: "0",
+	max: String(params.prop("count")),
+	step: params.prop("readOnly") ? "any" : params.prop("allowHalf") ? "0.5" : "1"
+});
+const sync = (params) => {
+	syncRateInput({
+		scope: params.scope,
+		inputId: inputId(params.scope),
+		current: () => formValue(params, effective(params)),
+		initial: () => formValue(params, effective(params, params.prop("defaultValue"))),
+		constraints: () => constraints(params)
+	});
+	if (!params.context.get("validationError")) return;
+	const input = params.scope.getById(inputId(params.scope));
+	if (!isInputElement(input) || input.matches(":disabled") || input.validity.valid) params.context.set("validationError", false);
+};
+const clearPreview = (params) => {
+	params.context.set("previewValue", null);
+	params.context.set("pointerId", null);
+	params.context.set("moved", false);
+};
+/** One bindable owns raw models; mode/domain changes derive values without fake change callbacks. */
+const rateMachine = createMachine({
+	props: ({ props }) => createRateProps({
+		...props,
+		label: props.label ?? ""
+	}),
+	initialState: () => "ready",
+	context({ prop, bindable }) {
+		return {
+			value: bindable(() => ({
+				defaultValue: prop("defaultValue"),
+				value: prop("value"),
+				onChange: (value) => prop("onValueChange")?.({ value })
+			})),
+			previewValue: bindable(() => ({
+				defaultValue: null,
+				onChange: (value) => prop("onPreviewChange")?.({ value })
+			})),
+			focused: bindable(() => ({ defaultValue: false })),
+			pointerId: bindable(() => ({ defaultValue: null })),
+			startX: bindable(() => ({ defaultValue: 0 })),
+			startY: bindable(() => ({ defaultValue: 0 })),
+			moved: bindable(() => ({ defaultValue: false })),
+			inheritedDisabled: bindable(() => ({ defaultValue: false })),
+			validationError: bindable(() => ({ defaultValue: false }))
+		};
+	},
+	watch({ track, context, prop, action, send }) {
+		track([() => context.hash("value")], () => {
+			context.set("validationError", false);
+			action(["syncInput"]);
+		});
+		track([
+			() => prop("count"),
+			() => prop("allowHalf"),
+			() => prop("readOnly"),
+			() => prop("disabled"),
+			() => prop("required"),
+			() => prop("defaultValue")
+		], () => send({ type: "DOMAIN.CHANGED" }));
+	},
+	effects: ["trackForm"],
+	on: {
+		"VALUE.SET": { actions: ["setValue", "syncInput"] },
+		"PREVIEW.SET": { actions: ["setPreview"] },
+		"FOCUS.SET": { actions: ["setFocus"] },
+		"DISABLED.SET": { actions: ["setDisabled"] },
+		"FORM.RESET": {
+			target: "ready",
+			actions: [
+				"resetForm",
+				"cancelPointer",
+				"syncInput"
+			]
+		},
+		"INVALID": { actions: ["markInvalid"] },
+		"DOMAIN.CHANGED": {
+			target: "ready",
+			actions: ["cancelPointer", "syncInput"]
+		},
+		"POINTER.CANCEL": {
+			guard: ({ event, context }) => event.type === "POINTER.CANCEL" && (event.pointerId === void 0 || event.pointerId === context.get("pointerId") || context.get("pointerId") == null && !event.captureLost),
+			target: "ready",
+			actions: ["cancelPointer"]
+		}
+	},
+	states: {
+		ready: { on: { "POINTER.START": {
+			guard: "canInteract",
+			target: "dragging",
+			actions: ["startPointer"]
+		} } },
+		dragging: {
+			effects: ["capturePointer"],
+			on: {
+				"POINTER.MOVE": { actions: ["movePointer"] },
+				"POINTER.END": {
+					guard: ({ event, context }) => event.type === "POINTER.END" && event.pointerId === context.get("pointerId"),
+					target: "ready",
+					actions: ["commitPointer", "syncInput"]
+				}
+			}
+		}
+	},
+	implementations: {
+		guards: { canInteract: (params) => !locked(params) },
+		effects: {
+			trackForm(params) {
+				return trackRateForm({
+					scope: params.scope,
+					rootId: rootId(params.scope),
+					inputId: inputId(params.scope),
+					current: () => formValue(params, effective(params)),
+					initial: () => formValue(params, effective(params, params.prop("defaultValue"))),
+					constraints: () => constraints(params),
+					onReset: () => params.send({ type: "FORM.RESET" }),
+					onDisabledChange: (value) => params.send({
+						type: "DISABLED.SET",
+						value
+					})
+				});
+			},
+			capturePointer({ scope, context, event }) {
+				const target = scope.getById(controlId(scope)), id = event.type === "POINTER.START" ? event.pointerId : context.get("pointerId");
+				if (target && id !== null) try {
+					target.setPointerCapture?.(id);
+				} catch {}
+				return () => {
+					if (target && id !== null && target.hasPointerCapture?.(id)) try {
+						target.releasePointerCapture(id);
+					} catch {}
+				};
+			}
+		},
+		actions: {
+			syncInput: sync,
+			setValue(params) {
+				if (params.event.type !== "VALUE.SET" || locked(params)) return;
+				params.context.set("value", normalizeRateValue(params.event.value, params.prop("count"), params.prop("allowHalf")));
+				clearPreview(params);
+			},
+			setPreview(params) {
+				if (params.event.type !== "PREVIEW.SET" || locked(params)) return;
+				params.context.set("previewValue", params.event.value === null ? null : normalizeRateValue(params.event.value, params.prop("count"), params.prop("allowHalf")));
+			},
+			startPointer(params) {
+				if (params.event.type !== "POINTER.START" || locked(params)) return;
+				params.context.set("pointerId", params.event.pointerId);
+				params.context.set("startX", params.event.x);
+				params.context.set("startY", params.event.y);
+				params.context.set("moved", false);
+				params.context.set("previewValue", params.event.value);
+			},
+			movePointer(params) {
+				if (params.event.type !== "POINTER.MOVE" || params.event.pointerId !== params.context.get("pointerId") || locked(params)) return;
+				const dx = Math.abs(params.event.x - params.context.get("startX")), dy = Math.abs(params.event.y - params.context.get("startY"));
+				if (params.event.touch && dy > dx && dy > 8) {
+					params.send({ type: "POINTER.CANCEL" });
+					return;
+				}
+				if (dx > 8 || dy > 8) params.context.set("moved", true);
+				params.context.set("previewValue", params.event.value);
+			},
+			commitPointer(params) {
+				if (params.event.type !== "POINTER.END" || params.event.pointerId !== params.context.get("pointerId") || locked(params)) {
+					clearPreview(params);
+					return;
+				}
+				const value = !params.context.get("moved") && params.prop("allowClear") && params.event.value === effective(params) ? 0 : params.event.value;
+				params.context.set("value", value);
+				params.context.set("validationError", false);
+				clearPreview(params);
+			},
+			cancelPointer: clearPreview,
+			setFocus({ context, event }) {
+				if (event.type === "FOCUS.SET") context.set("focused", event.value);
+			},
+			setDisabled(params) {
+				if (params.event.type !== "DISABLED.SET") return;
+				params.context.set("inheritedDisabled", params.event.value);
+				if (params.event.value) params.send({ type: "POINTER.CANCEL" });
+				sync(params);
+			},
+			resetForm({ context, prop }) {
+				context.set("value", prop("defaultValue"));
+				context.set("validationError", false);
+			},
+			markInvalid({ context, scope }) {
+				context.set("validationError", true);
+				scope.getById(controlId(scope))?.focus();
+			}
+		}
+	}
+});
+function connect(service, normalize) {
+	const id = rootId(service.scope), value = service.context.get("value"), committed = effective(service), preview = service.context.get("previewValue"), displayed = preview ?? committed;
+	const disabled = !!service.prop("disabled") || service.context.get("inheritedDisabled"), readOnly = !!service.prop("readOnly"), invalid = !!service.prop("invalid") || service.context.get("validationError");
+	const parts = (part) => ({
+		"data-scope": "rate",
+		"data-part": part
+	});
+	const items = Array.from({ length: service.prop("count") }, (_, index) => {
+		const fill = glyphFill(displayed - index);
+		return {
+			index: index + 1,
+			fill,
+			state: fill === 0 ? "empty" : fill === 1 ? "full" : "half"
+		};
+	});
+	const item = (props) => {
+		const result = items[props.index - 1];
+		if (!result) throw new RangeError("Rate item is outside count");
+		return result;
+	};
+	const direction = (target) => {
+		const dir = service.prop("dir");
+		return dir === "rtl" || dir === "ltr" ? dir : getComputedStyle(target).direction === "rtl" ? "rtl" : "ltr";
+	};
+	const valueAt = (event) => {
+		const target = event.currentTarget, point = getEventPoint(event, "client");
+		const rects = items.map((entry) => service.scope.getById(`${id}-item-${entry.index}`)?.getBoundingClientRect()).filter((rect) => !!rect);
+		return {
+			...point,
+			value: getRatePointValue(point.x, rects, service.prop("allowHalf"), direction(target))
+		};
+	};
+	const blocked = () => {
+		const input = service.scope.getById(inputId(service.scope));
+		return disabled || readOnly || isInputElement(input) && input.matches(":disabled");
+	};
+	const pointerEvent = (type, event) => {
+		if (blocked() || event.defaultPrevented || event.isPrimary === false || event.pointerType === "touch" && !service.prop("touchable")) return;
+		const result = valueAt(event);
+		if (result.value === null) return;
+		service.send({
+			type,
+			pointerId: event.pointerId ?? 0,
+			...result,
+			value: result.value,
+			touch: event.pointerType === "touch"
+		});
+	};
+	return {
+		value,
+		effectiveValue: committed,
+		previewValue: preview,
+		displayValue: displayed,
+		label: service.prop("label"),
+		description: service.prop("description") ?? "",
+		clearLabel: service.prop("clearLabel"),
+		character: service.prop("character"),
+		items,
+		setValue: (value) => service.send({
+			type: "VALUE.SET",
+			value
+		}),
+		setPreviewValue: (value) => service.send({
+			type: "PREVIEW.SET",
+			value
+		}),
+		getRootProps: () => normalize.element({
+			...parts("root"),
+			id,
+			dir: service.prop("dir"),
+			"data-size": service.prop("size"),
+			"data-value": value,
+			"data-effective-value": committed,
+			"data-preview-value": preview ?? void 0,
+			"data-disabled": dataAttr(disabled),
+			"data-readonly": dataAttr(readOnly),
+			"data-invalid": dataAttr(invalid)
+		}),
+		getLabelProps: () => normalize.element({
+			...parts("label"),
+			id: `${id}-label`
+		}),
+		getDescriptionProps: () => normalize.element({
+			...parts("description"),
+			id: `${id}-description`,
+			hidden: !service.prop("description")
+		}),
+		getControlProps: () => normalize.element({
+			...parts("control"),
+			id: controlId(service.scope),
+			role: "slider",
+			tabIndex: disabled ? -1 : 0,
+			"aria-labelledby": `${id}-label`,
+			"aria-describedby": service.prop("description") ? `${id}-description` : void 0,
+			"aria-valuemin": 0,
+			"aria-valuemax": service.prop("count"),
+			"aria-valuenow": committed,
+			"aria-valuetext": service.prop("valueTextTemplate").replace(/\{value\}/g, String(committed)).replace(/\{count\}/g, String(service.prop("count"))),
+			"aria-disabled": disabled || void 0,
+			"aria-readonly": readOnly || void 0,
+			"aria-required": service.prop("required") || void 0,
+			"aria-invalid": invalid || void 0,
+			"aria-orientation": "horizontal",
+			onFocus() {
+				service.send({
+					type: "FOCUS.SET",
+					value: true
+				});
+			},
+			onBlur() {
+				service.send({
+					type: "FOCUS.SET",
+					value: false
+				});
+				service.send({ type: "POINTER.CANCEL" });
+			},
+			onKeyDown(event) {
+				if (event.defaultPrevented || event.ctrlKey || event.altKey || event.metaKey) return;
+				if (event.key === "Escape") {
+					service.send({ type: "POINTER.CANCEL" });
+					return;
+				}
+				if (![
+					"ArrowLeft",
+					"ArrowRight",
+					"ArrowUp",
+					"ArrowDown",
+					"Home",
+					"End",
+					"PageUp",
+					"PageDown"
+				].includes(event.key)) return;
+				event.preventDefault();
+				if (blocked()) return;
+				const key = getEventKey(event, { dir: direction(event.currentTarget) }), step = service.prop("allowHalf") ? .5 : 1, page = Math.max(1, Math.floor(service.prop("count") / 5));
+				const next = key === "Home" ? 0 : key === "End" ? service.prop("count") : committed + (key === "PageUp" ? page : key === "PageDown" ? -page : key === "ArrowRight" || key === "ArrowUp" ? step : -step);
+				service.send({
+					type: "VALUE.SET",
+					value: next
+				});
+			},
+			onPointerDown(event) {
+				if (event.button !== 0 || blocked()) return;
+				event.currentTarget.focus();
+				pointerEvent("POINTER.START", event);
+			},
+			onPointerMove(event) {
+				if (service.context.get("pointerId") != null) pointerEvent("POINTER.MOVE", event);
+				else if (event.pointerType !== "touch" && !blocked()) {
+					const result = valueAt(event);
+					service.send({
+						type: "PREVIEW.SET",
+						value: result.value
+					});
+				}
+			},
+			onPointerUp(event) {
+				pointerEvent("POINTER.END", event);
+			},
+			onPointerCancel(event) {
+				service.send({
+					type: "POINTER.CANCEL",
+					pointerId: event.pointerId ?? 0
+				});
+			},
+			onLostPointerCapture(event) {
+				service.send({
+					type: "POINTER.CANCEL",
+					pointerId: event.pointerId ?? 0,
+					captureLost: true
+				});
+			},
+			onPointerLeave() {
+				if (service.context.get("pointerId") == null) service.send({
+					type: "PREVIEW.SET",
+					value: null
+				});
+			}
+		}),
+		getItemProps: (props) => {
+			const entry = item(props);
+			return normalize.element({
+				...parts("item"),
+				id: `${id}-item-${entry.index}`,
+				"data-index": entry.index,
+				"data-state": entry.state,
+				"aria-hidden": true
+			});
+		},
+		getEmptyIconProps: (props) => {
+			item(props);
+			return normalize.element({
+				...parts("empty-icon"),
+				"aria-hidden": true
+			});
+		},
+		getFilledIconProps: (props) => {
+			const entry = item(props);
+			return normalize.element({
+				...parts("filled-icon"),
+				"aria-hidden": true,
+				style: { "--qw-rate-fill": String(entry.fill) }
+			});
+		},
+		getItemIconState: (props, filled) => {
+			const entry = item(props);
+			return resolveIconState({
+				id: `${id}-${entry.index}-${filled ? "full" : "empty"}`,
+				name: filled ? service.prop("iconName") : service.prop("emptyIconName")
+			});
+		},
+		getInputProps: () => normalize.input({
+			...parts("input"),
+			id: inputId(service.scope),
+			type: "number",
+			name: service.prop("name"),
+			form: service.prop("form"),
+			value: formValue(service, committed),
+			min: 0,
+			max: service.prop("count"),
+			step: readOnly ? "any" : service.prop("allowHalf") ? .5 : 1,
+			required: !!service.prop("required"),
+			disabled: !!service.prop("disabled"),
+			tabIndex: -1,
+			"aria-hidden": true,
+			style: visuallyHiddenStyle,
+			onChange(event) {
+				if (!blocked()) service.send({
+					type: "VALUE.SET",
+					value: event.currentTarget.valueAsNumber
+				});
+				queueMicrotask(() => sync(service));
+			},
+			onInvalid(event) {
+				event.preventDefault();
+				service.send({ type: "INVALID" });
+			}
+		}),
+		getClearProps: () => normalize.button({
+			...parts("clear"),
+			type: "button",
+			hidden: !service.prop("allowClear") || readOnly || committed === 0,
+			disabled,
+			"aria-label": service.prop("clearLabel"),
+			onClick() {
+				service.send({
+					type: "VALUE.SET",
+					value: 0
+				});
+			}
+		}),
+		getContentProps: () => normalize.element(parts("content"))
+	};
+}
+//#endregion
+export { getRatePointValue as a, rateMachine as c, createRateProps as i, rateTouchCoverageForGlyphFill as l, RATE_SIZES as n, normalizeRateCount as o, connect as r, normalizeRateValue as s, RATE_PARTS as t };
+
+//# sourceMappingURL=rate-5XsU2QkY.js.map