@esposter/shared 4.3.3 → 4.5.0

package/dist/index.js

@@ -105,6 +105,36 @@ let ObjectMethod = /* @__PURE__ */ function(ObjectMethod) {
 	ObjectMethod["ValueOf"] = "valueOf";
 	return ObjectMethod;
 }({});
+// src/models/panzoom/PanzoomContain.ts
+let PanzoomContain = /* @__PURE__ */ function(PanzoomContain) {
+	PanzoomContain["Automatic"] = "automatic";
+	PanzoomContain["Inside"] = "inside";
+	PanzoomContain["Outside"] = "outside";
+	return PanzoomContain;
+}({});
+// src/models/panzoom/PanzoomDeltaMode.ts
+let PanzoomDeltaMode = /* @__PURE__ */ function(PanzoomDeltaMode) {
+	PanzoomDeltaMode[PanzoomDeltaMode["Pixel"] = 0] = "Pixel";
+	PanzoomDeltaMode[PanzoomDeltaMode["Line"] = 1] = "Line";
+	PanzoomDeltaMode[PanzoomDeltaMode["Page"] = 2] = "Page";
+	return PanzoomDeltaMode;
+}({});
+// src/models/panzoom/PanzoomEventName.ts
+let PanzoomEventName = /* @__PURE__ */ function(PanzoomEventName) {
+	PanzoomEventName["Change"] = "panzoomchange";
+	PanzoomEventName["End"] = "panzoomend";
+	PanzoomEventName["Pan"] = "panzoompan";
+	PanzoomEventName["Reset"] = "panzoomreset";
+	PanzoomEventName["Start"] = "panzoomstart";
+	PanzoomEventName["Zoom"] = "panzoomzoom";
+	return PanzoomEventName;
+}({});
+// src/models/panzoom/PanzoomZoomDirection.ts
+let PanzoomZoomDirection = /* @__PURE__ */ function(PanzoomZoomDirection) {
+	PanzoomZoomDirection["In"] = "in";
+	PanzoomZoomDirection["Out"] = "out";
+	return PanzoomZoomDirection;
+}({});
 // src/services/app/constants.ts
 const MAX_READ_LIMIT = 1e3;
 const SITE_NAME = "Esposter";
@@ -157,6 +187,10 @@ var ItemMetadata = class {
 	deletedAt = null;
 	updatedAt = /* @__PURE__ */ new Date();
 };
