@nepdatejs/vanilla 0.0.0-stage → 0.1.1

package/dist/date-picker-DyvpYe29.d.ts

@@ -0,0 +1,74 @@
+import { i as DatePickerViewOptions, n as RichProps, r as DatePickerView, t as Base } from "./element-utils-C-r5gPlk.js";
+import { DatePickerState, SinglePreset } from "@nepdatejs/datepicker";
+//#region src/date-picker-element.d.ts
+/**
+ * <nep-date-picker name="dob" min="2020-01-01"></nep-date-picker>
+ *
+ * A form-associated BS/AD date field: the form receives the AD "YYYY-MM-DD"
+ * value under `name`. Fires `change` with { value, ad, bs }, plus `nep-open`,
+ * `nep-close` and `nep-calendar-change`.
+ */
+declare class NepDatePickerElement extends Base {
+  static readonly formAssociated = true;
+  static readonly observedAttributes: readonly string[];
+  /** The view, once connected. */
+  view: DatePickerView | null;
+  private readonly internals;
+  private rich;
+  private customPresets;
+  private unsubscribe;
+  constructor();
+  get value(): string;
+  set value(next: string);
+  get holidays(): RichProps["holidays"];
+  set holidays(next: RichProps["holidays"]);
+  get events(): RichProps["events"];
+  set events(next: RichProps["events"]);
+  get isDateDisabled(): RichProps["isDateDisabled"];
+  set isDateDisabled(next: RichProps["isDateDisabled"]);
+  /** Shortcuts, including custom { id, label, resolve } ones. Overrides the presets attribute. */
+  get presets(): readonly SinglePreset[] | undefined;
+  set presets(next: readonly SinglePreset[] | undefined);
+  get form(): HTMLFormElement | null;
+  get validity(): ValidityState | undefined;
+  get validationMessage(): string;
+  checkValidity(): boolean;
+  reportValidity(): boolean;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(name: string, previous: string | null, next: string | null): void;
+  formResetCallback(): void;
+  formDisabledCallback(disabled: boolean): void;
+  formStateRestoreCallback(state: string | File | FormData | null): void;
+  override focus(options?: FocusOptions): void;
+  open(): void;
+  close(): void;
+  private setRich;
+  private readOptions;
+  private syncForm;
+}
+//#endregion
+//#region src/date-picker.d.ts
+/** Register <nep-date-picker> (skipped if already defined). */
+declare function defineDatePicker(registry?: CustomElementRegistry): void;
+interface DatePickerHandle {
+  readonly view: DatePickerView;
+  getValue(): string;
+  getState(): DatePickerState;
+  setValue(value: string): void;
+  setOptions(changes: Partial<DatePickerViewOptions>): void;
+  open(): void;
+  close(): void;
+  destroy(): void;
+}
+/**
+ * Mount a date picker without custom elements.
+ *
+ * - Given a container, renders the field into it.
+ * - Given an <input>, hides it and keeps its value in step with the picker
+ *   (AD "YYYY-MM-DD"), so existing forms and server code keep working.
+ */
+declare function createDatePicker$1(target: HTMLElement, options?: DatePickerViewOptions): DatePickerHandle;
+//#endregion
+export { NepDatePickerElement as i, createDatePicker$1 as n, defineDatePicker as r, DatePickerHandle as t };
+//# sourceMappingURL=date-picker-DyvpYe29.d.ts.map

package/dist/date-picker.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_date_picker = require("./date-picker-CgjYsf1w.cjs");
+exports.DatePickerView = require_date_picker.DatePickerView;
+exports.NepDatePickerElement = require_date_picker.NepDatePickerElement;
+exports.createDatePicker = require_date_picker.createDatePicker;
+exports.defineDatePicker = require_date_picker.defineDatePicker;

package/dist/date-picker.d.cts

@@ -0,0 +1,3 @@
+import { a as Theme, i as DatePickerViewOptions, r as DatePickerView } from "./element-utils-BVye8UQq.cjs";
+import { i as NepDatePickerElement, n as createDatePicker, r as defineDatePicker, t as DatePickerHandle } from "./date-picker-BidCGOz0.cjs";
+export { DatePickerHandle, DatePickerView, type DatePickerViewOptions, NepDatePickerElement, type Theme, createDatePicker, defineDatePicker };

