@vizejs/ui 0.426.2 → 0.427.0

package/dist/pin-input-oMrddl8G.mjs

@@ -0,0 +1,446 @@
+import { a as useDeterministicId } from "./deterministic-id-bMmJU5xD.mjs";
+import { createContext } from "./context.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { useControllableState } from "./controllable-state.mjs";
+import { computed, createCommentVNode, createElementBlock, defineComponent, guardReactiveProps, nextTick, normalizeProps, onScopeDispose, openBlock, renderSlot, unref, useTemplateRef, watch } from "vue";
+//#region src/families/form/pin-input/pin-input-context.ts
+/** Typed context shared by PinInput and its fields. */
+const pinInputContext = createContext("PinInput");
+//#endregion
+//#region src/families/form/pin-input/pin-input-state.ts
+let graphemeSegmenter;
+/** Split text into user-perceived characters (created lazily to keep imports side-effect free). */
+function splitPinCharacters(text) {
+	graphemeSegmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+	return Array.from(graphemeSegmenter.segment(text), (part) => part.segment);
+}
+const numericCharacter = /^\p{Nd}$/u;
+const alphanumericCharacter = /^[\p{L}\p{Nd}]$/u;
+/** Keep only accepted characters, folding compatibility forms such as full-width digits. */
+function sanitizePinInput(text, type, pattern) {
+	const accepted = [];
+	for (const character of splitPinCharacters(text)) {
+		if (pattern !== void 0) {
+			pattern.lastIndex = 0;
+			if (pattern.test(character)) accepted.push(character);
+			continue;
+		}
+		if (!(type === "numeric" ? numericCharacter : alphanumericCharacter).test(character)) continue;
+		accepted.push(character.normalize("NFKC"));
+	}
+	return accepted;
+}
+/** Normalize a length prop into a safe positive integer. */
+function normalizePinLength(length) {
+	return Number.isFinite(length) && length >= 1 ? Math.min(Math.floor(length), 64) : 1;
+}
+/** Write characters starting at `index` (clamped to the end of the value), truncated to `length`. */
+function writePinCharacters(value, index, characters, length) {
+	const current = splitPinCharacters(value);
+	const start = Math.min(Math.max(index, 0), current.length);
+	return [
+		...current.slice(0, start),
+		...characters,
+		...current.slice(start + characters.length)
+	].slice(0, length).join("");
+}
+/** Remove the character at `index`, shifting later characters left. */
+function removePinCharacter(value, index) {
+	const current = splitPinCharacters(value);
+	if (index < 0 || index >= current.length) return value;
+	current.splice(index, 1);
+	return current.join("");
+}
+/** Narrow characters to a fixed-length tuple after checking the runtime length. */
+function isPinCharacters(characters, length) {
+	return characters.length === length;
+}
+//#endregion
+//#region src/families/form/pin-input/pin-input.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = [
+	"aria-label",
+	"aria-labelledby",
+	"data-state",
+	"data-complete",
+	"data-disabled",
+	"data-invalid"
+];
+const _hoisted_2 = [
+	"name",
+	"form",
+	"value",
+	"disabled"
+];
+//#endregion
+//#region src/families/form/pin-input/pin-input.vue
+var pin_input_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "pin-input",
+	props: {
+		length: {
+			type: null,
+			required: true
+		},
+		modelValue: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		defaultValue: {
+			type: String,
+			required: false,
+			default: ""
+		},
+		type: {
+			type: String,
+			required: false,
+			default: "numeric"
+		},
+		pattern: {
+			type: null,
+			required: false,
+			default: () => void 0
+		},
+		mask: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		otp: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		id: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		name: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		form: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		placeholder: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		required: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		getFieldLabel: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaErrormessage: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaInvalid: {
+			type: [Boolean, String],
+			required: false,
+			default: false
+		}
+	},
+	emits: ["update:modelValue", "complete"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const root = useTemplateRef("root");
+		const baseId = useDeterministicId({
+			id: () => __props.id,
+			hint: "pin"
+		});
+		const fieldCount = computed(() => normalizePinLength(__props.length));
+		const fields = /* @__PURE__ */ new Map();
+		function sanitize(text) {
+			return sanitizePinInput(text, __props.type, __props.pattern).slice(0, fieldCount.value).join("");
+		}
+		const state = useControllableState({
+			value: () => __props.modelValue === void 0 ? void 0 : sanitize(__props.modelValue),
+			defaultValue: () => sanitize(__props.defaultValue),
+			onChange: (next, previous) => {
+				emit("update:modelValue", next);
+				const nextCharacters = splitPinCharacters(next);
+				if (!(splitPinCharacters(previous).length === fieldCount.value) && isPinCharacters(nextCharacters, __props.length)) emit("complete", next, nextCharacters);
+			}
+		});
+		const value = state.value;
+		const characters = computed(() => splitPinCharacters(value.value));
+		const complete = computed(() => characters.value.length === fieldCount.value);
+		const indexes = computed(() => Array.from({ length: fieldCount.value }, (_, index) => index));
+		const ariaInvalidValue = computed(() => {
+			if (__props.ariaInvalid === false) return void 0;
+			return __props.ariaInvalid === true ? "true" : __props.ariaInvalid;
+		});
+		const dataState = computed(() => {
+			if (__props.disabled) return "disabled";
+			if (complete.value) return "complete";
+			return characters.value.length === 0 ? "empty" : "incomplete";
+		});
+		function commit(next) {
+			return state.set(next);
+		}
+		function focusField(index) {
+			const clamped = Math.min(Math.max(index, 0), fieldCount.value - 1);
+			const element = fields.get(clamped);
+			element?.focus();
+			element?.select();
+		}
+		/** Write typed or pasted text at a field; returns the index that should receive focus. */
+		function write(index, text) {
+			if (__props.disabled) return index;
+			const accepted = sanitizePinInput(text, __props.type, __props.pattern);
+			if (accepted.length === 0) return index;
+			const start = Math.min(index, characters.value.length);
+			commit(writePinCharacters(value.value, start, accepted, fieldCount.value));
+			return Math.min(start + accepted.length, fieldCount.value - 1);
+		}
+		/** Delete a character; returns the index that should receive focus. */
+		function remove(index, direction) {
+			if (__props.disabled) return index;
+			const hasCharacter = index < characters.value.length;
+			if (direction === "forward" || hasCharacter) {
+				commit(removePinCharacter(value.value, index));
+				return index;
+			}
+			const previous = Math.min(index, characters.value.length) - 1;
+			if (previous < 0) return 0;
+			commit(removePinCharacter(value.value, previous));
+			return previous;
+		}
+		watch(root, (element, _previous, onCleanup) => {
+			const owner = __props.form === void 0 ? element?.closest("form") : element?.ownerDocument.getElementById(__props.form);
+			if (owner == null || !(owner instanceof HTMLFormElement)) return;
+			const onReset = () => {
+				if (!state.controlled.value) state.reset();
+				nextTick(() => {
+					for (const [index, input] of fields) input.value = characters.value[index] ?? "";
+				});
+			};
+			owner.addEventListener("reset", onReset);
+			onCleanup(() => owner.removeEventListener("reset", onReset));
+		}, {
+			flush: "post",
+			immediate: true
+		});
+		function defaultFieldLabel(index, count) {
+			return `Character ${index + 1} of ${count}`;
+		}
+		pinInputContext.provide({
+			baseId,
+			characters,
+			length: fieldCount,
+			type: computed(() => __props.type),
+			mask: computed(() => __props.mask),
+			otp: computed(() => __props.otp),
+			disabled: computed(() => __props.disabled),
+			required: computed(() => __props.required),
+			complete,
+			placeholder: computed(() => __props.placeholder),
+			ariaDescribedby: computed(() => __props.ariaDescribedby),
+			ariaInvalid: ariaInvalidValue,
+			ariaErrormessage: computed(() => __props.ariaErrormessage),
+			fieldLabel: (index) => (__props.getFieldLabel ?? defaultFieldLabel)(index, fieldCount.value),
+			registerField: (index, element) => {
+				if (element === null) fields.delete(index);
+				else fields.set(index, element);
+			},
+			focusField,
+			write,
+			remove
+		});
+		const slotState = computed(() => ({
+			value: value.value,
+			length: fieldCount.value,
+			indexes: indexes.value,
+			complete: complete.value,
+			disabled: __props.disabled,
+			state: dataState.value
+		}));
+		function field(key) {
+			return computed(() => slotState.value[key]);
+		}
+		__expose({
+			value: field("value"),
+			length: field("length"),
+			indexes: field("indexes"),
+			complete: field("complete"),
+			disabled: field("disabled"),
+			state: field("state"),
+			root,
+			focus: (index) => focusField(index ?? Math.min(characters.value.length, fieldCount.value - 1)),
+			setValue: (next) => commit(sanitize(next)),
+			clear: () => commit("")
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "root",
+				ref: root,
+				role: "group",
+				"aria-label": __props.ariaLabel,
+				"aria-labelledby": __props.ariaLabelledby,
+				part: "root",
+				"data-vize-ui": "pin-input",
+				"data-state": dataState.value,
+				"data-complete": complete.value ? "true" : "false",
+				"data-disabled": __props.disabled ? "true" : void 0,
+				"data-invalid": ariaInvalidValue.value === void 0 ? void 0 : "true"
+			}, [__props.name !== void 0 ? (openBlock(), createElementBlock("input", {
+				key: 0,
+				type: "hidden",
+				name: __props.name,
+				form: __props.form,
+				value: unref(value),
+				disabled: __props.disabled,
+				"data-vize-ui": "pin-input-value"
+			}, null, 8, _hoisted_2)) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)], 8, _hoisted_1$1);
+		};
+	}
+}), [["__scopeId", "data-v-a5834c6a"]]);
+//#endregion
+//#region src/families/form/pin-input/pin-input-field.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"type",
+	"value",
+	"inputmode",
+	"autocomplete",
+	"placeholder",
+	"disabled",
+	"required",
+	"aria-label",
+	"aria-describedby",
+	"aria-invalid",
+	"aria-errormessage",
+	"data-index",
+	"data-filled"
+];
+//#endregion
+//#region src/families/form/pin-input/pin-input-field.vue
+var pin_input_field_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "pin-input-field",
+	props: {
+		index: {
+			type: Number,
+			required: true
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props) {
+		const context = pinInputContext.use();
+		const element = useTemplateRef("element");
+		const character = computed(() => context.characters.value[__props.index] ?? "");
+		const filled = computed(() => character.value.length > 0);
+		const autocomplete = computed(() => context.otp.value && __props.index === 0 ? "one-time-code" : "off");
+		watch(element, (input) => context.registerField(__props.index, input), {
+			flush: "sync",
+			immediate: true
+		});
+		onScopeDispose(() => context.registerField(__props.index, null));
+		function syncNativeValue() {
+			if (element.value !== null && element.value.value !== character.value) element.value.value = character.value;
+		}
+		function onInput(event) {
+			if (!(event.currentTarget instanceof HTMLInputElement)) return;
+			const text = event.currentTarget.value;
+			const typed = text.startsWith(character.value) && text.length > character.value.length ? text.slice(character.value.length) : text;
+			const next = typed.length === 0 ? __props.index : context.write(__props.index, typed);
+			queueMicrotask(() => {
+				syncNativeValue();
+				if (typed.length > 0) context.focusField(next);
+			});
+		}
+		function onPaste(event) {
+			const text = event.clipboardData?.getData("text") ?? "";
+			if (text.length === 0) return;
+			event.preventDefault();
+			const next = context.write(__props.index, text);
+			queueMicrotask(() => context.focusField(next));
+		}
+		function onKeydown(event) {
+			if (event.altKey || event.metaKey || event.ctrlKey || event.isComposing) return;
+			const key = event.key;
+			let target;
+			if (key === "Backspace") target = context.remove(__props.index, "backward");
+			else if (key === "Delete") target = context.remove(__props.index, "forward");
+			else if (key === "ArrowLeft") target = __props.index - 1;
+			else if (key === "ArrowRight") target = __props.index + 1;
+			else if (key === "Home") target = 0;
+			else if (key === "End") target = Math.min(context.characters.value.length, context.length.value - 1);
+			if (target === void 0) return;
+			event.preventDefault();
+			const focusTarget = target;
+			queueMicrotask(() => {
+				syncNativeValue();
+				context.focusField(focusTarget);
+			});
+		}
+		function onFocus(event) {
+			if (event.currentTarget instanceof HTMLInputElement) event.currentTarget.select();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("input", {
+				id: `${unref(context).baseId.value}-${__props.index}`,
+				ref_key: "element",
+				ref: element,
+				type: unref(context).mask.value ? "password" : "text",
+				value: character.value,
+				inputmode: unref(context).type.value === "numeric" ? "numeric" : "text",
+				autocomplete: autocomplete.value,
+				autocapitalize: "off",
+				autocorrect: "off",
+				spellcheck: "false",
+				placeholder: unref(context).placeholder.value,
+				disabled: unref(context).disabled.value,
+				required: unref(context).required.value && !unref(context).complete.value,
+				"aria-label": __props.ariaLabel ?? unref(context).fieldLabel(__props.index),
+				"aria-describedby": unref(context).ariaDescribedby.value,
+				"aria-invalid": unref(context).ariaInvalid.value,
+				"aria-errormessage": unref(context).ariaInvalid.value === void 0 ? void 0 : unref(context).ariaErrormessage.value,
+				part: "field",
+				"data-vize-ui": "pin-input-field",
+				"data-index": __props.index,
+				"data-filled": filled.value ? "true" : "false",
+				onInput,
+				onPaste,
+				onKeydown,
+				onFocus
+			}, null, 40, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-bfbd148a"]]);
+//#endregion
+export { removePinCharacter as a, writePinCharacters as c, normalizePinLength as i, pin_input_default as n, sanitizePinInput as o, isPinCharacters as r, splitPinCharacters as s, pin_input_field_default as t };

package/dist/pin-input.d.mts

@@ -0,0 +1,2 @@
+import { a as splitPinCharacters, c as _default, d as PinInputExpose, f as PinInputSlotState, i as sanitizePinInput, l as PinInputAriaInvalid, m as PinInputType, n as normalizePinLength, o as writePinCharacters, p as PinInputState, r as removePinCharacter, s as _default$1, t as isPinCharacters, u as PinInputCharacters } from "./pin-input-Dci-Z7uY.mjs";
+export { _default as PinInput, type PinInputAriaInvalid, type PinInputCharacters, type PinInputExpose, _default$1 as PinInputField, type PinInputSlotState, type PinInputState, type PinInputType, isPinCharacters, normalizePinLength, removePinCharacter, sanitizePinInput, splitPinCharacters, writePinCharacters };

package/dist/pin-input.mjs

@@ -0,0 +1,2 @@
+import { a as removePinCharacter, c as writePinCharacters, i as normalizePinLength, n as pin_input_default, o as sanitizePinInput, r as isPinCharacters, s as splitPinCharacters, t as pin_input_field_default } from "./pin-input-oMrddl8G.mjs";
+export { pin_input_default as PinInput, pin_input_field_default as PinInputField, isPinCharacters, normalizePinLength, removePinCharacter, sanitizePinInput, splitPinCharacters, writePinCharacters };

package/dist/plain-date-By3bTWQG.d.mts

@@ -0,0 +1,143 @@
+//#region src/families/date-time/calendar/plain-date.d.ts
+/**
+ * Timezone-free ISO calendar date model shared by the date-time family.
+ *
+ * Every value is a plain `{ year, month, day }` record in the proleptic
+ * Gregorian (ISO 8601) calendar. Arithmetic runs on integer epoch days, so no
+ * operation ever constructs a `Date` in the host time zone and results are
+ * identical on the server, in every browser, and across daylight-saving
+ * transitions. `Temporal.PlainDate` instances (ISO calendar) satisfy
+ * {@link PlainDate} structurally and are accepted wherever a date is read.
+ */
+/** A calendar date without time or time zone, in the ISO 8601 calendar. */
+interface PlainDate {
+  /** ISO year. Year `0` is 1 BCE; negative years are supported. */
+  readonly year: number;
+  /** ISO month from `1` (January) through `12` (December). */
+  readonly month: number;
+  /** Day of month from `1` through the month length. */
+  readonly day: number;
+}
+/** A calendar month without a day, in the ISO 8601 calendar. */
+interface PlainYearMonth {
+  /** ISO year. */
+  readonly year: number;
+  /** ISO month from `1` through `12`. */
+  readonly month: number;
+}
+/** An inclusive date range whose `start` is never after its `end`. */
+interface DateRange {
+  /** First selected date, inclusive. */
+  readonly start: PlainDate;
+  /** Last selected date, inclusive. */
+  readonly end: PlainDate;
+}
+/** Predicate that marks individual dates, for example unavailable dates. */
+type DateMatcher = (date: PlainDate) => boolean;
+/** Day of week where `0` is Sunday and `6` is Saturday. */
+type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** Result of {@link compareDates}. */
+type DateOrder = -1 | 0 | 1;
+/** Smallest year accepted by the model; matches the ECMAScript `Date` range. */
+declare const PLAIN_DATE_MIN_YEAR = -271820;
+/** Largest year accepted by the model; matches the ECMAScript `Date` range. */
+declare const PLAIN_DATE_MAX_YEAR = 275759;
+/** Whether `year` is a Gregorian leap year. */
+declare function isLeapYear(year: number): boolean;
+/** Number of days in the given ISO month, or `0` when the month is invalid. */
+declare function daysInMonth(year: number, month: number): number;
+/** Whether a value is a structurally valid ISO date inside the supported year range. */
+declare function isValidPlainDate(value: unknown): value is PlainDate;
+/**
+ * Create a frozen {@link PlainDate}.
+ *
+ * @throws `RangeError` tagged `VIZE_UI_PLAIN_DATE_INVALID` for impossible dates.
+ */
+declare function createPlainDate(year: number, month: number, day: number): PlainDate;
+/**
+ * Copy any `{ year, month, day }` record, including `Temporal.PlainDate`, into
+ * a frozen {@link PlainDate}. Invalid, missing, or out-of-range input returns `null`.
+ */
+declare function normalizePlainDate(value: PlainDate | null | undefined): PlainDate | null;
+/** Convert a date to days since 1970-01-01 (negative before the epoch). */
+declare function toEpochDay(date: PlainDate): number;
+/** Convert days since 1970-01-01 back into a frozen {@link PlainDate}. */
+declare function fromEpochDay(epochDay: number): PlainDate;
+/** Order two dates chronologically. */
+declare function compareDates(left: PlainDate, right: PlainDate): DateOrder;
+/** Whether two nullable dates denote the same day. */
+declare function isSameDay(left: PlainDate | null | undefined, right: PlainDate | null | undefined): boolean;
+/** Whether two dates fall in the same ISO month. */
+declare function isSameMonth(left: PlainYearMonth, right: PlainYearMonth): boolean;
+/** Add a signed number of days. */
+declare function addDays(date: PlainDate, days: number): PlainDate;
+/** Add a signed number of months, clamping the day to the target month length. */
+declare function addMonths(date: PlainDate, months: number): PlainDate;
+/** Add a signed number of years, clamping February 29 in non-leap years. */
+declare function addYears(date: PlainDate, years: number): PlainDate;
+/** Shift a year-month by a signed number of months. */
+declare function shiftYearMonth(value: PlainYearMonth, months: number): PlainYearMonth;
+/** Signed number of whole months from `from` to `to`. */
+declare function monthsBetween(from: PlainYearMonth, to: PlainYearMonth): number;
+/** Signed number of days from `from` to `to`. */
+declare function daysBetween(from: PlainDate, to: PlainDate): number;
+/** Day of week, where `0` is Sunday. */
+declare function dayOfWeek(date: PlainDate): Weekday;
+/** First date of the week containing `date` for a locale week start. */
+declare function startOfWeek(date: PlainDate, weekStartsOn: Weekday): PlainDate;
+/** Last date of the week containing `date` for a locale week start. */
+declare function endOfWeek(date: PlainDate, weekStartsOn: Weekday): PlainDate;
+/** First day of the month containing `value`. */
+declare function startOfMonth(value: PlainYearMonth): PlainDate;
+/** Last day of the month containing `value`. */
+declare function endOfMonth(value: PlainYearMonth): PlainDate;
+/** Year-month that contains `date`. */
+declare function toYearMonth(date: PlainYearMonth): PlainYearMonth;
+/** Clamp a date into an optional inclusive `[min, max]` window. */
+declare function clampDate(date: PlainDate, min: PlainDate | null | undefined, max: PlainDate | null | undefined): PlainDate;
+/** Whether a date is inside an optional inclusive `[min, max]` window. */
+declare function isDateWithin(date: PlainDate, min: PlainDate | null | undefined, max: PlainDate | null | undefined): boolean;
+/** Order two dates into a frozen {@link DateRange}. */
+declare function createDateRange(first: PlainDate, second: PlainDate): DateRange;
+/** Copy and order a `{ start, end }` record; invalid input returns `null`. */
+declare function normalizeDateRange(value: DateRange | null | undefined): DateRange | null;
+/** Whether `date` lies inside an inclusive range. */
+declare function isDateInRange(date: PlainDate, range: DateRange | null | undefined): boolean;
+/** Whether two nullable ranges cover the same days. */
+declare function isSameRange(left: DateRange | null | undefined, right: DateRange | null | undefined): boolean;
+/** Format an ISO 8601 calendar date such as `2026-09-25` (extended years use `±YYYYYY`). */
+declare function formatIsoDate(date: PlainDate): string;
+/** Parse an ISO 8601 calendar date. Anything else, including impossible dates, returns `null`. */
+declare function parseIsoDate(value: string): PlainDate | null;
+/** Read the calendar fields of a `Date` in the host's local time zone. */
+declare function fromLocalDate(date: Date): PlainDate | null;
+/** Read the calendar fields of a `Date` in UTC. */
+declare function fromUtcDate(date: Date): PlainDate | null;
+/** Create a `Date` at local midnight of `date` in the host time zone. */
+declare function toLocalDate(date: PlainDate): Date;
+/** Create a `Date` at UTC midnight of `date`; formatting it with `timeZone: "UTC"` is stable everywhere. */
+declare function toUtcDate(date: PlainDate): Date;
+/**
+ * Calendar date of an instant in an IANA time zone.
+ *
+ * This is the only operation that depends on a clock value; callers own
+ * where the epoch milliseconds come from. Unknown time zones return `null`.
+ */
+declare function fromEpochMilliseconds(epochMilliseconds: number, timeZone: string): PlainDate | null;
+/** ISO 8601 week-numbering year and week (`1`–`53`). */
+interface IsoWeek {
+  /** ISO week-numbering year, which can differ from the calendar year near January 1. */
+  readonly year: number;
+  /** Week number from `1` through `53`. */
+  readonly week: number;
+}
+/** ISO 8601 week containing `date` (weeks start on Monday; week 1 holds the first Thursday). */
+declare function isoWeekOf(date: PlainDate): IsoWeek;
+/** Monday that starts an ISO week, or `null` for weeks that do not exist in that year. */
+declare function startOfIsoWeek(value: IsoWeek): PlainDate | null;
+/** Format `YYYY-Www` (HTML `week` input value). */
+declare function formatIsoWeek(value: IsoWeek): string;
+/** Parse `YYYY-Www`; anything else, including week 53 in 52-week years, returns `null`. */
+declare function parseIsoWeek(value: string): IsoWeek | null;
+//#endregion
+export { isLeapYear as A, parseIsoWeek as B, formatIsoWeek as C, fromUtcDate as D, fromLocalDate as E, isoWeekOf as F, toEpochDay as G, startOfIsoWeek as H, monthsBetween as I, toYearMonth as J, toLocalDate as K, normalizeDateRange as L, isSameMonth as M, isSameRange as N, isDateInRange as O, isValidPlainDate as P, normalizePlainDate as R, formatIsoDate as S, fromEpochMilliseconds as T, startOfMonth as U, shiftYearMonth as V, startOfWeek as W, dayOfWeek as _, PLAIN_DATE_MAX_YEAR as a, endOfMonth as b, PlainYearMonth as c, addMonths as d, addYears as f, createPlainDate as g, createDateRange as h, IsoWeek as i, isSameDay as j, isDateWithin as k, Weekday as l, compareDates as m, DateOrder as n, PLAIN_DATE_MIN_YEAR as o, clampDate as p, toUtcDate as q, DateRange as r, PlainDate as s, DateMatcher as t, addDays as u, daysBetween as v, fromEpochDay as w, endOfWeek as x, daysInMonth as y, parseIsoDate as z };