@esposter/shared 4.4.0 → 4.6.0

package/README.md

@@ -5,7 +5,7 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-Shared TypeScript utilities, types, and error classes for the Esposter platform.
+Provides shared TypeScript utilities, types and error classes for the Esposter platform.
 
 Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/shared).
 
@@ -19,11 +19,13 @@ Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/
 
 ## <a name="getting-started">🚀 Getting Started</a>
 
+Install the package and zod.
+
 ```bash
 pnpm i @esposter/shared zod
 ```
 
-Works in both browser and server environments.
+The package works in browser and server environments.
 
 ## <a name="key-exports">🧩 Key Exports</a>
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { Result, ResultAsync } from "neverthrow";
-import { HTMLElement } from "node-html-parser";
+import { HTMLElement as HTMLElement$1 } from "node-html-parser";
 import { DefaultTreeAdapterTypes, html as html$1 } from "parse5";
 export declare class ForbiddenError extends Error {
   constructor(message: string);
@@ -139,6 +139,150 @@ export declare enum ObjectMethod {
   ToString = "toString",
   ValueOf = "valueOf"
 }
+export interface PanzoomEventDetail {
+  isSVG: boolean;
+  originalEvent?: Event;
+  scale: number;
+  x: number;
+  y: number;
+}
+export declare enum PanzoomContain {
+  Automatic = "automatic",
+  Inside = "inside",
+  Outside = "outside"
+}
+export type PanzoomStartScale = "fit" | number;
+export interface PanzoomOptions {
+  animate?: boolean;
+  canvas?: boolean;
+  contain?: PanzoomContain;
+  cursor?: string;
+  disablePan?: boolean;
+  disableXAxis?: boolean;
+  disableYAxis?: boolean;
+  disableZoom?: boolean;
+  duration?: number;
+  easing?: string;
+  exclude?: Element[];
+  excludeClass?: string;
+  filter?: (event: PointerEvent) => boolean;
+  handleStartEvent?: (event: Event) => void;
+  maxScale?: number;
+  minScale?: number;
+  noBind?: boolean;
+  overflow?: string;
+  panCursor?: string;
+  panOnlyWhenZoomed?: boolean;
+  panThreshold?: number;
+  pinchAndPan?: boolean;
+  relative?: boolean;
+  roundPixels?: boolean;
+  setTransform?: (element: HTMLElement | SVGElement, detail: Pick<PanzoomEventDetail, "isSVG" | "scale" | "x" | "y">) => void;
+  silent?: boolean;
+  startScale?: PanzoomStartScale;
+  startX?: number;
+  startY?: number;
+  step?: number;
+  touchAction?: string;
+}
+export interface PanzoomPanOptions extends PanzoomOptions {
+  force?: boolean;
+}
+export interface PanzoomPoint {
+  x: number;
+  y: number;
+}
+export interface PanzoomZoomOptions extends PanzoomPanOptions {
+  focal?: PanzoomPoint;
+}
+export interface Panzoom {
+  bind: () => void;
+  destroy: () => void;
+  fit: (fitOptions?: PanzoomPanOptions) => PanzoomEventDetail;
+  getOptions: () => PanzoomOptions;
+  getPan: () => PanzoomPoint;
+  getScale: () => number;
+  pan: (x: number, y: number, panOptions?: PanzoomPanOptions) => PanzoomEventDetail;
+  reset: (resetOptions?: PanzoomPanOptions) => PanzoomEventDetail;
+  resetStyle: () => void;
+  setOptions: (options?: PanzoomOptions) => void;
+  zoom: (scale: number, zoomOptions?: PanzoomZoomOptions) => PanzoomEventDetail;
+  zoomIn: (zoomOptions?: PanzoomZoomOptions) => PanzoomEventDetail;
+  zoomOut: (zoomOptions?: PanzoomZoomOptions) => PanzoomEventDetail;
+  zoomToPoint: (scale: number, point: Pick<MouseEvent, "clientX" | "clientY">, zoomOptions?: PanzoomZoomOptions, originalEvent?: Event) => PanzoomEventDetail;
+  zoomWithWheel: (event: WheelEvent, zoomOptions?: PanzoomZoomOptions) => PanzoomEventDetail;
+}
+export interface PanzoomAxis {
+  center: number;
+  length: number;
+  parentLength: number;
+  parentStart: number;
+}
+export interface PanzoomBox {
+  height: number;
+  left: number;
+  top: number;
+  width: number;
+}
+export interface PanzoomDrag {
+  anchorPan: PanzoomPoint;
+  anchorPoint: PanzoomPoint;
+  downPoint: PanzoomPoint;
+  isDragging: boolean;
+}
+export type PanzoomElement = HTMLElement | SVGElement;
+export interface PanzoomPinch {
+  midpoint: PanzoomPoint;
+  startDistance: number;
+  startScale: number;
+}
+export interface PanzoomState {
+  scale: number;
+  x: number;
+  y: number;
+}
+export interface PanzoomContext {
+  drag?: PanzoomDrag;
+  element: PanzoomElement;
+  isClickSuppressed: boolean;
+  isDestroyed: boolean;
+  options: PanzoomOptions;
+  parent: PanzoomElement;
+  pinch?: PanzoomPinch;
+  pointers: Map<number, PanzoomPoint>;
+  state: PanzoomState;
+  styles: Map<PanzoomElement, Map<string, string>>;
+}
+export declare enum PanzoomDeltaMode {
+  Pixel = 0,
+  Line = 1,
+  Page = 2
+}
+export declare enum PanzoomEventName {
+  Change = "panzoomchange",
+  End = "panzoomend",
+  Pan = "panzoompan",
+  Reset = "panzoomreset",
+  Start = "panzoomstart",
+  Zoom = "panzoomzoom"
+}
+export interface PanzoomSize {
+  height: number;
+  width: number;
+}
+export interface PanzoomMeasure {
+  center: PanzoomPoint;
+  parent: PanzoomBox;
+  size: PanzoomSize;
+}
+export interface PanzoomPinchFrame {
+  distance: number;
+  midpoint: PanzoomPoint;
+}
+export declare enum PanzoomZoomDirection {
+  In = "in",
+  Out = "out"
+}
 export interface ProfanityOptions {
   isWholeWord: boolean;
 }
@@ -1968,7 +2112,7 @@ export declare const SPOILER_ATTRIBUTE = "data-spoiler";
 export declare const SPOILER_SELECTOR: string;
 export declare const checkIsOnlyReactor: (userIds: string[], userId: string) => boolean;
 export declare const getUpdatedUserIds: (userIds: string[], newUserId: string) => string[];
-export declare const getMentions: (message: string) => HTMLElement[];
+export declare const getMentions: (message: string) => HTMLElement$1[];
 export declare const charset: (type: string) => false | string;
 export declare const MEDIA_TYPE_REGEX: RegExp;
 export declare const PATH_SEPARATOR_REGEX: RegExp;
@@ -1988,6 +2132,68 @@ export declare const getMediaType: (value: string) => string;
 export declare const getMimeScore: (mimeType: string, source?: string) => number;
 export declare const getMimeTypeEntryMap: () => ReadonlyMap<string, MimeDatabaseEntry>;
 export declare const lookup: (path: string) => false | string;
+export declare const applyPanzoomStyles: (context: PanzoomContext) => void;
+export declare const bindPanzoom: (context: PanzoomContext, signal: AbortSignal) => void;
+export declare const checkIsContainableLength: (length: number) => boolean;
+export declare const checkIsPanzoomElement: (value: Element) => value is PanzoomElement;
+export declare const checkIsPanzoomExcluded: (target: Element, { exclude, excludeClass }: Pick<PanzoomOptions, "exclude" | "excludeClass">) => boolean;
+export declare const checkIsZoomRefused: ({ disableZoom, force }: PanzoomZoomOptions) => boolean;
+export declare const PANZOOM_DEFAULT_MAX_SCALE = 4;
+export declare const PANZOOM_DEFAULT_MIN_SCALE = .125;
+export declare const PANZOOM_DEFAULT_START_SCALE = 1;
+export declare const PANZOOM_DEFAULT_STEP = .3;
+export declare const PANZOOM_WHEEL_STEP_DIVISOR = 3;
+export declare const PANZOOM_WHEEL_NOTCH_PIXELS = 100;
+export declare const PANZOOM_PIXELS_PER_LINE = 16;
+export declare const PANZOOM_PRIMARY_BUTTON = 0;
+export declare const PANZOOM_DEFAULT_CURSOR = "move";
+export declare const PANZOOM_DEFAULT_DURATION = 200;
+export declare const PANZOOM_DEFAULT_EASING = "ease-in-out";
+export declare const PANZOOM_DEFAULT_EXCLUDE_CLASS = "panzoom-exclude";
+export declare const PANZOOM_DEFAULT_OVERFLOW = "hidden";
+export declare const PANZOOM_DEFAULT_PAN_THRESHOLD = 0;
+export declare const PANZOOM_DEFAULT_START_PAN = 0;
+export declare const PANZOOM_DEFAULT_TOUCH_ACTION = "none";
+export declare const PANZOOM_TRANSFORM_ORIGIN = "50% 50%";
+export declare const PANZOOM_SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+export declare const PANZOOM_DEFAULT_OPTIONS: Readonly<PanzoomOptions>;
+export declare const constrainPanzoomAxis: (value: number, axis: PanzoomAxis, scale: number, contain?: PanzoomContain) => number;
+export declare const constrainPanzoomPan: (current: PanzoomState, requested: PanzoomPoint, toScale: number, measure: PanzoomMeasure, options: PanzoomPanOptions) => PanzoomPoint;
+export declare const constrainPanzoomScale: (scale: number, measure: PanzoomMeasure, { contain, maxScale, minScale }: Pick<PanzoomOptions, "contain" | "maxScale" | "minScale">) => number;
+export declare const createPanzoom: (element: PanzoomElement, options?: PanzoomOptions) => Panzoom;
+export declare const dispatchPanzoomChange: (context: Pick<PanzoomContext, "element" | "isDestroyed">, name: PanzoomEventName, detail: PanzoomEventDetail, options: Pick<PanzoomOptions, "silent">) => void;
+export declare const dispatchPanzoomEvent: ({ element, isDestroyed }: Pick<PanzoomContext, "element" | "isDestroyed">, name: PanzoomEventName, detail: PanzoomEventDetail, { silent }: Pick<PanzoomOptions, "silent">) => void;
+export declare const endPanzoomGesture: (context: PanzoomContext, event: PointerEvent) => void;
+export declare const fitPanzoom: (context: PanzoomContext, callOptions: PanzoomZoomOptions) => PanzoomEventDetail;
+export declare const getPanzoomCallOptions: ({ options }: PanzoomContext, callOptions: PanzoomZoomOptions) => PanzoomZoomOptions;
+export declare const getPanzoomCentredPan: (scale: number, measure: PanzoomMeasure) => PanzoomPoint;
+export declare const getPanzoomCoverScale: (measure: PanzoomMeasure) => number;
+export declare const getPanzoomDrag: (state: PanzoomState, point: PanzoomPoint) => PanzoomDrag;
+export declare const getPanzoomEventDetail: ({ element, state }: PanzoomContext, originalEvent?: Event) => PanzoomEventDetail;
+export declare const getPanzoomFitScale: ({ parent, size }: PanzoomMeasure) => number;
+export declare const getPanzoomFocalPan: (current: PanzoomState, toScale: number, point: PanzoomPoint, measure: PanzoomMeasure) => PanzoomPoint;
+export declare const getPanzoomMeasure: (element: PanzoomElement, parent: PanzoomElement, state: PanzoomState) => PanzoomMeasure;
+export declare const getPanzoomParent: (element: PanzoomElement) => null | PanzoomElement;
+export declare const getPanzoomPinchFrame: (pointers: Map<number, PanzoomPoint>) => PanzoomPinchFrame;
+export declare const getPanzoomPinchScale: (startScale: number, startDistance: number, distance: number) => number;
+export declare const getPanzoomStartScale: (measure: PanzoomMeasure, options: Pick<PanzoomPanOptions, "contain" | "maxScale" | "minScale" | "startScale">) => number;
+export declare const getPanzoomStartState: (state: PanzoomState, measure: PanzoomMeasure, options: PanzoomPanOptions) => PanzoomState;
+export declare const getPanzoomStepScale: (scale: number, direction: PanzoomZoomDirection, step?: number) => number;
+export declare const getPanzoomTarget: ({ element, options, parent }: PanzoomContext) => PanzoomElement;
+export declare const getPanzoomWheelScale: (scale: number, { deltaMode, deltaX, deltaY }: Pick<WheelEvent, "deltaMode" | "deltaX" | "deltaY">, step?: number) => number;
+export declare const getPanzoomZoomedState: (state: PanzoomState, measure: PanzoomMeasure, options: PanzoomPanOptions, scale: number, focal?: PanzoomPoint) => PanzoomState;
+export declare const movePanzoomDrag: (context: PanzoomContext, drag: PanzoomDrag, point: PanzoomPoint, event: PointerEvent) => void;
+export declare const movePanzoomGesture: (context: PanzoomContext, event: PointerEvent) => void;
+export declare const movePanzoomPinch: (context: PanzoomContext, pinch: PanzoomPinch, event: PointerEvent) => void;
+export declare const panPanzoom: (context: PanzoomContext, point: PanzoomPoint, callOptions: PanzoomZoomOptions, originalEvent?: Event) => PanzoomEventDetail;
+export declare const reanchorPanzoomDrag: ({ drag, pointers, state }: PanzoomContext) => void;
+export declare const resetPanzoom: (context: PanzoomContext, callOptions: PanzoomZoomOptions) => PanzoomEventDetail;
+export declare const restorePanzoomStyles: ({ styles }: PanzoomContext, properties?: readonly string[]) => void;
+export declare const startPanzoomGesture: (context: PanzoomContext, event: PointerEvent) => void;
+export declare const writePanzoomState: (context: PanzoomContext, state: PanzoomState, { animate, duration, easing, setTransform }: PanzoomPanOptions) => void;
+export declare const writePanzoomStyle: ({ isDestroyed, styles }: PanzoomContext, element: PanzoomElement, property: string, value: string) => void;
+export declare const zoomPanzoom: (context: PanzoomContext, scale: number, callOptions: PanzoomZoomOptions, originalEvent?: Event) => PanzoomEventDetail;
+export declare const zoomPanzoomStep: (context: PanzoomContext, direction: PanzoomZoomDirection, zoomOptions: PanzoomZoomOptions) => PanzoomEventDetail;
 export declare const css: typeof String.raw;
 export declare const html: typeof String.raw;
 export declare const checkContainsProfanity: (text: unknown, { isWholeWord }?: Partial<ProfanityOptions>) => boolean;
@@ -2028,6 +2234,7 @@ export declare const sanitizeHtml: (html: string, options?: SanitizeHtmlOptions)
 export declare const sanitizeTextHtml: (html: string, allowance?: TextHtmlAllowance) => string;
 export declare const applyItemMetadataMixin: <TBase extends Class<object>>(Base: TBase) => ItemMetadataClass<TBase>;
 export declare const createNormalizedStringSchema: (maxLength: number, schema?: z.ZodString) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+export declare const createRecordSchema: <TKey extends z.core.$ZodRecordKey, TValue extends z.core.SomeType>(keySchema: TKey, valueSchema: TValue, maxEntries: number) => z.ZodRecord<TKey, TValue>;
 export declare const createUniqueArraySchema: CreateUniqueArraySchema;
 export declare const DEFAULT_COMPRESSION_LEVEL = 12;
 export declare const MIN_WINDOW_LOG = 10;
@@ -2067,6 +2274,7 @@ export type MergeObjectsStrict<T extends object[]> = T extends [infer TFirst, in
 export declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
 export declare const omitDeep: <T, TKey extends string>(value: T, ...keys: TKey[]) => DeepOmit<T, TKey>;
 export declare const createEvictingPromiseCache: <TArguments extends unknown[], TValue>(getKey: (...args: TArguments) => string, load: (...args: TArguments) => Promise<TValue>) => ((...args: TArguments) => Promise<TValue>);
+export declare const rethrowRejections: (reasons: unknown[]) => void;
 export declare const settleAll: <T>(tasks: (() => Promise<T>)[], concurrencyLimit?: number) => Promise<T[]>;
 export declare const getRawData: <T>(data: T) => T;
 export declare const toRawDeep: <T extends object>(data: T) => T;
@@ -2075,6 +2283,7 @@ export declare const dedent: Dedent;
 export declare const encodeUrlSubDelimiters: (value: string) => string;
 export declare const getDecodedUriComponent: (value: string, fallback: string) => string;
 export declare const normalizeString: (value: string | undefined) => string;
+export declare const padWithZeros: (value: number, length: number) => string;
 export declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
 export declare const toKebabCase: <T extends string>(string: T) => KebabCase<T>;
 export declare const truncate: (string: string, length: number) => string;
@@ -2082,8 +2291,8 @@ export declare const uncapitalize: <T extends string>(string: T) => Uncapitalize
 export declare const MILLISECONDS_PER_SECOND = 1e3;
 export declare const createExponentialBackoff: (baseDelayMs: number, maxDelayMs: number) => (<T>(operation: () => Promise<T>) => Promise<T>);
 export declare const getExponentialBackoffDelayMs: (attempt: number, baseDelayMs: number, maxDelayMs: number) => number;
-export declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
 export declare const now: () => string;
 export declare const sleep: (durationMs: number) => Promise<void>;
+export declare const checkIsEnumValue: <TEnum extends Record<string, string>>(enumObject: TEnum, value: string) => value is TEnum[keyof TEnum];
 export declare const exhaustiveGuard: (value: never) => never;
 export {};

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";
@@ -724,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
@@ -1200,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;
@@ -1613,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
@@ -1757,13 +2422,6 @@ const downloadFile = (filename, blobPart, type) => {
 const checkIsServer = () => typeof window === "undefined";
 // 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;
@@ -1817,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;
 };
@@ -2043,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");
@@ -2085,27 +2750,13 @@ const createExponentialBackoff = (baseDelayMs, maxDelayMs) => {
 		});
 	};
 };