package/dist/date-picker.d.ts

@@ -0,0 +1,3 @@
+import { a as Theme, i as DatePickerViewOptions, r as DatePickerView } from "./element-utils-C-r5gPlk.js";
+import { i as NepDatePickerElement, n as createDatePicker, r as defineDatePicker, t as DatePickerHandle } from "./date-picker-DyvpYe29.js";
+export { DatePickerHandle, DatePickerView, type DatePickerViewOptions, NepDatePickerElement, type Theme, createDatePicker, defineDatePicker };

package/dist/date-picker.js

@@ -0,0 +1 @@
+export { i as DatePickerView, r as NepDatePickerElement, t as createDatePicker, n as defineDatePicker } from "./date-picker-BwlrlU5Y.js";

package/dist/date-range-picker-D3eNvlgv.d.ts

@@ -0,0 +1,98 @@
+import { a as Theme, n as RichProps, t as Base } from "./element-utils-C-r5gPlk.js";
+import { DateRangePickerOptions, DateRangePickerState, DateRangePickerStore, RangeField, RangePreset } from "@nepdatejs/datepicker";
+import { PanelLayout } from "@nepdatejs/dom";
+//#region src/range-view.d.ts
+interface DateRangePickerViewOptions extends DateRangePickerOptions {
+  /** Field names for plain form posts; hidden inputs are rendered when set. */
+  readonly startName?: string | undefined;
+  readonly endName?: string | undefined;
+  readonly hiddenInput?: boolean | undefined;
+  readonly disabled?: boolean | undefined;
+  readonly required?: boolean | undefined;
+  /** 'sheet' opens a bottom sheet; 'popover' sits beside the field; 'auto' (default) uses the sheet below 480px. */
+  readonly panelLayout?: PanelLayout | undefined;
+  readonly theme?: Theme | undefined;
+  readonly startLabel?: string | undefined;
+  readonly endLabel?: string | undefined;
+  /** Show a "Fiscal year" button that switches the panel to fiscal-year tiles. */
+  readonly fiscalYearView?: boolean | undefined;
+  readonly onOpenChange?: ((open: boolean) => void) | undefined;
+}
+/** Two date fields (start, end) sharing one panel calendar in range mode. */
+declare class DateRangePickerView {
+  readonly store: DateRangePickerStore;
+  readonly inputs: Record<RangeField, HTMLInputElement>;
+  private options;
+  private readonly field;
+  private readonly boxes;
+  private readonly toggleButton;
+  private readonly hint;
+  private readonly panel;
+  private readonly segment;
+  private readonly fiscalButton;
+  private readonly footer;
+  private readonly hidden;
+  private readonly calendarView;
+  private readonly presetList;
+  private readonly unsubscribe;
+  private closePanel;
+  private wasOpen;
+  constructor(host: HTMLElement, options?: DateRangePickerViewOptions);
+  getState(): DateRangePickerState;
+  setOptions(changes: Partial<DateRangePickerViewOptions>): void;
+  open(): void;
+  close(): void;
+  destroy(): void;
+  private render;
+  private panelWidth;
+  private syncPanel;
+  private readonly onClick;
+}
+//#endregion
+//#region src/date-range-picker-element.d.ts
+/**
+ * <nep-date-range-picker name="leave" min-days="1"></nep-date-range-picker>
+ *
+ * Two BS/AD fields sharing one panel. The form receives `${name}-start` and
+ * `${name}-end` (or `start-name` / `end-name`). Fires `change` with { value }.
+ */
+declare class NepDateRangePickerElement extends Base {
+  static readonly formAssociated = true;
+  static readonly observedAttributes: readonly string[];
+  view: DateRangePickerView | null;
+  private readonly internals;
+  private rich;
+  private customPresets;
+  private unsubscribe;
+  constructor();
+  get value(): {
+    start: string;
+    end: string;
+  };
+  set value(next: {
+    start: string;
+    end: string;
+  });
+  set holidays(next: RichProps["holidays"]);
+  set isDateDisabled(next: RichProps["isDateDisabled"]);
+  /** Shortcuts, including custom { id, label, resolve } ones. Overrides the presets attribute. */
+  get presets(): readonly RangePreset[] | undefined;
+  set presets(next: readonly RangePreset[] | undefined);
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(): void;
+  formResetCallback(): void;
+  formDisabledCallback(disabled: boolean): void;
+  private names;
+  private readOptions;
+  private syncForm;
+}
+//#endregion
+//#region src/date-range-picker.d.ts
+/** Register <nep-date-range-picker> (skipped if already defined). */
+declare function defineDateRangePicker(registry?: CustomElementRegistry): void;
+/** Mount a date range picker into a container. */
+declare function createDateRangePicker$1(container: HTMLElement, options?: DateRangePickerViewOptions): DateRangePickerView;
+//#endregion
+export { DateRangePickerViewOptions as a, DateRangePickerView as i, defineDateRangePicker as n, NepDateRangePickerElement as r, createDateRangePicker$1 as t };
+//# sourceMappingURL=date-range-picker-D3eNvlgv.d.ts.map