+// src/util/object/getPropertyNames.ts
+const getPropertyNames = () => new Proxy({}, { get: (_target, property) => property });
+// src/models/shared/ItemMetadataPropertyNames.ts
+const ItemMetadataPropertyNames = getPropertyNames();
 // src/util/reactivity/getRawData.ts
 const getRawData = (data) => {
 	const raw = data && data.__v_raw;
@@ -209,8 +243,12 @@ const withFinalizer = (callback, finalizer) => {
 };
 // src/services/error/withFinalizerAsync.ts
 const withFinalizerAsync = async (callback, finalizer) => {
-	const callbackResult = await getResultAsync(async () => callback());
-	if (finalizer) await getResultAsync(async () => finalizer()).match(noop, (error) => {
+	const callbackResult = await getResultAsync(async () => {
+		return await callback();
+	});
+	if (finalizer) await getResultAsync(async () => {
+		await finalizer();
+	}).match(noop, (error) => {
 		reportFinalizerError(callbackResult, error);
 	});
 	return callbackResult.match((value) => value, (error) => {
@@ -336,12 +374,23 @@ const wrapUpgradeDatabase = (database) => ({
 	...wrapDatabase(database),
 	createObjectStore: (name, options) => wrapObjectStore(database.createObjectStore(name, options))
 });
+// src/util/function/getSynchronizedFunction.ts
+const pendingPromises = /* @__PURE__ */ new Set();
+const getSynchronizedFunction = (asyncFunction) => (...args) => {
+	const promise = withFinalizerAsync(() => asyncFunction(...args), () => {
+		pendingPromises.delete(promise);
+	});
+	pendingPromises.add(promise);
+};
+const waitForSynchronizedFunctions = async () => {
+	await Promise.allSettled(pendingPromises);
+};
 // src/services/indexedDb/wrapUpgradeTransaction.ts
 const wrapUpgradeTransaction = (transaction) => {
 	const done = getTransactionDone(transaction);
-	getResultAsync(() => done).match(noop, (error) => {
+	getSynchronizedFunction(() => getResultAsync(() => done).match(noop, (error) => {
 		if (transaction.error) console.error(error);
-	});
+	}))();
 	return {
 		get done() {
 			return done;
@@ -610,6 +659,10 @@ const CUSTOM_EMOJI_ID_ATTRIBUTE = "data-custom-emoji-id";
 const CUSTOM_EMOJI_NAME_ATTRIBUTE = "data-custom-emoji-name";
 const SPOILER_ATTRIBUTE = "data-spoiler";
 const SPOILER_SELECTOR = `span[${SPOILER_ATTRIBUTE}]`;
+// src/services/message/emoji/checkIsOnlyReactor.ts
+const checkIsOnlyReactor = (userIds, userId) => userIds.length === 1 && userIds[0] === userId;
+// src/services/message/emoji/getUpdatedUserIds.ts
+const getUpdatedUserIds = (userIds, newUserId) => userIds.includes(newUserId) ? userIds.filter((id) => id !== newUserId) : [...userIds, newUserId];
 // src/services/message/getMentions.ts
 const getMentions = (message) => parse(message).querySelectorAll(MENTION_SELECTOR);
 // src/services/mime/constants.ts
@@ -701,6 +754,643 @@ const contentType = (value) => {
 };
 // src/services/mime/extension.ts
 const extension = (type) => getMimeTypeEntryMap().get(getMediaType(type).toLowerCase())?.extensions?.[0] ?? false;
+// src/services/panzoom/constants.ts
+const PANZOOM_DEFAULT_MAX_SCALE = 4;
+const PANZOOM_DEFAULT_MIN_SCALE = .125;
+const PANZOOM_DEFAULT_START_SCALE = 1;
+const PANZOOM_DEFAULT_STEP = .3;
+const PANZOOM_WHEEL_STEP_DIVISOR = 3;
+const PANZOOM_WHEEL_NOTCH_PIXELS = 100;
+const PANZOOM_PIXELS_PER_LINE = 16;
+const PANZOOM_PRIMARY_BUTTON = 0;
+const PANZOOM_DEFAULT_CURSOR = "move";
+const PANZOOM_DEFAULT_DURATION = 200;
+const PANZOOM_DEFAULT_EASING = "ease-in-out";
+const PANZOOM_DEFAULT_EXCLUDE_CLASS = "panzoom-exclude";
+const PANZOOM_DEFAULT_OVERFLOW = "hidden";
+const PANZOOM_DEFAULT_PAN_THRESHOLD = 0;
+const PANZOOM_DEFAULT_START_PAN = 0;
+const PANZOOM_DEFAULT_TOUCH_ACTION = "none";
+const PANZOOM_TRANSFORM_ORIGIN = "50% 50%";
+const PANZOOM_SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const PANZOOM_DEFAULT_OPTIONS = Object.freeze({
+	animate: false,
+	canvas: false,
+	cursor: PANZOOM_DEFAULT_CURSOR,
+	disablePan: false,
+	disableXAxis: false,
+	disableYAxis: false,
+	disableZoom: false,
+	duration: 200,
+	easing: PANZOOM_DEFAULT_EASING,
+	excludeClass: PANZOOM_DEFAULT_EXCLUDE_CLASS,
+	maxScale: 4,
+	minScale: PANZOOM_DEFAULT_MIN_SCALE,
+	overflow: PANZOOM_DEFAULT_OVERFLOW,
+	panOnlyWhenZoomed: false,
+	panThreshold: 0,
+	pinchAndPan: false,
+	relative: false,
+	startScale: 1,
+	startX: 0,
+	startY: 0,
+	step: PANZOOM_DEFAULT_STEP,
+	touchAction: PANZOOM_DEFAULT_TOUCH_ACTION
+});
+// src/services/panzoom/getPanzoomTarget.ts
+const getPanzoomTarget = ({ element, options, parent }) => options.canvas ? parent : element;
+// src/services/panzoom/restorePanzoomStyles.ts
+const restorePanzoomStyles = ({ styles }, properties) => {
+	for (const [element, values] of styles) {
+		const restoredProperties = properties ?? [...values.keys()];
+		for (const property of restoredProperties.filter((name) => values.has(name))) {
+			const previousValue = values.get(property) ?? "";
+			if (previousValue) element.style.setProperty(property, previousValue);
+			else element.style.removeProperty(property);
+			values.delete(property);
+		}
+	}
+};
+// src/util/map/getOrCreate.ts
+const getOrCreate = (map, key, create) => {
+	if (map.has(key)) return map.get(key);
+	const value = create();
+	map.set(key, value);
+	return value;
+};
+// src/services/panzoom/writePanzoomStyle.ts
+const writePanzoomStyle = ({ isDestroyed, styles }, element, property, value) => {
+	if (isDestroyed) return;
+	const values = getOrCreate(styles, element, () => /* @__PURE__ */ new Map());
+	if (!values.has(property)) values.set(property, element.style.getPropertyValue(property));
+	element.style.setProperty(property, value);
+};
+// src/services/panzoom/applyPanzoomStyles.ts
+const applyPanzoomStyles = (context) => {
+	const { element, options, parent } = context;
+	const touchAction = options.touchAction ?? "none";
+	writePanzoomStyle(context, parent, "overflow", options.overflow ?? "hidden");
+	writePanzoomStyle(context, parent, "touch-action", touchAction);
+	writePanzoomStyle(context, element, "touch-action", touchAction);
+	if (options.disablePan) restorePanzoomStyles(context, ["cursor"]);
+	else writePanzoomStyle(context, getPanzoomTarget(context), "cursor", options.cursor ?? "move");
+};
+// src/services/panzoom/dispatchPanzoomEvent.ts
+const dispatchPanzoomEvent = ({ element, isDestroyed }, name, detail, { silent }) => {
+	if (silent || isDestroyed) return;
+	element.dispatchEvent(new CustomEvent(name, { detail }));
+};
+// src/services/panzoom/getPanzoomDrag.ts
+const getPanzoomDrag = (state, point) => ({
+	anchorPan: {
+		x: state.x,
+		y: state.y
+	},
+	anchorPoint: point,
+	downPoint: point,
+	isDragging: false
+});
+// src/services/panzoom/getPanzoomEventDetail.ts
+const getPanzoomEventDetail = ({ element, state }, originalEvent) => ({
+	isSVG: element.namespaceURI === "http://www.w3.org/2000/svg" && element.localName !== "svg",
+	originalEvent,
+	scale: state.scale,
+	x: state.x,
+	y: state.y
+});
+// src/util/array/takeOne.ts
+const takeOne = (values, index = 0) => {
+	return values[index];
+};
+// src/services/panzoom/endPanzoomGesture.ts
+const endPanzoomGesture = (context, event) => {
+	const { options, pointers, state } = context;
+	if (!pointers.has(event.pointerId)) return;
+	pointers.delete(event.pointerId);
+	if (context.drag?.isDragging && event.type === "pointerup" && event.button === 0) context.isClickSuppressed = true;
+	context.drag = void 0;
+	context.pinch = void 0;
+	const remainingPoints = [...pointers.values()];
+	if (remainingPoints.length === 1) context.drag = getPanzoomDrag(state, takeOne(remainingPoints, 0));
+	if (pointers.size > 0) return;
+	restorePanzoomStyles(context, ["user-select"]);
+	applyPanzoomStyles(context);
+	dispatchPanzoomEvent(context, "panzoomend", getPanzoomEventDetail(context, event), options);
+};
+// src/services/panzoom/checkIsContainableLength.ts
+const checkIsContainableLength = (length) => Number.isFinite(length) && length > 0;
+// src/services/panzoom/constrainPanzoomAxis.ts
+const constrainPanzoomAxis = (value, axis, scale, contain) => {
+	if (!contain || !checkIsContainableLength(axis.parentLength)) return value;
+	const halfLength = axis.length / 2;
+	const leadingPan = (axis.parentStart - axis.center) / scale + halfLength;
+	const trailingPan = (axis.parentStart + axis.parentLength - axis.center) / scale - halfLength;
+	const isFitting = axis.length * scale <= axis.parentLength;
+	const isInside = contain === "inside" || contain === "automatic" && isFitting;
+	return Math.max(Math.min(value, isInside ? trailingPan : leadingPan), isInside ? leadingPan : trailingPan);
+};
+// src/services/panzoom/getPanzoomCoverScale.ts
+const getPanzoomCoverScale = (measure) => Math.max(measure.parent.width / measure.size.width, measure.parent.height / measure.size.height);
+// src/services/panzoom/getPanzoomFitScale.ts
+const getPanzoomFitScale = ({ parent, size }) => {
+	const fit = Math.min(checkIsContainableLength(parent.width) ? parent.width / size.width : Number.POSITIVE_INFINITY, checkIsContainableLength(parent.height) ? parent.height / size.height : Number.POSITIVE_INFINITY);
+	return Number.isFinite(fit) ? fit : 1;
+};
+// src/services/panzoom/constrainPanzoomScale.ts
+const constrainPanzoomScale = (scale, measure, { contain, maxScale = 4, minScale = PANZOOM_DEFAULT_MIN_SCALE }) => {
+	const isParentContainable = checkIsContainableLength(measure.parent.width) || checkIsContainableLength(measure.parent.height);
+	if (!contain || !isParentContainable || measure.size.width <= 1 || measure.size.height <= 1) return Math.min(Math.max(scale, minScale), maxScale);
+	if (contain === "inside") {
+		const cap = Math.max(minScale, Math.min(maxScale, getPanzoomFitScale(measure)));
+		return Math.min(Math.max(scale, minScale), cap);
+	}
+	const floor = contain === "outside" ? getPanzoomCoverScale(measure) : getPanzoomFitScale(measure);
+	return Math.min(Math.max(scale, Math.max(minScale, floor)), maxScale);
+};
+// src/services/panzoom/getPanzoomStartScale.ts
+const getPanzoomStartScale = (measure, options) => {
+	const { startScale = 1 } = options;
+	const scale = startScale === "fit" ? getPanzoomFitScale(measure) : startScale;
+	return constrainPanzoomScale(scale, measure, options);
+};
+// src/services/panzoom/constrainPanzoomPan.ts
+const constrainPanzoomPan = (current, requested, toScale, measure, options) => {
+	const { contain, disablePan, disableXAxis, disableYAxis, force, panOnlyWhenZoomed, relative, roundPixels } = options;
+	const isPanDisabled = disablePan || panOnlyWhenZoomed && current.scale === getPanzoomStartScale(measure, options);
+	if (!force && isPanDisabled) return {
+		x: current.x,
+		y: current.y
+	};
+	const offsetX = relative ? current.x : 0;
+	const offsetY = relative ? current.y : 0;
+	const unconstrainedX = disableXAxis ? current.x : offsetX + requested.x;
+	const unconstrainedY = disableYAxis ? current.y : offsetY + requested.y;
+	const roundedX = roundPixels ? Math.round(unconstrainedX) : unconstrainedX;
+	const roundedY = roundPixels ? Math.round(unconstrainedY) : unconstrainedY;
+	const axisX = {
+		center: measure.center.x,
+		length: measure.size.width,
+		parentLength: measure.parent.width,
+		parentStart: measure.parent.left
+	};
+	const axisY = {
+		center: measure.center.y,
+		length: measure.size.height,
+		parentLength: measure.parent.height,
+		parentStart: measure.parent.top
+	};
+	return {
+		x: constrainPanzoomAxis(roundedX, axisX, toScale, contain),
+		y: constrainPanzoomAxis(roundedY, axisY, toScale, contain)
+	};
+};
+// src/services/panzoom/dispatchPanzoomChange.ts
+const dispatchPanzoomChange = (context, name, detail, options) => {
+	dispatchPanzoomEvent(context, name, detail, options);
+	dispatchPanzoomEvent(context, "panzoomchange", detail, options);
+};
+// src/services/panzoom/getPanzoomCallOptions.ts
+const getPanzoomCallOptions = ({ options }, callOptions) => ({
+	...options,
+	...callOptions
+});
+// src/services/panzoom/getPanzoomMeasure.ts
+const getInset = (border, padding) => Number.parseFloat(border) + Number.parseFloat(padding);
+const getPanzoomMeasure = (element, parent, state) => {
+	const rectangle = element.getBoundingClientRect();
+	const parentRectangle = parent.getBoundingClientRect();
+	const parentStyle = getComputedStyle(parent);
+	const insetLeft = getInset(parentStyle.borderLeftWidth, parentStyle.paddingLeft);
+	const insetTop = getInset(parentStyle.borderTopWidth, parentStyle.paddingTop);
+	const insetRight = getInset(parentStyle.borderRightWidth, parentStyle.paddingRight);
+	const insetBottom = getInset(parentStyle.borderBottomWidth, parentStyle.paddingBottom);
+	return {
+		center: {
+			x: rectangle.left + rectangle.width / 2 - state.scale * state.x,
+			y: rectangle.top + rectangle.height / 2 - state.scale * state.y
+		},
+		parent: {
+			height: parentRectangle.height - insetTop - insetBottom,
+			left: parentRectangle.left + insetLeft,
+			top: parentRectangle.top + insetTop,
+			width: parentRectangle.width - insetLeft - insetRight
+		},
+		size: {
+			height: rectangle.height / state.scale,
+			width: rectangle.width / state.scale
+		}
+	};
+};
+// src/services/panzoom/writePanzoomState.ts
+const writePanzoomState = (context, state, { animate, duration = 200, easing = PANZOOM_DEFAULT_EASING, setTransform }) => {
+	if (context.isDestroyed) return;
+	const { element } = context;
+	context.state = state;
+	writePanzoomStyle(context, element, "transition", animate ? `transform ${duration}ms ${easing}` : "none");
+	if (setTransform) setTransform(element, getPanzoomEventDetail(context));
+	else writePanzoomStyle(context, element, "transform", `scale(${state.scale}) translate(${state.x}px, ${state.y}px)`);
+	writePanzoomStyle(context, element, "--panzoom-scale", `${state.scale}`);
+};
+// src/services/panzoom/panPanzoom.ts
+const panPanzoom = (context, point, callOptions, originalEvent) => {
+	const options = getPanzoomCallOptions(context, callOptions);
+	const { element, parent, state } = context;
+	const measure = getPanzoomMeasure(element, parent, state);
+	const pan = constrainPanzoomPan(state, point, state.scale, measure, options);
+	if (pan.x === state.x && pan.y === state.y) return getPanzoomEventDetail(context, originalEvent);
+	writePanzoomState(context, {
+		scale: state.scale,
+		x: pan.x,
+		y: pan.y
+	}, options);
+	const detail = getPanzoomEventDetail(context, originalEvent);
+	dispatchPanzoomChange(context, "panzoompan", detail, options);
+	return detail;
+};
+// src/services/panzoom/movePanzoomDrag.ts
+const movePanzoomDrag = (context, drag, point, event) => {
+	const { options, state } = context;
+	if (!drag.isDragging) {
+		if (Math.hypot(point.x - drag.downPoint.x, point.y - drag.downPoint.y) <= (options.panThreshold ?? 0)) return;
+		drag.isDragging = true;
+	}
+	panPanzoom(context, {
+		x: drag.anchorPan.x + (point.x - drag.anchorPoint.x) / state.scale,
+		y: drag.anchorPan.y + (point.y - drag.anchorPoint.y) / state.scale
+	}, {
+		animate: false,
+		relative: false
+	}, event);
+};
+// src/services/panzoom/getPanzoomPinchFrame.ts
+const getPanzoomPinchFrame = (pointers) => {
+	const points = [...pointers.values()];
+	const first = takeOne(points, 0);
+	const second = takeOne(points, 1);
+	return {
+		distance: Math.hypot(first.x - second.x, first.y - second.y),
+		midpoint: {
+			x: (first.x + second.x) / 2,
+			y: (first.y + second.y) / 2
+		}
+	};
+};
+// src/services/panzoom/getPanzoomPinchScale.ts
+const getPanzoomPinchScale = (startScale, startDistance, distance) => startDistance > 0 ? startScale * distance / startDistance : startScale;
+// src/services/panzoom/checkIsZoomRefused.ts
+const checkIsZoomRefused = ({ disableZoom, force }) => Boolean(disableZoom) && !force;
+// src/services/panzoom/getPanzoomFocalPan.ts
+const getPanzoomFocalPan = (current, toScale, point, measure) => {
+	const offsetX = point.x - measure.center.x;
+	const offsetY = point.y - measure.center.y;
+	return {
+		x: offsetX / toScale - offsetX / current.scale + current.x,
+		y: offsetY / toScale - offsetY / current.scale + current.y
+	};
+};
+// src/services/panzoom/getPanzoomZoomedState.ts
+const getPanzoomZoomedState = (state, measure, options, scale, focal) => {
+	const toScale = constrainPanzoomScale(scale, measure, options);
+	const requested = focal ? getPanzoomFocalPan(state, toScale, focal, measure) : {
+		x: state.x,
+		y: state.y
+	};
+	const pan = constrainPanzoomPan(state, requested, toScale, measure, {
+		...options,
+		force: true,
+		relative: false
+	});
+	return {
+		scale: toScale,
+		x: pan.x,
+		y: pan.y
+	};
+};
+// src/services/panzoom/reanchorPanzoomDrag.ts
+const reanchorPanzoomDrag = ({ drag, pointers, state }) => {
+	if (!drag) return;
+	drag.anchorPoint = takeOne([...pointers.values()], 0);
+	drag.anchorPan = {
+		x: state.x,
+		y: state.y
+	};
+};
+// src/services/panzoom/zoomPanzoom.ts
+const zoomPanzoom = (context, scale, callOptions, originalEvent) => {
+	const options = getPanzoomCallOptions(context, callOptions);
+	if (checkIsZoomRefused(options)) return getPanzoomEventDetail(context, originalEvent);
+	const { element, parent, state } = context;
+	const measure = getPanzoomMeasure(element, parent, state);
+	writePanzoomState(context, getPanzoomZoomedState(state, measure, options, scale, options.focal), options);
+	const detail = getPanzoomEventDetail(context, originalEvent);
+	dispatchPanzoomChange(context, "panzoomzoom", detail, options);
+	reanchorPanzoomDrag(context);
+	return detail;
+};
+// src/services/panzoom/movePanzoomPinch.ts
+const movePanzoomPinch = (context, pinch, event) => {
+	const frame = getPanzoomPinchFrame(context.pointers);
+	const scale = getPanzoomPinchScale(pinch.startScale, pinch.startDistance, frame.distance);
+	zoomPanzoom(context, scale, {
+		animate: false,
+		focal: pinch.midpoint
+	}, event);
+	if (context.options.pinchAndPan) {
+		const { state } = context;
+		panPanzoom(context, {
+			x: state.x + (frame.midpoint.x - pinch.midpoint.x) / state.scale,
+			y: state.y + (frame.midpoint.y - pinch.midpoint.y) / state.scale
+		}, {
+			animate: false,
+			relative: false
+		}, event);
+	}
+	pinch.midpoint = frame.midpoint;
+};
+// src/services/panzoom/movePanzoomGesture.ts
+const movePanzoomGesture = (context, event) => {
+	const { drag, pinch, pointers } = context;
+	if (!pointers.has(event.pointerId)) return;
+	const point = {
+		x: event.clientX,
+		y: event.clientY
+	};
+	pointers.set(event.pointerId, point);
+	if (pinch) movePanzoomPinch(context, pinch, event);
+	else if (drag && event.pointerId === takeOne([...pointers.keys()], 0)) movePanzoomDrag(context, drag, point, event);
+};
+// src/services/panzoom/checkIsPanzoomExcluded.ts
+const checkIsPanzoomExcluded = (target, { exclude = [], excludeClass = PANZOOM_DEFAULT_EXCLUDE_CLASS }) => exclude.some((excluded) => excluded.contains(target)) || target.closest(`.${CSS.escape(excludeClass)}`) !== null;
+// src/services/panzoom/startPanzoomGesture.ts
+const startPanzoomGesture = (context, event) => {
+	const { element, options, pointers, state } = context;
+	context.isClickSuppressed = false;
+	if (pointers.size >= 2) return;
+	if (checkIsPanzoomExcluded(event.target, options)) return;
+	const { filter } = options;
+	if (filter && !filter(event)) return;
+	const point = {
+		x: event.clientX,
+		y: event.clientY
+	};
+	pointers.set(event.pointerId, point);
+	getPanzoomTarget(context).setPointerCapture(event.pointerId);
+	if (options.handleStartEvent) options.handleStartEvent(event);
+	else {
+		event.preventDefault();
+		event.stopPropagation();
+	}
+	if (pointers.size === 1) context.drag = getPanzoomDrag(state, point);
+	if (pointers.size === 2) {
+		const frame = getPanzoomPinchFrame(pointers);
+		if (frame.distance > 0) {
+			context.drag = void 0;
+			context.pinch = {
+				midpoint: frame.midpoint,
+				startDistance: frame.distance,
+				startScale: state.scale
+			};
+		}
+	}
+	writePanzoomStyle(context, element, "user-select", "none");
+	if (!options.disablePan && options.panCursor) writePanzoomStyle(context, getPanzoomTarget(context), "cursor", options.panCursor);
+	dispatchPanzoomEvent(context, "panzoomstart", getPanzoomEventDetail(context, event), options);
+};
+// src/services/panzoom/bindPanzoom.ts
+const bindPanzoom = (context, signal) => {
+	const target = getPanzoomTarget(context);
+	const { ownerDocument } = context.element;
+	target.addEventListener("pointerdown", (event) => {
+		startPanzoomGesture(context, event);
+	}, { signal });
+	target.addEventListener("click", (event) => {
+		if (!context.isClickSuppressed) return;
+		context.isClickSuppressed = false;
+		event.preventDefault();
+		event.stopPropagation();
+	}, {
+		capture: true,
+		signal
+	});
+	ownerDocument.addEventListener("pointermove", (event) => {
+		movePanzoomGesture(context, event);
+	}, {
+		passive: true,
+		signal
+	});
+	ownerDocument.addEventListener("pointerup", (event) => {
+		endPanzoomGesture(context, event);
+	}, {
+		passive: true,
+		signal
+	});
+	ownerDocument.addEventListener("pointercancel", (event) => {
+		endPanzoomGesture(context, event);
+	}, {
+		passive: true,
+		signal
+	});
+};
+// src/services/panzoom/checkIsPanzoomElement.ts
+const checkIsPanzoomElement = (value) => "style" in value;
+// src/services/panzoom/getPanzoomCentredPan.ts
+const getPanzoomCentredPan = (scale, measure) => {
+	const parentCentreX = measure.parent.left + measure.parent.width / 2;
+	const parentCentreY = measure.parent.top + measure.parent.height / 2;
+	return {
+		x: (parentCentreX - measure.center.x) / scale,
+		y: (parentCentreY - measure.center.y) / scale
+	};
+};
+// src/services/panzoom/fitPanzoom.ts
+const fitPanzoom = (context, callOptions) => {
+	const options = getPanzoomCallOptions(context, {
+		force: true,
+		...callOptions
+	});
+	const { element, parent, state } = context;
+	const measure = getPanzoomMeasure(element, parent, state);
+	const scale = constrainPanzoomScale(getPanzoomFitScale(measure), measure, options);
+	const pan = constrainPanzoomPan(state, getPanzoomCentredPan(scale, measure), scale, measure, {
+		...options,
+		relative: false
+	});
+	writePanzoomState(context, {
+		scale,
+		x: pan.x,
+		y: pan.y
+	}, options);
+	const detail = getPanzoomEventDetail(context);
+	dispatchPanzoomChange(context, "panzoomzoom", detail, options);
+	reanchorPanzoomDrag(context);
+	return detail;
+};
+// src/services/panzoom/getPanzoomParent.ts
+const getPanzoomParent = (element) => {
+	const { parentNode } = element;
+	if (parentNode?.nodeType === Node.DOCUMENT_FRAGMENT_NODE && "host" in parentNode) {
+		const { host } = parentNode;
+		return checkIsPanzoomElement(host) ? host : null;
+	}
+	return element.parentElement;
+};
+// src/services/panzoom/getPanzoomStartState.ts
+const getPanzoomStartState = (state, measure, options) => {
+	const { startX = 0, startY = 0 } = options;
+	const scale = getPanzoomStartScale(measure, options);
+	const pan = constrainPanzoomPan(state, {
+		x: startX,
+		y: startY
+	}, scale, measure, {
+		...options,
+		force: true,
+		relative: false
+	});
+	return {
+		scale,
+		x: pan.x,
+		y: pan.y
+	};
+};
+// src/services/panzoom/getPanzoomWheelScale.ts
+const getPanzoomWheelScale = (scale, { deltaMode, deltaX, deltaY }, step = PANZOOM_DEFAULT_STEP) => {
+	const delta = deltaY === 0 ? deltaX : deltaY;
+	const pixelDelta = deltaMode === 0 ? delta : delta * 16;
+	const notchFraction = Math.min(Math.abs(pixelDelta) / 100, 1);
+	const direction = -Math.sign(pixelDelta);
+	return scale * Math.exp(direction * step * notchFraction / 3);
+};
+// src/services/panzoom/resetPanzoom.ts
+const resetPanzoom = (context, callOptions) => {
+	const options = getPanzoomCallOptions(context, {
+		animate: true,
+		force: true,
+		...callOptions
+	});
+	const { element, parent, state } = context;
+	const measure = getPanzoomMeasure(element, parent, state);
+	writePanzoomState(context, getPanzoomStartState(state, measure, options), options);
+	const detail = getPanzoomEventDetail(context);
+	dispatchPanzoomChange(context, "panzoomreset", detail, options);
+	reanchorPanzoomDrag(context);
+	return detail;
+};
+// src/services/panzoom/getPanzoomStepScale.ts
+const getPanzoomStepScale = (scale, direction, step = PANZOOM_DEFAULT_STEP) => {
+	const exponent = direction === "in" ? step : -step;
+	return scale * Math.exp(exponent);
+};
+// src/services/panzoom/zoomPanzoomStep.ts
+const zoomPanzoomStep = (context, direction, zoomOptions) => zoomPanzoom(context, getPanzoomStepScale(context.state.scale, direction, context.options.step), {
+	animate: true,
+	...zoomOptions
+});
+// src/services/panzoom/createPanzoom.ts
+const createPanzoom = (element, options = {}) => {
+	if (element.nodeType !== Node.ELEMENT_NODE) throw new InvalidOperationError("Create", createPanzoom.name, "the element is not an Element");
+	if (!element.isConnected) throw new InvalidOperationError("Create", createPanzoom.name, "the element is not attached to a document");
+	const parent = getPanzoomParent(element);
+	if (!parent) throw new InvalidOperationError("Create", createPanzoom.name, "the element has no parent to contain it");
+	const context = {
+		element,
+		isClickSuppressed: false,
+		isDestroyed: false,
+		options: {
+			...PANZOOM_DEFAULT_OPTIONS,
+			...options
+		},
+		parent,
+		pointers: /* @__PURE__ */ new Map(),
+		state: {
+			scale: 1,
+			x: 0,
+			y: 0
+		},
+		styles: /* @__PURE__ */ new Map()
+	};
+	writePanzoomState(context, context.state, { animate: false });
+	const start = getPanzoomStartState(context.state, getPanzoomMeasure(element, parent, context.state), context.options);
+	writePanzoomState(context, start, { animate: false });
+	writePanzoomStyle(context, element, "transform-origin", PANZOOM_TRANSFORM_ORIGIN);
+	applyPanzoomStyles(context);
+	let controller;
+	const bind = () => {
+		if (controller || context.isDestroyed) return;
+		controller = new AbortController();
+		bindPanzoom(context, controller.signal);
+	};
+	const destroy = () => {
+		context.isDestroyed = true;
+		controller?.abort();
+		controller = void 0;
+		context.drag = void 0;
+		context.pinch = void 0;
+		context.pointers.clear();
+		restorePanzoomStyles(context);
+	};
+	const panzoom = {
+		bind,
+		destroy,
+		fit: (fitOptions = {}) => fitPanzoom(context, fitOptions),
+		getOptions: () => ({ ...context.options }),
+		getPan: () => ({
+			x: context.state.x,
+			y: context.state.y
+		}),
+		getScale: () => context.state.scale,
+		pan: (x, y, panOptions = {}) => panPanzoom(context, {
+			x,
+			y
+		}, panOptions),
+		reset: (resetOptions = {}) => resetPanzoom(context, resetOptions),
+		resetStyle: () => {
+			restorePanzoomStyles(context, [
+				"cursor",
+				"overflow",
+				"touch-action",
+				"user-select"
+			]);
+		},
+		setOptions: (newOptions = {}) => {
+			const previousTarget = getPanzoomTarget(context);
+			context.options = {
+				...context.options,
+				...newOptions
+			};
+			if (controller && getPanzoomTarget(context) !== previousTarget) {
+				controller.abort();
+				controller = void 0;
+				restorePanzoomStyles(context, ["cursor"]);
+				bind();
+			}
+			applyPanzoomStyles(context);
+		},
+		zoom: (scale, zoomOptions = {}) => zoomPanzoom(context, scale, zoomOptions),
+		zoomIn: (zoomOptions = {}) => zoomPanzoomStep(context, "in", zoomOptions),
+		zoomOut: (zoomOptions = {}) => zoomPanzoomStep(context, "out", zoomOptions),
+		zoomToPoint: (scale, point, zoomOptions, originalEvent) => zoomPanzoom(context, scale, {
+			...zoomOptions,
+			focal: {
+				x: point.clientX,
+				y: point.clientY
+			}
+		}, originalEvent),
+		zoomWithWheel: (event, zoomOptions = {}) => {
+			const callOptions = getPanzoomCallOptions(context, zoomOptions);
+			if (!checkIsZoomRefused(callOptions)) event.preventDefault();
+			return zoomPanzoom(context, getPanzoomWheelScale(context.state.scale, event, context.options.step), {
+				...zoomOptions,
+				animate: false,
+				focal: {
+					x: event.clientX,
+					y: event.clientY
+				}
+			}, event);
+		}
+	};
+	if (!context.options.noBind) bind();
+	return panzoom;
+};
 // src/services/prettier/css.ts
 const css = String.raw;
 // src/services/prettier/html.ts
@@ -1177,10 +1867,6 @@ const checkIsUnsafeUrlCharacter = (character) => {
 	const codePoint = character.codePointAt(0) ?? 0;
 	return checkIsWhitespaceCharacter(character) || codePoint < FIRST_PRINTABLE_CODE_POINT || codePoint >= DELETE_CODE_POINT && codePoint <= LAST_C1_CONTROL_CODE_POINT || character === GRAVE_ACCENT;
 };
-// src/util/array/takeOne.ts
-const takeOne = (values, index = 0) => {
-	return values[index];
-};
 // src/services/sanitizeHtml/checkIsAllowedUrl.ts
 const PATH_DELIMITER_REGEX = /[/?#]/u;
 const NON_SCHEME_CHARACTERS_REGEX = /[^a-z\d+.-]/giu;
@@ -1193,6 +1879,17 @@ const checkIsAllowedUrl = (url, allowedSchemes) => {
 	const scheme = beforePath.slice(0, separatorIndex).replaceAll(NON_SCHEME_CHARACTERS_REGEX, "").toLowerCase();
 	return allowedSchemes.includes(scheme);
 };
+// src/services/sanitizeHtml/getTagPolicy.ts
+const getTagPolicy = (tagPolicies, tagName) => Object.hasOwn(tagPolicies, tagName) ? tagPolicies[tagName] : void 0;
+// src/services/sanitizeHtml/checkIsSourceAllowed.ts
+const checkIsSourceAllowed = (element, allowedSources) => {
+	const sourceRules = getTagPolicy(allowedSources, element.tagName);
+	if (!sourceRules) return true;
+	return Object.entries(sourceRules).every(([name, patterns]) => {
+		const attribute = element.attrs.find((attr) => attr.name === name);
+		return attribute !== void 0 && patterns.some((pattern) => pattern.test(attribute.value));
+	});
+};
 // src/services/sanitizeHtml/constants.ts
 const HTML_NAMESPACE = html$1.NS.HTML;
 const DEFAULT_ALLOWED_TAGS = [
@@ -1327,7 +2024,7 @@ const MAX_NESTING_DEPTH = 256;
 const SRCSET_DESCRIPTOR_REGEX = /^(?:\d+w|\d*\.?\d+x|\d+h)$/u;
 const ESCAPED_TEXT_CHARACTERS_REGEX = /[&<>]/gu;
 const ESCAPED_ATTRIBUTE_CHARACTERS_REGEX = /[&"<>]/gu;
-const SANITIZER_ADVISORY_WATCH_SINCE = "2026-10-21";
+const SANITIZER_ADVISORY_WATCH_SINCE = "2026-10-23";
 // src/services/sanitizeHtml/getChildNodes.ts
 const getChildNodes = (element) => "content" in element ? element.content.childNodes : element.childNodes;
 // src/services/sanitizeHtml/collectText.ts
@@ -1420,7 +2117,6 @@ const filterStyle = (value, rules) => {
 	return Array.from(declarations, ([property, { important, propertyValue }]) => `${property}${PROPERTY_SEPARATOR}${propertyValue}${important ? IMPORTANT_SUFFIX : ""}`).join(DECLARATION_SEPARATOR);
 };
 // src/services/sanitizeHtml/filterAttributes.ts
-const getTagPolicy = (tagPolicies, tagName) => Object.hasOwn(tagPolicies, tagName) ? tagPolicies[tagName] : void 0;
 const checkIsMetaRefresh = (tagName, attributes) => tagName === "meta" && attributes["http-equiv"]?.trim().toLowerCase() === "refresh";
 const filterAttributes = (element, policy) => {
 	const { tagName } = element;
@@ -1451,7 +2147,7 @@ const renderNode = (node, policy, depth) => {
 	if (!("tagName" in node) || depth > 256) return "";
 	const element = node;
 	const children = getChildNodes(element).map((child) => renderNode(child, policy, depth + 1)).join("");
-	if (!(element.namespaceURI === HTML_NAMESPACE && !NON_TEXT_TAGS.includes(element.tagName) && policy.allowedTags.includes(element.tagName))) return NON_TEXT_TAGS.includes(element.tagName) ? "" : children;
+	if (!(element.namespaceURI === HTML_NAMESPACE && !NON_TEXT_TAGS.includes(element.tagName) && policy.allowedTags.includes(element.tagName) && checkIsSourceAllowed(element, policy.allowedSources))) return NON_TEXT_TAGS.includes(element.tagName) ? "" : children;
 	const attributes = Object.entries(filterAttributes(element, policy)).map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
 	const opening = `<${element.tagName}${attributes}>`;
 	return VOID_TAGS.includes(element.tagName) ? opening : `${opening}${children}</${element.tagName}>`;
@@ -1502,6 +2198,7 @@ const sanitizeHtml = (html, options) => filterHtml(html, {
 	},
 	allowedClasses: options?.allowedClasses ?? {},
 	allowedSchemes: DEFAULT_ALLOWED_SCHEMES,
+	allowedSources: options?.allowedSources ?? {},
 	allowedStyles: {
 		...options?.allowedStyles,
 		...TABLE_ALLOWED_STYLES
@@ -1521,47 +2218,54 @@ const COLOR_REGEXES = [
 	/^rgba?\(\d{1,3},\s*\d{1,3},\s*\d{1,3}(?:,\s*[\d.]+)?\)$/u,
 	/^[a-z]+$/iu
 ];
-const sanitizeTextHtml = (html) => sanitizeHtml(html, {
-	allowedAttributes: {
-		input: [
-			"checked",
-			"disabled",
-			"type"
-		],
-		li: ["data-checked", "data-type"],
-		span: [
-			CUSTOM_EMOJI_ID_ATTRIBUTE,
-			CUSTOM_EMOJI_NAME_ATTRIBUTE,
-			MENTION_ID_ATTRIBUTE,
-			MENTION_ITEM_TYPE_ATTRIBUTE,
-			MENTION_LABEL_ATTRIBUTE,
-			MENTION_TYPE_ATTRIBUTE,
-			SPOILER_ATTRIBUTE,
-			"style"
-		],
-		ul: ["data-type"]
-	},
-	allowedClasses: {
-		code: ["language-*"],
-		pre: ["language-*"],
-		span: ["hljs*"]
-	},
-	allowedStyles: { span: {
-		"background-color": COLOR_REGEXES,
-		"border-radius": [/^[\d.]+(?<unit>px|em|rem|%)$/u],
-		color: COLOR_REGEXES
-	} },
-	allowedTags: [
-		...DEFAULT_ALLOWED_TAGS,
-		"input",
-		"label"
+const KIT_ALLOWED_ATTRIBUTES = {
+	input: [
+		"checked",
+		"disabled",
+		"type"
 	],
-	transformAttributes: { input: ({ checked }) => ({
-		...checked === void 0 ? {} : { checked },
-		disabled: "",
-		type: "checkbox"
-	}) }
-});
+	li: ["data-checked", "data-type"],
+	span: [
+		CUSTOM_EMOJI_ID_ATTRIBUTE,
+		CUSTOM_EMOJI_NAME_ATTRIBUTE,
+		MENTION_ID_ATTRIBUTE,
+		MENTION_ITEM_TYPE_ATTRIBUTE,
+		MENTION_LABEL_ATTRIBUTE,
+		MENTION_TYPE_ATTRIBUTE,
+		SPOILER_ATTRIBUTE,
+		"style"
+	],
+	ul: ["data-type"]
+};
+const sanitizeTextHtml = (html, allowance = {}) => {
+	const allowedAttributes = { ...KIT_ALLOWED_ATTRIBUTES };
+	for (const [tagName, attributes] of Object.entries(allowance.allowedAttributes ?? {})) allowedAttributes[tagName] = [.../* @__PURE__ */ new Set([...allowedAttributes[tagName] ?? [], ...attributes])];
+	return sanitizeHtml(html, {
+		allowedAttributes,
+		allowedClasses: {
+			code: ["language-*"],
+			pre: ["language-*"],
+			span: ["hljs*"]
+		},
+		allowedSources: allowance.allowedSources,
+		allowedStyles: { span: {
+			"background-color": COLOR_REGEXES,
+			"border-radius": [/^[\d.]+(?<unit>px|em|rem|%)$/u],
+			color: COLOR_REGEXES
+		} },
+		allowedTags: [
+			...DEFAULT_ALLOWED_TAGS,
+			"input",
+			"label",
+			...allowance.allowedTags ?? []
+		],
+		transformAttributes: { input: ({ checked }) => ({
+			...checked === void 0 ? {} : { checked },
+			disabled: "",
+			type: "checkbox"
+		}) }
+	});
+};
 // src/services/shared/applyItemMetadataMixin.ts
 const applyItemMetadataMixin = (Base) => class ItemWithMetadata extends Base {
 	createdAt = /* @__PURE__ */ new Date();
@@ -1572,6 +2276,8 @@ const applyItemMetadataMixin = (Base) => class ItemWithMetadata extends Base {
 const normalizeString = (value) => value?.trim() ?? "";
 // src/services/zod/createNormalizedStringSchema.ts
 const createNormalizedStringSchema = (maxLength, schema = z.string()) => schema.transform(normalizeString).pipe(z.string().max(maxLength));
+// src/services/zod/createRecordSchema.ts
+const createRecordSchema = (keySchema, valueSchema, maxEntries) => z.record(keySchema, valueSchema).refine((record) => Object.keys(record).length <= maxEntries, { error: `Record must have at most ${maxEntries} entries` }).meta({ maxProperties: maxEntries });
 // src/util/id/constants.ts
 const ID_SEPARATOR = "|";
 // src/services/zod/createUniqueArraySchema.ts
@@ -1714,26 +2420,8 @@ const downloadFile = (filename, blobPart, type) => {
 };
 // src/util/environment/checkIsServer.ts
 const checkIsServer = () => typeof window === "undefined";
-// src/util/function/getSynchronizedFunction.ts
-const pendingPromises = /* @__PURE__ */ new Set();
-const getSynchronizedFunction = (asyncFunction) => (...args) => {
-	const promise = asyncFunction(...args).finally(() => {
-		pendingPromises.delete(promise);
-	});
-	pendingPromises.add(promise);
-};
-const waitForSynchronizedFunctions = async () => {
-	await Promise.allSettled(pendingPromises);
-};
 // src/util/id/uuid/constants.ts
 const UUIDV4_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu;
-// src/util/map/getOrCreate.ts
-const getOrCreate = (map, key, create) => {
-	if (map.has(key)) return map.get(key);
-	const value = create();
-	map.set(key, value);
-	return value;
-};
 // src/util/object/clonePlainDeep.ts
 const clone = (data, copies) => {
 	if (!Array.isArray(data) && !checkIsPlainObject(data)) return data;
@@ -1751,8 +2439,6 @@ const clone = (data, copies) => {
 	}
 };
 const clonePlainDeep = (data) => clone(data, /* @__PURE__ */ new WeakMap());
-// src/util/object/getPropertyNames.ts
-const getPropertyNames = () => new Proxy({}, { get: (_target, property) => property });
 // src/util/object/jsonDateParse.ts
 const ISO_DATE_REGEX = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hours>\d{2}):(?<minutes>\d{2}):(?<seconds>\d{2}(?:\.{0,1}\d*))(?:Z|(?<sign>\+|-)(?<offset>[\d|:]*))?$/u;
 const MS_AJAX_DATE_REGEX = /^\/Date\((?<timestamp>-?\d+(?:[-+]\d+)?)\)[/\\]$/u;
@@ -1789,17 +2475,22 @@ const createEvictingPromiseCache = (getKey, load) => {
 		});
 	};
 };
+// src/util/promise/rethrowRejections.ts
+const rethrowRejections = (reasons) => {
+	if (reasons.length === 1) throw takeOne(reasons);
+	else if (reasons.length > 1) throw new AggregateError(reasons, toAppError(takeOne(reasons)).message);
+};
 // src/util/promise/settleAll.ts
 const settleAll = async (tasks, concurrencyLimit = tasks.length) => {
 	if (tasks.length === 0) return [];
+	if (!Number.isInteger(concurrencyLimit) || concurrencyLimit < 1) throw new InvalidOperationError("Read", settleAll.name, "the concurrency limit is not a whole number of at least one");
 	const values = [];
 	for (const tasksChunk of chunk(tasks, concurrencyLimit)) {
 		const results = await Promise.allSettled(tasksChunk.map((task) => Promise.try(task)));
 		const reasons = [];
 		for (const result of results) if (result.status === "rejected") reasons.push(result.reason);
 		else values.push(result.value);
-		if (reasons.length === 1) throw takeOne(reasons);
-		else if (reasons.length > 1) throw new AggregateError(reasons, toAppError(takeOne(reasons)).message);
+		rethrowRejections(reasons);
 	}
 	return values;
 };
@@ -2015,6 +2706,8 @@ const EncodedSubDelimiterMap = {
 const encodeUrlSubDelimiters = (value) => Object.entries(EncodedSubDelimiterMap).reduce((encoded, [subDelimiter, encodedSubDelimiter]) => encoded.replaceAll(subDelimiter, encodedSubDelimiter), value);
 // src/util/text/getDecodedUriComponent.ts
 const getDecodedUriComponent = (value, fallback) => getResult(() => decodeURIComponent(value)).unwrapOr(fallback);
+// src/util/text/padWithZeros.ts
+const padWithZeros = (value, length) => String(value).padStart(length, "0");
 // src/util/text/streamToText.ts
 const streamToText = async (readable) => {
 	readable.setEncoding("utf8");
@@ -2035,33 +2728,33 @@ const truncate = (string, length) => {
 const uncapitalize = (string) => `${string.charAt(0).toLowerCase()}${string.slice(1)}`;
 // src/util/time/constants.ts
 const MILLISECONDS_PER_SECOND = 1e3;
-// src/util/time/hrtime.ts
-const hrtime = (previousHrTime) => {
-	if (checkIsServer()) return process.hrtime(previousHrTime);
-	const clocktime = performance.now() * .001;
-	let seconds = Math.floor(clocktime);
-	let nanoseconds = Math.floor(clocktime % 1 * 1e9);
-	if (previousHrTime) {
-		seconds -= previousHrTime[0];
-		nanoseconds -= previousHrTime[1];
-		if (nanoseconds < 0) {
-			seconds--;
-			nanoseconds += 1e9;
-		}
-	}
-	return [seconds, nanoseconds];
-};
-// src/util/time/now.ts
-const loadNanoseconds = hrtime();
-const loadMilliseconds = Date.now();
-const now = () => {
-	const [seconds, nanoseconds] = hrtime(loadNanoseconds);
-	return (BigInt(loadMilliseconds) * 10n ** 6n + (BigInt(seconds) * 10n ** 9n + BigInt(nanoseconds))).toString();
-};
+// src/util/time/getExponentialBackoffDelayMs.ts
+const getExponentialBackoffDelayMs = (attempt, baseDelayMs, maxDelayMs) => Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
 // src/util/time/sleep.ts
 const sleep = (durationMs) => new Promise((resolve) => {
 	setTimeout(() => {
 		resolve();
 	}, durationMs);
 });
-export { ALL_SPECIAL_VALUES, APPEND_SEGMENT, CHARSET_PARAMETER_REGEX, CUSTOM_EMOJI_ID_ATTRIBUTE, CUSTOM_EMOJI_NAME_ATTRIBUTE, DEFAULT_ALLOWED_ATTRIBUTES, DEFAULT_ALLOWED_SCHEMES, DEFAULT_ALLOWED_TAGS, DEFAULT_COMPRESSION_LEVEL, DEFAULT_FACET_SCORE, DEFAULT_LINK_ATTRIBUTES, DEFAULT_SOURCE_SCORE, DEFAULT_TEXT_CHARSET, DEFAULT_TYPE_SCORE, ESCAPED_ATTRIBUTE_CHARACTERS_REGEX, ESCAPED_TEXT_CHARACTERS_REGEX, FacetScoreMap, ForbiddenError, GIBIBYTE, HTML_NAMESPACE, ID_SEPARATOR, IMPORTANT_REGEX, InvalidOperationError, ItemMetadata, JSON_POINTER_REGEX, JsonPatchOperationType, KIBIBYTE, MAX_NESTING_DEPTH, MAX_READ_LIMIT, MAX_WINDOW_LOG, MEDIA_TYPE_REGEX, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_SELECTOR, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MILLISECONDS_PER_SECOND, MIN_WINDOW_LOG, MentionType, NON_TEXT_TAGS, NotFoundError, NotInitializedError, ObjectMethod, Operation, PATH_SEPARATOR_REGEX, RoutePath, SANITIZER_ADVISORY_WATCH_SINCE, SITE_NAME, SPOILER_ATTRIBUTE, SPOILER_SELECTOR, SRCSET_ATTRIBUTE, SRCSET_DESCRIPTOR_REGEX, Serializable, SourceScoreMap, TEXT_MEDIA_TYPE_REGEX, TypeScoreMap, TypedEventEmitter, URL_ATTRIBUTES, UUIDV4_REGEX, VOID_TAGS, WordFilteredError, addJsonValue, applyItemMetadataMixin, applyPatch, applyPatches, capitalize, charset, checkContainsProfanity, checkIsAllowedUrl, checkIsCustomMethod, checkIsDeepEqual, checkIsNestedControl, checkIsNestedInteraction, checkIsPlainObject, checkIsSameBytes, checkIsSameValueZero, checkIsServer, checkIsUnsafeUrlCharacter, checkIsWhitespaceCharacter, chunk, chunkBySerializedSize, clonePlainDeep, collectText, contentType, createEvictingPromiseCache, createHistory, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, dedent, downloadFile, downloadUrl, encodeUrlSubDelimiters, englishProfaneWords, escapeAttribute, escapeCharacters, escapeText, exhaustiveGuard, extension, filterAttributes, filterClasses, filterHtml, filterSrcset, filterStyle, getChildNodes, getDecodedUriComponent, getEndOfDay, getEnumerableKeys, getExtensionMimeTypeMap, getMediaType, getMentions, getMimeScore, getMimeTypeEntryMap, getOrCreate, getPropertyNames, getRawData, getRequestError, getResult, getResultAsync, getSynchronizedFunction, getTransactionDone, getTransactionObjectStore, getWindowLog, getZonedDateTime, hrtime, html, jsonDateParse, lookup, matchesClassPattern, mergeObjectsStrict, noop, normalizeString, now, omitDeep, openDatabase, parseArrayIndex, parseJsonPointer, pushHistory, readJsonValue, redoHistory, removeJsonValue, renderNode, reportFinalizerError, requestToPromise, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, streamToText, takeOne, takeRandom, toAppError, toJsonPointer, toKebabCase, toRawDeep, truncate, uncapitalize, undoHistory, updateJsonValue, waitForSynchronizedFunctions, withFinalizer, withFinalizerAsync, wrapDatabase, wrapIndex, wrapObjectStore, wrapTransaction, wrapUpgradeDatabase, wrapUpgradeTransaction };
+// src/util/time/createExponentialBackoff.ts
+const createExponentialBackoff = (baseDelayMs, maxDelayMs) => {
+	let failureCount = 0;
+	return async (operation) => {
+		if (failureCount > 0) await sleep(getExponentialBackoffDelayMs(failureCount - 1, baseDelayMs, maxDelayMs));
+		return getResultAsync(operation).match((value) => {
+			failureCount = 0;
+			return value;
+		}, (error) => {
+			failureCount += 1;
+			throw error;
+		});
+	};
+};
+// src/util/time/now.ts
+let latestNanoseconds = 0n;
+const now = () => {
+	const nanoseconds = BigInt(Math.round(performance.timeOrigin * 1e3)) * 1000n + BigInt(Math.round(performance.now() * 1e6));
+	latestNanoseconds = nanoseconds > latestNanoseconds ? nanoseconds : latestNanoseconds + 1n;
+	return latestNanoseconds.toString();
+};
+export { ALL_SPECIAL_VALUES, APPEND_SEGMENT, CHARSET_PARAMETER_REGEX, CUSTOM_EMOJI_ID_ATTRIBUTE, CUSTOM_EMOJI_NAME_ATTRIBUTE, DEFAULT_ALLOWED_ATTRIBUTES, DEFAULT_ALLOWED_SCHEMES, DEFAULT_ALLOWED_TAGS, DEFAULT_COMPRESSION_LEVEL, DEFAULT_FACET_SCORE, DEFAULT_LINK_ATTRIBUTES, DEFAULT_SOURCE_SCORE, DEFAULT_TEXT_CHARSET, DEFAULT_TYPE_SCORE, ESCAPED_ATTRIBUTE_CHARACTERS_REGEX, ESCAPED_TEXT_CHARACTERS_REGEX, FacetScoreMap, ForbiddenError, GIBIBYTE, HTML_NAMESPACE, ID_SEPARATOR, IMPORTANT_REGEX, InvalidOperationError, ItemMetadata, ItemMetadataPropertyNames, JSON_POINTER_REGEX, JsonPatchOperationType, KIBIBYTE, MAX_NESTING_DEPTH, MAX_READ_LIMIT, MAX_WINDOW_LOG, MEDIA_TYPE_REGEX, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_SELECTOR, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MILLISECONDS_PER_SECOND, MIN_WINDOW_LOG, MentionType, NON_TEXT_TAGS, NotFoundError, NotInitializedError, ObjectMethod, Operation, PANZOOM_DEFAULT_CURSOR, PANZOOM_DEFAULT_DURATION, PANZOOM_DEFAULT_EASING, PANZOOM_DEFAULT_EXCLUDE_CLASS, PANZOOM_DEFAULT_MAX_SCALE, PANZOOM_DEFAULT_MIN_SCALE, PANZOOM_DEFAULT_OPTIONS, PANZOOM_DEFAULT_OVERFLOW, PANZOOM_DEFAULT_PAN_THRESHOLD, PANZOOM_DEFAULT_START_PAN, PANZOOM_DEFAULT_START_SCALE, PANZOOM_DEFAULT_STEP, PANZOOM_DEFAULT_TOUCH_ACTION, PANZOOM_PIXELS_PER_LINE, PANZOOM_PRIMARY_BUTTON, PANZOOM_SVG_NAMESPACE, PANZOOM_TRANSFORM_ORIGIN, PANZOOM_WHEEL_NOTCH_PIXELS, PANZOOM_WHEEL_STEP_DIVISOR, PATH_SEPARATOR_REGEX, PanzoomContain, PanzoomDeltaMode, PanzoomEventName, PanzoomZoomDirection, RoutePath, SANITIZER_ADVISORY_WATCH_SINCE, SITE_NAME, SPOILER_ATTRIBUTE, SPOILER_SELECTOR, SRCSET_ATTRIBUTE, SRCSET_DESCRIPTOR_REGEX, Serializable, SourceScoreMap, TEXT_MEDIA_TYPE_REGEX, TypeScoreMap, TypedEventEmitter, URL_ATTRIBUTES, UUIDV4_REGEX, VOID_TAGS, WordFilteredError, addJsonValue, applyItemMetadataMixin, applyPanzoomStyles, applyPatch, applyPatches, bindPanzoom, capitalize, charset, checkContainsProfanity, checkIsAllowedUrl, checkIsContainableLength, checkIsCustomMethod, checkIsDeepEqual, checkIsNestedControl, checkIsNestedInteraction, checkIsOnlyReactor, checkIsPanzoomElement, checkIsPanzoomExcluded, checkIsPlainObject, checkIsSameBytes, checkIsSameValueZero, checkIsServer, checkIsSourceAllowed, checkIsUnsafeUrlCharacter, checkIsWhitespaceCharacter, checkIsZoomRefused, chunk, chunkBySerializedSize, clonePlainDeep, collectText, constrainPanzoomAxis, constrainPanzoomPan, constrainPanzoomScale, contentType, createEvictingPromiseCache, createExponentialBackoff, createHistory, createItemEntityTypeSchema, createNormalizedStringSchema, createPanzoom, createRecordSchema, createUniqueArraySchema, css, dedent, dispatchPanzoomChange, dispatchPanzoomEvent, downloadFile, downloadUrl, encodeUrlSubDelimiters, endPanzoomGesture, englishProfaneWords, escapeAttribute, escapeCharacters, escapeText, exhaustiveGuard, extension, filterAttributes, filterClasses, filterHtml, filterSrcset, filterStyle, fitPanzoom, getChildNodes, getDecodedUriComponent, getEndOfDay, getEnumerableKeys, getExponentialBackoffDelayMs, getExtensionMimeTypeMap, getMediaType, getMentions, getMimeScore, getMimeTypeEntryMap, getOrCreate, getPanzoomCallOptions, getPanzoomCentredPan, getPanzoomCoverScale, getPanzoomDrag, getPanzoomEventDetail, getPanzoomFitScale, getPanzoomFocalPan, getPanzoomMeasure, getPanzoomParent, getPanzoomPinchFrame, getPanzoomPinchScale, getPanzoomStartScale, getPanzoomStartState, getPanzoomStepScale, getPanzoomTarget, getPanzoomWheelScale, getPanzoomZoomedState, getPropertyNames, getRawData, getRequestError, getResult, getResultAsync, getSynchronizedFunction, getTagPolicy, getTransactionDone, getTransactionObjectStore, getUpdatedUserIds, getWindowLog, getZonedDateTime, html, jsonDateParse, lookup, matchesClassPattern, mergeObjectsStrict, movePanzoomDrag, movePanzoomGesture, movePanzoomPinch, noop, normalizeString, now, omitDeep, openDatabase, padWithZeros, panPanzoom, parseArrayIndex, parseJsonPointer, pushHistory, readJsonValue, reanchorPanzoomDrag, redoHistory, removeJsonValue, renderNode, reportFinalizerError, requestToPromise, resetPanzoom, restorePanzoomStyles, rethrowRejections, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, startPanzoomGesture, streamToText, takeOne, takeRandom, toAppError, toJsonPointer, toKebabCase, toRawDeep, truncate, uncapitalize, undoHistory, updateJsonValue, waitForSynchronizedFunctions, withFinalizer, withFinalizerAsync, wrapDatabase, wrapIndex, wrapObjectStore, wrapTransaction, wrapUpgradeDatabase, wrapUpgradeTransaction, writePanzoomState, writePanzoomStyle, zoomPanzoom, zoomPanzoomStep };