-// 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();
+let latestNanoseconds = 0n;
 const now = () => {
-	const [seconds, nanoseconds] = hrtime(loadNanoseconds);
-	return (BigInt(loadMilliseconds) * 10n ** 6n + (BigInt(seconds) * 10n ** 9n + BigInt(nanoseconds))).toString();
+	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, 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, checkIsOnlyReactor, checkIsPlainObject, checkIsSameBytes, checkIsSameValueZero, checkIsServer, checkIsSourceAllowed, checkIsUnsafeUrlCharacter, checkIsWhitespaceCharacter, chunk, chunkBySerializedSize, clonePlainDeep, collectText, contentType, createEvictingPromiseCache, createExponentialBackoff, createHistory, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, dedent, downloadFile, downloadUrl, encodeUrlSubDelimiters, englishProfaneWords, escapeAttribute, escapeCharacters, escapeText, exhaustiveGuard, extension, filterAttributes, filterClasses, filterHtml, filterSrcset, filterStyle, getChildNodes, getDecodedUriComponent, getEndOfDay, getEnumerableKeys, getExponentialBackoffDelayMs, getExtensionMimeTypeMap, getMediaType, getMentions, getMimeScore, getMimeTypeEntryMap, getOrCreate, getPropertyNames, getRawData, getRequestError, getResult, getResultAsync, getSynchronizedFunction, getTagPolicy, getTransactionDone, getTransactionObjectStore, getUpdatedUserIds, 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/validation/checkIsEnumValue.ts
+const checkIsEnumValue = (enumObject, value) => Object.values(enumObject).some((enumValue) => enumValue === value);
+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, checkIsEnumValue, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esposter/shared",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "A library that contains shared typescript code.",
   "keywords": [
     "error-handling",
@@ -48,18 +48,18 @@
   "dependencies": {
     "mime-db": "^1.54.0",
     "neverthrow": "^8.2.0",
-    "node-html-parser": "^9.0.5",
-    "parse5": "^8.0.1"
+    "node-html-parser": "^9.0.7",
+    "parse5": "^8.1.0"
   },
   "devDependencies": {
     "@azure/data-tables": "^13.3.2",
-    "@esposter/configuration": "4.4.0",
+    "@esposter/configuration": "4.6.0",
     "@types/node": "^26.6.6",
     "fake-indexeddb": "^6.2.7",
     "happy-dom": "^21.0.4",
-    "tsdown": "0.23.2",
+    "tsdown": "^0.23.7",
     "type-fest": "^5.10.0",
-    "vue": "^3.5.44"
+    "vue": "^3.5.45"
   },
   "peerDependencies": {
     "zod": "^4.6.7"
@@ -67,5 +67,5 @@
   "inlinedDependencies": {
     "type-fest": "5.10.0"
   },
-  "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
+  "gitHead": "0ceea3ffbe12ca69413ea5db2d3cfad197a63cba"
 }