package/dist/date-range-picker-NwetXUC-.js

@@ -0,0 +1,449 @@
+import { _ as icon, a as calendarAttr, b as setText, c as onUnlessFalse, d as str, f as swallowInnerChange, g as el, h as CalendarView, i as bool, l as panelLayout, n as defineElement, o as int, p as theme, r as Base, t as ELEMENT_NAMES, u as presetIds, v as setAttrs, x as uid, y as setPopupMode } from "./registry-BvkGnkvV.js";
+import { n as openPanel, r as renderSegment, t as PresetList } from "./preset-list-DmE6fJjr.js";
+import { getLocale } from "@nepdatejs/core";
+import { createDateRangePicker } from "@nepdatejs/datepicker";
+import { restoreFocus } from "@nepdatejs/dom";
+//#region src/range-view.ts
+const VIEW_KEYS = /* @__PURE__ */ new Set([
+	"startName",
+	"endName",
+	"hiddenInput",
+	"disabled",
+	"required",
+	"theme",
+	"panelLayout",
+	"startLabel",
+	"endLabel",
+	"fiscalYearView",
+	"onOpenChange",
+	"onChange",
+	"onCalendarChange"
+]);
+/** Two date fields (start, end) sharing one panel calendar in range mode. */
+var DateRangePickerView = class {
+	constructor(host, options = {}) {
+		this.closePanel = null;
+		this.wasOpen = false;
+		this.onClick = (event) => {
+			const target = event.target instanceof Element ? event.target : null;
+			if (!target || this.calendarView.element.contains(target)) return;
+			const calendar = target.closest("[data-calendar]")?.dataset["calendar"];
+			if (calendar === "BS" || calendar === "AD") {
+				this.store.actions.switchCalendar(calendar);
+				return;
+			}
+			if (target.closest("[data-action=\"fiscal\"]")) {
+				const calendar = this.store.calendar;
+				calendar.actions.setView(calendar.getState().view === "fiscal" ? "day" : "fiscal");
+				this.calendarView.focusGrid();
+				return;
+			}
+			if (target.closest("[data-action=\"toggle\"]")) {
+				if (this.store.getState().open) this.close();
+				else this.open();
+			}
+		};
+		this.options = { ...options };
+		this.store = createDateRangePicker({
+			...storeOptions(options),
+			onChange: (value, detail) => {
+				this.options.onChange?.(value, detail);
+			},
+			onCalendarChange: (calendar) => {
+				this.options.onCalendarChange?.(calendar);
+			}
+		});
+		const id = uid("ndp-range");
+		const makeInput = (field) => {
+			const input = el("input", {
+				class: "ndp-input__control",
+				id: `${id}-${field}`,
+				type: "text",
+				inputmode: "numeric",
+				autocomplete: "off",
+				"aria-controls": `${id}-panel`,
+				"data-field": field
+			});
+			input.addEventListener("input", () => {
+				this.store.actions.type(field, input.value);
+			});
+			input.addEventListener("blur", () => {
+				this.store.actions.blur(field);
+			});
+			input.addEventListener("keydown", (event) => {
+				if (event.key === "ArrowDown" && (event.altKey || input.value === "")) {
+					event.preventDefault();
+					this.open();
+				}
+			});
+			return input;
+		};
+		this.inputs = {
+			start: makeInput("start"),
+			end: makeInput("end")
+		};
+		this.toggleButton = el("button", {
+			type: "button",
+			class: "ndp-icon-button",
+			"data-action": "toggle"
+		}, [icon("calendar")]);
+		this.boxes = {
+			start: el("div", { class: "ndp-input" }, [this.inputs.start]),
+			end: el("div", { class: "ndp-input" }, [this.inputs.end, el("span", { class: "ndp-input__actions" }, [this.toggleButton])])
+		};
+		this.hint = el("p", {
+			class: "ndp-hint",
+			id: `${id}-hint`,
+			"aria-live": "polite",
+			hidden: true
+		});
+		this.hidden = {
+			start: el("input", { type: "hidden" }),
+			end: el("input", { type: "hidden" })
+		};
+		this.segment = el("div", {
+			class: "ndp-segment",
+			role: "group"
+		}, [el("button", {
+			type: "button",
+			class: "ndp-segment__item",
+			"data-calendar": "BS"
+		}), el("button", {
+			type: "button",
+			class: "ndp-segment__item",
+			"data-calendar": "AD"
+		})]);
+		this.fiscalButton = el("button", {
+			type: "button",
+			class: "ndp-button",
+			"data-action": "fiscal"
+		});
+		this.footer = el("div", { class: "ndp-panel__footer" }, [this.segment, this.fiscalButton]);
+		const calendarRoot = el("div", { class: "ndp-panel__calendar" });
+		this.presetList = new PresetList((id) => {
+			if (this.store.actions.applyPreset(id) && !this.store.getState().open) restoreFocus(this.inputs.start);
+		});
+		this.panel = el("div", {
+			class: "ndp-panel",
+			id: `${id}-panel`,
+			hidden: true
+		}, [el("div", { class: "ndp-panel__body" }, [this.presetList.element, calendarRoot]), this.footer]);
+		const row = el("div", { class: "ndp-range" }, [
+			this.boxes.start,
+			el("span", {
+				class: "ndp-range__separator",
+				"aria-hidden": "true"
+			}, ["→"]),
+			this.boxes.end
+		]);
+		this.field = el("div", { class: "ndp-field" }, [
+			row,
+			this.hint,
+			this.panel,
+			this.hidden.start,
+			this.hidden.end
+		]);
+		host.append(this.field);
+		this.calendarView = new CalendarView(calendarRoot, this.store.calendar, {
+			locale: () => this.options.locale,
+			onDayActivate: (date) => {
+				if (this.store.actions.select(date) && !this.store.getState().open) restoreFocus(this.inputs.end);
+			}
+		});
+		this.field.addEventListener("click", this.onClick);
+		this.unsubscribe = this.store.subscribe(() => {
+			this.render();
+		});
+		this.render();
+	}
+	getState() {
+		return this.store.getState();
+	}
+	setOptions(changes) {
+		this.options = {
+			...this.options,
+			...changes
+		};
+		const forStore = storeOptions(changes);
+		if (Object.keys(forStore).length > 0) this.store.setOptions(forStore);
+		else this.render();
+	}
+	open() {
+		if (!this.options.disabled) this.store.actions.open();
+	}
+	close() {
+		this.store.actions.close();
+	}
+	destroy() {
+		this.closePanel?.();
+		this.unsubscribe();
+		this.calendarView.destroy();
+		this.field.remove();
+	}
+	render() {
+		const state = this.store.getState();
+		const locale = getLocale(this.options.locale);
+		const disabled = this.options.disabled ?? false;
+		const hintText = state.error?.message ?? null;
+		const texts = {
+			start: state.startText,
+			end: state.endText
+		};
+		const labels = {
+			start: this.options.startLabel,
+			end: this.options.endLabel
+		};
+		for (const field of ["start", "end"]) {
+			const input = this.inputs[field];
+			if (input.value !== texts[field]) input.value = texts[field];
+			const error = state.error;
+			const fieldError = error !== null && (error.field === field || error.field === "range");
+			input.setCustomValidity(fieldError ? error.message : "");
+			setAttrs(input, {
+				placeholder: state.placeholder,
+				disabled,
+				required: this.options.required ?? false,
+				"aria-label": labels[field] ?? null,
+				"aria-invalid": fieldError ? "true" : null,
+				"aria-describedby": hintText ? this.hint.id : null
+			});
+			setAttrs(this.boxes[field], {
+				"data-invalid": fieldError,
+				"data-disabled": disabled
+			});
+			const name = this.options.hiddenInput === false ? void 0 : field === "start" ? this.options.startName : this.options.endName;
+			setAttrs(this.hidden[field], { name: name ?? null });
+			this.hidden[field].value = state.value[field];
+			this.hidden[field].disabled = name === void 0 || disabled;
+		}
+		setAttrs(this.field, { "data-ndp-theme": this.options.theme ?? null });
+		setAttrs(this.panel, {
+			"data-ndp-theme": this.options.theme ?? null,
+			"aria-label": locale.labels.chooseDate
+		});
+		setAttrs(this.toggleButton, {
+			disabled,
+			"aria-label": locale.labels.openCalendar,
+			"aria-expanded": state.open ? "true" : "false"
+		});
+		this.hint.hidden = hintText === null;
+		setText(this.hint, hintText ?? "");
+		setAttrs(this.hint, { "data-error": hintText !== null });
+		renderSegment(this.segment, state, locale);
+		this.presetList.render(state.presets, locale.labels.presets);
+		const fiscal = this.options.fiscalYearView ?? false;
+		this.fiscalButton.hidden = !fiscal;
+		setText(this.fiscalButton, locale.labels.fiscalYear);
+		setAttrs(this.fiscalButton, { "aria-pressed": state.calendarState.view === "fiscal" ? "true" : "false" });
+		this.footer.hidden = !fiscal && !state.canSwitchCalendar;
+		setPopupMode(state, [this.inputs.start, this.inputs.end], this.toggleButton, this.panel);
+		this.syncPanel(state.open && !state.inline);
+		this.panel.hidden = !state.inline && !this.wasOpen;
+		this.panel.style.setProperty("--ndp-panel-width", state.inline ? `${String(this.panelWidth())}px` : null);
+	}
+	panelWidth() {
+		return this.store.getState().presets.length > 0 ? 492 : 320;
+	}
+	syncPanel(open) {
+		if (open === this.wasOpen) return;
+		this.wasOpen = open;
+		this.options.onOpenChange?.(open);
+		if (open) {
+			const anchor = this.field.querySelector(".ndp-range") ?? this.field;
+			this.closePanel = openPanel({
+				panel: this.panel,
+				anchor,
+				inside: [this.field],
+				width: this.panelWidth(),
+				layout: this.options.panelLayout,
+				close: () => {
+					this.store.actions.close();
+				},
+				returnFocus: this.inputs.start
+			});
+			this.calendarView.focusGrid();
+		} else {
+			this.closePanel?.();
+			this.closePanel = null;
+		}
+	}
+};
+function storeOptions(options) {
+	const out = {};
+	for (const [key, value] of Object.entries(options)) if (!VIEW_KEYS.has(key)) out[key] = value;
+	return out;
+}
+//#endregion
+//#region src/date-range-picker-element.ts
+/**
+* <nep-date-range-picker name="leave" min-days="1"></nep-date-range-picker>
+*
+* Two BS/AD fields sharing one panel. The form receives `${name}-start` and
+* `${name}-end` (or `start-name` / `end-name`). Fires `change` with { value }.
+*/
+var NepDateRangePickerElement = class extends Base {
+	constructor() {
+		super();
+		this.view = null;
+		this.rich = {};
+		this.unsubscribe = null;
+		this.internals = typeof this.attachInternals === "function" ? this.attachInternals() : null;
+		swallowInnerChange(this);
+	}
+	get value() {
+		return this.view?.getState().value ?? {
+			start: "",
+			end: ""
+		};
+	}
+	set value(next) {
+		this.view?.store.actions.setValue(next);
+	}
+	set holidays(next) {
+		this.rich = {
+			...this.rich,
+			holidays: next
+		};
+		this.view?.setOptions({ holidays: next });
+	}
+	set isDateDisabled(next) {
+		this.rich = {
+			...this.rich,
+			isDateDisabled: next
+		};
+		this.view?.setOptions({ isDateDisabled: next });
+	}
+	/** Shortcuts, including custom { id, label, resolve } ones. Overrides the presets attribute. */
+	get presets() {
+		return this.customPresets ?? presetIds(this);
+	}
+	set presets(next) {
+		this.customPresets = next;
+		this.view?.setOptions({ presets: this.presets });
+	}
+	connectedCallback() {
+		if (this.view) return;
+		const view = new DateRangePickerView(this, {
+			...this.readOptions(),
+			defaultValue: {
+				start: str(this, "start") ?? "",
+				end: str(this, "end") ?? ""
+			},
+			onChange: (value) => {
+				this.dispatchEvent(new CustomEvent("change", {
+					bubbles: true,
+					detail: { value }
+				}));
+			},
+			onOpenChange: (open) => {
+				this.dispatchEvent(new CustomEvent(open ? "nep-open" : "nep-close", { bubbles: true }));
+			}
+		});
+		this.view = view;
+		this.unsubscribe = view.store.subscribe(() => {
+			this.syncForm();
+		});
+		this.syncForm();
+	}
+	disconnectedCallback() {
+		this.unsubscribe?.();
+		this.view?.destroy();
+		this.view = null;
+	}
+	attributeChangedCallback() {
+		this.view?.setOptions(this.readOptions());
+		this.syncForm();
+	}
+	formResetCallback() {
+		this.view?.store.actions.reset();
+	}
+	formDisabledCallback(disabled) {
+		this.view?.setOptions({ disabled: disabled || bool(this, "disabled") });
+	}
+	names() {
+		const name = str(this, "name");
+		return {
+			start: str(this, "start-name") ?? (name ? `${name}-start` : void 0),
+			end: str(this, "end-name") ?? (name ? `${name}-end` : void 0)
+		};
+	}
+	readOptions() {
+		const names = this.names();
+		return {
+			...this.rich,
+			startName: names.start,
+			endName: names.end,
+			hiddenInput: this.internals === null,
+			min: str(this, "min"),
+			max: str(this, "max"),
+			calendar: calendarAttr(this, "calendar"),
+			defaultCalendar: calendarAttr(this, "default-calendar"),
+			locale: str(this, "locale"),
+			minDays: int(this, "min-days"),
+			maxDays: int(this, "max-days"),
+			disabled: bool(this, "disabled"),
+			required: bool(this, "required"),
+			theme: theme(this),
+			panelLayout: panelLayout(this),
+			mask: onUnlessFalse(this, "mask"),
+			inline: this.hasAttribute("inline"),
+			startLabel: str(this, "start-label"),
+			endLabel: str(this, "end-label"),
+			fiscalYearView: bool(this, "fiscal-years"),
+			presets: this.presets
+		};
+	}
+	syncForm() {
+		const view = this.view;
+		if (!view || !this.internals) return;
+		const state = view.getState();
+		const names = this.names();
+		const data = new FormData();
+		if (names.start && state.value.start) data.append(names.start, state.value.start);
+		if (names.end && state.value.end) data.append(names.end, state.value.end);
+		this.internals.setFormValue(data);
+		if (state.error) this.internals.setValidity({ customError: true }, state.error.message, view.inputs.start);
+		else if (bool(this, "required") && (state.value.start === "" || state.value.end === "")) this.internals.setValidity({ valueMissing: true }, "Please choose a start and end date.", view.inputs.start);
+		else this.internals.setValidity({});
+	}
+};
+NepDateRangePickerElement.formAssociated = true;
+NepDateRangePickerElement.observedAttributes = [
+	"start",
+	"end",
+	"name",
+	"start-name",
+	"end-name",
+	"min",
+	"max",
+	"calendar",
+	"default-calendar",
+	"locale",
+	"min-days",
+	"max-days",
+	"disabled",
+	"required",
+	"theme",
+	"panel-layout",
+	"mask",
+	"inline",
+	"start-label",
+	"end-label",
+	"presets",
+	"fiscal-years"
+];
+//#endregion
+//#region src/date-range-picker.ts
+/** `@nepdatejs/vanilla/date-range-picker`: just the range picker. */
+/** Register <nep-date-range-picker> (skipped if already defined). */
+function defineDateRangePicker(registry) {
+	defineElement(ELEMENT_NAMES.dateRangePicker, NepDateRangePickerElement, registry);
+}
+/** Mount a date range picker into a container. */
+function createDateRangePicker$1(container, options = {}) {
+	return new DateRangePickerView(container, options);
+}
+//#endregion
+export { DateRangePickerView as i, defineDateRangePicker as n, NepDateRangePickerElement as r, createDateRangePicker$1 as t };
+
+//# sourceMappingURL=date-range-picker-NwetXUC-.js.map