diff --git a/.gitignore b/.gitignore index b571e42..1eb43e2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ .DS_Store node_modules/ -/dist/ + # local env files .env.local diff --git a/dist/src/components/CalendarHeatmap.vue.d.ts b/dist/src/components/CalendarHeatmap.vue.d.ts new file mode 100644 index 0000000..320c063 --- /dev/null +++ b/dist/src/components/CalendarHeatmap.vue.d.ts @@ -0,0 +1,459 @@ +import { PropType } from 'vue'; +import { CalendarItem, Locale, Month, TooltipFormatter, Value } from '../components/Heatmap'; +declare const _default: import("vue").DefineComponent<{ + endDate: { + required: true; + }; + max: { + type: NumberConstructor; + }; + rangeColor: { + type: PropType; + }; + values: { + type: PropType; + required: true; + }; + locale: { + type: PropType>; + }; + tooltip: { + type: BooleanConstructor; + default: boolean; + }; + showFuture: { + type: BooleanConstructor; + default: boolean; + }; + tooltipUnit: { + type: StringConstructor; + default: string; + }; + tooltipFormatter: { + type: PropType; + }; + vertical: { + type: BooleanConstructor; + default: boolean; + }; + noDataText: { + type: (BooleanConstructor | StringConstructor)[]; + default: null; + }; + round: { + type: NumberConstructor; + default: number; + }; + darkMode: BooleanConstructor; +}, { + SQUARE_BORDER_SIZE: number; + SQUARE_SIZE: number; + LEFT_SECTION_WIDTH: number; + RIGHT_SECTION_WIDTH: number; + TOP_SECTION_HEIGHT: number; + BOTTOM_SECTION_HEIGHT: number; + svg: import("vue").Ref; + heatmap: import("vue").Ref<{ + startDate: { + toString: () => string; + toDateString: () => string; + toTimeString: () => string; + toLocaleString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleDateString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleTimeString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + valueOf: () => number; + getTime: () => number; + getFullYear: () => number; + getUTCFullYear: () => number; + getMonth: () => number; + getUTCMonth: () => number; + getDate: () => number; + getUTCDate: () => number; + getDay: () => number; + getUTCDay: () => number; + getHours: () => number; + getUTCHours: () => number; + getMinutes: () => number; + getUTCMinutes: () => number; + getSeconds: () => number; + getUTCSeconds: () => number; + getMilliseconds: () => number; + getUTCMilliseconds: () => number; + getTimezoneOffset: () => number; + setTime: (time: number) => number; + setMilliseconds: (ms: number) => number; + setUTCMilliseconds: (ms: number) => number; + setSeconds: (sec: number, ms?: number | undefined) => number; + setUTCSeconds: (sec: number, ms?: number | undefined) => number; + setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setDate: (date: number) => number; + setUTCDate: (date: number) => number; + setMonth: (month: number, date?: number | undefined) => number; + setUTCMonth: (month: number, date?: number | undefined) => number; + setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + toUTCString: () => string; + toISOString: () => string; + toJSON: (key?: any) => string; + [Symbol.toPrimitive]: { + (hint: "default"): string; + (hint: "string"): string; + (hint: "number"): number; + (hint: string): string | number; + }; + }; + endDate: { + toString: () => string; + toDateString: () => string; + toTimeString: () => string; + toLocaleString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleDateString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleTimeString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + valueOf: () => number; + getTime: () => number; + getFullYear: () => number; + getUTCFullYear: () => number; + getMonth: () => number; + getUTCMonth: () => number; + getDate: () => number; + getUTCDate: () => number; + getDay: () => number; + getUTCDay: () => number; + getHours: () => number; + getUTCHours: () => number; + getMinutes: () => number; + getUTCMinutes: () => number; + getSeconds: () => number; + getUTCSeconds: () => number; + getMilliseconds: () => number; + getUTCMilliseconds: () => number; + getTimezoneOffset: () => number; + setTime: (time: number) => number; + setMilliseconds: (ms: number) => number; + setUTCMilliseconds: (ms: number) => number; + setSeconds: (sec: number, ms?: number | undefined) => number; + setUTCSeconds: (sec: number, ms?: number | undefined) => number; + setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setDate: (date: number) => number; + setUTCDate: (date: number) => number; + setMonth: (month: number, date?: number | undefined) => number; + setUTCMonth: (month: number, date?: number | undefined) => number; + setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + toUTCString: () => string; + toISOString: () => string; + toJSON: (key?: any) => string; + [Symbol.toPrimitive]: { + (hint: "default"): string; + (hint: "string"): string; + (hint: "number"): number; + (hint: string): string | number; + }; + }; + max: number; + values: { + [x: string]: unknown; + [x: number]: unknown; + [x: symbol]: unknown; + date: string | { + toString: () => string; + toDateString: () => string; + toTimeString: () => string; + toLocaleString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleDateString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleTimeString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + valueOf: () => number; + getTime: () => number; + getFullYear: () => number; + getUTCFullYear: () => number; + getMonth: () => number; + getUTCMonth: () => number; + getDate: () => number; + getUTCDate: () => number; + getDay: () => number; + getUTCDay: () => number; + getHours: () => number; + getUTCHours: () => number; + getMinutes: () => number; + getUTCMinutes: () => number; + getSeconds: () => number; + getUTCSeconds: () => number; + getMilliseconds: () => number; + getUTCMilliseconds: () => number; + getTimezoneOffset: () => number; + setTime: (time: number) => number; + setMilliseconds: (ms: number) => number; + setUTCMilliseconds: (ms: number) => number; + setSeconds: (sec: number, ms?: number | undefined) => number; + setUTCSeconds: (sec: number, ms?: number | undefined) => number; + setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setDate: (date: number) => number; + setUTCDate: (date: number) => number; + setMonth: (month: number, date?: number | undefined) => number; + setUTCMonth: (month: number, date?: number | undefined) => number; + setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + toUTCString: () => string; + toISOString: () => string; + toJSON: (key?: any) => string; + [Symbol.toPrimitive]: { + (hint: "default"): string; + (hint: "string"): string; + (hint: "number"): number; + (hint: string): string | number; + }; + }; + count: number; + }[]; + readonly activities: import('../components/Heatmap').Activities; + readonly weekCount: number; + readonly calendar: { + date: { + toString: () => string; + toDateString: () => string; + toTimeString: () => string; + toLocaleString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleDateString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleTimeString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + valueOf: () => number; + getTime: () => number; + getFullYear: () => number; + getUTCFullYear: () => number; + getMonth: () => number; + getUTCMonth: () => number; + getDate: () => number; + getUTCDate: () => number; + getDay: () => number; + getUTCDay: () => number; + getHours: () => number; + getUTCHours: () => number; + getMinutes: () => number; + getUTCMinutes: () => number; + getSeconds: () => number; + getUTCSeconds: () => number; + getMilliseconds: () => number; + getUTCMilliseconds: () => number; + getTimezoneOffset: () => number; + setTime: (time: number) => number; + setMilliseconds: (ms: number) => number; + setUTCMilliseconds: (ms: number) => number; + setSeconds: (sec: number, ms?: number | undefined) => number; + setUTCSeconds: (sec: number, ms?: number | undefined) => number; + setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setDate: (date: number) => number; + setUTCDate: (date: number) => number; + setMonth: (month: number, date?: number | undefined) => number; + setUTCMonth: (month: number, date?: number | undefined) => number; + setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + toUTCString: () => string; + toISOString: () => string; + toJSON: (key?: any) => string; + [Symbol.toPrimitive]: { + (hint: "default"): string; + (hint: "string"): string; + (hint: "number"): number; + (hint: string): string | number; + }; + }; + count?: number | undefined; + colorIndex: number; + raw?: unknown; + }[][]; + readonly firstFullWeekOfMonths: { + value: number; + index: number; + }[]; + getColorIndex: (count?: number | undefined) => number; + getCountEmptyDaysAtStart: () => number; + getCountEmptyDaysAtEnd: () => number; + getDaysCount: () => number; + }>; + now: import("vue").Ref<{ + toString: () => string; + toDateString: () => string; + toTimeString: () => string; + toLocaleString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleDateString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + toLocaleTimeString: { + (): string; + (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string; + }; + valueOf: () => number; + getTime: () => number; + getFullYear: () => number; + getUTCFullYear: () => number; + getMonth: () => number; + getUTCMonth: () => number; + getDate: () => number; + getUTCDate: () => number; + getDay: () => number; + getUTCDay: () => number; + getHours: () => number; + getUTCHours: () => number; + getMinutes: () => number; + getUTCMinutes: () => number; + getSeconds: () => number; + getUTCSeconds: () => number; + getMilliseconds: () => number; + getUTCMilliseconds: () => number; + getTimezoneOffset: () => number; + setTime: (time: number) => number; + setMilliseconds: (ms: number) => number; + setUTCMilliseconds: (ms: number) => number; + setSeconds: (sec: number, ms?: number | undefined) => number; + setUTCSeconds: (sec: number, ms?: number | undefined) => number; + setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number; + setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number; + setDate: (date: number) => number; + setUTCDate: (date: number) => number; + setMonth: (month: number, date?: number | undefined) => number; + setUTCMonth: (month: number, date?: number | undefined) => number; + setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number; + toUTCString: () => string; + toISOString: () => string; + toJSON: (key?: any) => string; + [Symbol.toPrimitive]: { + (hint: "default"): string; + (hint: "string"): string; + (hint: "number"): number; + (hint: string): string | number; + }; + }>; + width: import("vue").Ref; + height: import("vue").Ref; + viewbox: import("vue").Ref; + daysLabelWrapperTransform: import("vue").Ref; + monthsLabelWrapperTransform: import("vue").Ref; + yearWrapperTransform: string; + legendWrapperTransform: import("vue").Ref; + lo: import("vue").Ref<{ + months: string[]; + days: string[]; + on: string; + less: string; + more: string; + }>; + legendViewbox: import("vue").Ref; + curRangeColor: import("vue").Ref; + tooltipOptions: (day: CalendarItem) => string | undefined; + getWeekPosition: (index: number) => string; + getDayPosition: (index: number) => string; + getMonthLabelPosition: (month: Month) => { + x: number; + y: number; + }; +}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "dayClick"[], "dayClick", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly; + }; + values: { + type: PropType; + required: true; + }; + locale: { + type: PropType>; + }; + tooltip: { + type: BooleanConstructor; + default: boolean; + }; + showFuture: { + type: BooleanConstructor; + default: boolean; + }; + tooltipUnit: { + type: StringConstructor; + default: string; + }; + tooltipFormatter: { + type: PropType; + }; + vertical: { + type: BooleanConstructor; + default: boolean; + }; + noDataText: { + type: (BooleanConstructor | StringConstructor)[]; + default: null; + }; + round: { + type: NumberConstructor; + default: number; + }; + darkMode: BooleanConstructor; +}>> & { + onDayClick?: ((...args: any[]) => any) | undefined; +}, { + tooltip: boolean; + showFuture: boolean; + tooltipUnit: string; + vertical: boolean; + noDataText: string | boolean; + round: number; + darkMode: boolean; +}>; +export default _default; diff --git a/dist/src/components/Heatmap.d.ts b/dist/src/components/Heatmap.d.ts new file mode 100644 index 0000000..283fb2f --- /dev/null +++ b/dist/src/components/Heatmap.d.ts @@ -0,0 +1,60 @@ +export interface Value { + date: Date | string; + count: number; + [x: string | number | symbol]: unknown; +} +export interface Activity { + count: number; + colorIndex: number; + raw: unknown; +} +export declare type Activities = Map; +export interface CalendarItem { + date: Date; + count?: number; + colorIndex: number; + raw?: unknown; +} +export declare type Calendar = CalendarItem[][]; +export interface Month { + value: number; + index: number; +} +export interface Locale { + months: string[]; + days: string[]; + on: string; + less: string; + more: string; +} +export declare type TooltipFormatter = (item: CalendarItem, unit: string) => string; +export declare class Heatmap { + static readonly DEFAULT_RANGE_COLOR_LIGHT: string[]; + static readonly DEFAULT_RANGE_COLOR_DARK: string[]; + static readonly DEFAULT_LOCALE: Locale; + static readonly DEFAULT_TOOLTIP_UNIT = "contributions"; + static readonly DAYS_IN_ONE_YEAR = 365; + static readonly DAYS_IN_WEEK = 7; + static readonly SQUARE_SIZE = 10; + startDate: Date; + endDate: Date; + max: number; + private _values; + private _firstFullWeekOfMonths?; + private _activities?; + private _calendar?; + constructor(endDate: Date | string, values: Value[], max?: number); + set values(v: Value[]); + get values(): Value[]; + get activities(): Activities; + get weekCount(): number; + get calendar(): Calendar; + get firstFullWeekOfMonths(): Month[]; + getColorIndex(count?: number): number; + getCountEmptyDaysAtStart(): number; + getCountEmptyDaysAtEnd(): number; + getDaysCount(): number; + private shiftDate; + private parseDate; + private keyDayParser; +} diff --git a/dist/src/index.d.ts b/dist/src/index.d.ts new file mode 100644 index 0000000..1d88803 --- /dev/null +++ b/dist/src/index.d.ts @@ -0,0 +1,8 @@ +import { App } from 'vue'; +declare function install(Vue: App): void; +declare const _default: { + install: typeof install; +}; +export default _default; +export * from './components/Heatmap'; +export { default as CalendarHeatmap } from './components/CalendarHeatmap.vue'; diff --git a/dist/style.css b/dist/style.css new file mode 100644 index 0000000..164326e --- /dev/null +++ b/dist/style.css @@ -0,0 +1 @@ +.tippy-box[data-animation=fade][data-state=hidden]{opacity:0}[data-tippy-root]{max-width:calc(100vw - 10px)}.tippy-box{position:relative;background-color:#333;color:#fff;border-radius:4px;font-size:14px;line-height:1.4;white-space:normal;outline:0;transition-property:transform,visibility,opacity}.tippy-box[data-placement^=top]>.tippy-arrow{bottom:0}.tippy-box[data-placement^=top]>.tippy-arrow:before{bottom:-7px;left:0;border-width:8px 8px 0;border-top-color:initial;transform-origin:center top}.tippy-box[data-placement^=bottom]>.tippy-arrow{top:0}.tippy-box[data-placement^=bottom]>.tippy-arrow:before{top:-7px;left:0;border-width:0 8px 8px;border-bottom-color:initial;transform-origin:center bottom}.tippy-box[data-placement^=left]>.tippy-arrow{right:0}.tippy-box[data-placement^=left]>.tippy-arrow:before{border-width:8px 0 8px 8px;border-left-color:initial;right:-7px;transform-origin:center left}.tippy-box[data-placement^=right]>.tippy-arrow{left:0}.tippy-box[data-placement^=right]>.tippy-arrow:before{left:-7px;border-width:8px 8px 8px 0;border-right-color:initial;transform-origin:center right}.tippy-box[data-inertia][data-state=visible]{transition-timing-function:cubic-bezier(.54,1.5,.38,1.11)}.tippy-arrow{width:16px;height:16px;color:#333}.tippy-arrow:before{content:"";position:absolute;border-color:transparent;border-style:solid}.tippy-content{position:relative;padding:5px 9px;z-index:1}.tippy-box[data-placement^=top]>.tippy-svg-arrow{bottom:0}.tippy-box[data-placement^=top]>.tippy-svg-arrow:after,.tippy-box[data-placement^=top]>.tippy-svg-arrow>svg{top:16px;transform:rotate(180deg)}.tippy-box[data-placement^=bottom]>.tippy-svg-arrow{top:0}.tippy-box[data-placement^=bottom]>.tippy-svg-arrow>svg{bottom:16px}.tippy-box[data-placement^=left]>.tippy-svg-arrow{right:0}.tippy-box[data-placement^=left]>.tippy-svg-arrow:after,.tippy-box[data-placement^=left]>.tippy-svg-arrow>svg{transform:rotate(90deg);top:calc(50% - 3px);left:11px}.tippy-box[data-placement^=right]>.tippy-svg-arrow{left:0}.tippy-box[data-placement^=right]>.tippy-svg-arrow:after,.tippy-box[data-placement^=right]>.tippy-svg-arrow>svg{transform:rotate(-90deg);top:calc(50% - 3px);right:11px}.tippy-svg-arrow{width:16px;height:16px;fill:#333;text-align:initial}.tippy-svg-arrow,.tippy-svg-arrow>svg{position:absolute}.vch__container .vch__legend{display:flex;justify-content:space-between;align-items:center}.vch__container .vch__external-legend-wrapper{margin:0 8px}svg.vch__wrapper{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Open Sans,Helvetica Neue,sans-serif;line-height:10px;width:100%}svg.vch__wrapper .vch__months__labels__wrapper text.vch__month__label{font-size:10px}svg.vch__wrapper .vch__days__labels__wrapper text.vch__day__label,svg.vch__wrapper .vch__legend__wrapper text{font-size:9px}svg.vch__wrapper text.vch__month__label,svg.vch__wrapper text.vch__day__label,svg.vch__wrapper .vch__legend__wrapper text{fill:#767676}svg.vch__wrapper rect.vch__day__square:hover{stroke:#555;stroke-width:2px;paint-order:stroke}svg.vch__wrapper rect.vch__day__square:focus{outline:none}svg.vch__wrapper.dark-mode text.vch__month__label,svg.vch__wrapper.dark-mode text.vch__day__label,svg.vch__wrapper.dark-mode .vch__legend__wrapper text{fill:#fff} diff --git a/dist/vue3-calendar-heatmap.es.js b/dist/vue3-calendar-heatmap.es.js new file mode 100644 index 0000000..899206b --- /dev/null +++ b/dist/vue3-calendar-heatmap.es.js @@ -0,0 +1,3091 @@ +var __defProp = Object.defineProperty; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +import { defineComponent, ref, toRefs, watch, toRef, nextTick, onMounted, onBeforeUnmount, openBlock, createElementBlock, normalizeClass, createElementVNode, Fragment, renderList, toDisplayString, normalizeStyle, createCommentVNode, renderSlot } from "vue"; +const _Heatmap = class { + constructor(endDate, values, max2) { + __publicField(this, "startDate"); + __publicField(this, "endDate"); + __publicField(this, "max"); + __publicField(this, "_values"); + __publicField(this, "_firstFullWeekOfMonths"); + __publicField(this, "_activities"); + __publicField(this, "_calendar"); + this.endDate = this.parseDate(endDate); + this.max = max2 || Math.ceil(Math.max(...values.map((day) => day.count)) / 5 * 4); + this.startDate = this.shiftDate(endDate, -_Heatmap.DAYS_IN_ONE_YEAR); + this._values = values; + } + set values(v) { + this.max = Math.ceil(Math.max(...v.map((day) => day.count)) / 5 * 4); + this._values = v; + this._firstFullWeekOfMonths = void 0; + this._calendar = void 0; + this._activities = void 0; + } + get values() { + return this._values; + } + get activities() { + if (!this._activities) { + this._activities = /* @__PURE__ */ new Map(); + for (let i = 0, len = this.values.length; i < len; i++) { + this._activities.set(this.keyDayParser(this.values[i].date), { + count: this.values[i].count, + colorIndex: this.getColorIndex(this.values[i].count), + raw: __spreadValues({}, this.values[i]) + }); + } + } + return this._activities; + } + get weekCount() { + return this.getDaysCount() / _Heatmap.DAYS_IN_WEEK; + } + get calendar() { + if (!this._calendar) { + let date = this.shiftDate(this.startDate, -this.getCountEmptyDaysAtStart()); + date = new Date(date.getFullYear(), date.getMonth(), date.getDate()); + this._calendar = new Array(this.weekCount); + for (let i = 0, len = this._calendar.length; i < len; i++) { + this._calendar[i] = new Array(_Heatmap.DAYS_IN_WEEK); + for (let j = 0; j < _Heatmap.DAYS_IN_WEEK; j++) { + const dayValues = this.activities.get(this.keyDayParser(date)); + this._calendar[i][j] = { + date: new Date(date.valueOf()), + count: dayValues ? dayValues.count : void 0, + colorIndex: dayValues ? dayValues.colorIndex : 0, + raw: dayValues ? dayValues.raw : void 0 + }; + date.setDate(date.getDate() + 1); + } + } + } + return this._calendar; + } + get firstFullWeekOfMonths() { + if (!this._firstFullWeekOfMonths) { + const cal = this.calendar; + this._firstFullWeekOfMonths = []; + for (let index2 = 1, len = cal.length; index2 < len; index2++) { + const lastWeek = cal[index2 - 1][0].date, currentWeek = cal[index2][0].date; + if (lastWeek.getFullYear() < currentWeek.getFullYear() || lastWeek.getMonth() < currentWeek.getMonth()) { + this._firstFullWeekOfMonths.push({ value: currentWeek.getMonth(), index: index2 }); + } + } + } + return this._firstFullWeekOfMonths; + } + getColorIndex(count) { + if (count === null || count === void 0) { + return 0; + } else if (count <= 0) { + return 1; + } else if (count >= this.max) { + return 5; + } else { + return Math.ceil(count * 100 / this.max * 0.03) + 1; + } + } + getCountEmptyDaysAtStart() { + return this.startDate.getDay(); + } + getCountEmptyDaysAtEnd() { + return _Heatmap.DAYS_IN_WEEK - 1 - this.endDate.getDay(); + } + getDaysCount() { + return _Heatmap.DAYS_IN_ONE_YEAR + 1 + this.getCountEmptyDaysAtStart() + this.getCountEmptyDaysAtEnd(); + } + shiftDate(date, numDays) { + const newDate = new Date(date); + newDate.setDate(newDate.getDate() + numDays); + return newDate; + } + parseDate(entry) { + return entry instanceof Date ? entry : new Date(entry); + } + keyDayParser(date) { + const day = this.parseDate(date); + return String(day.getFullYear()) + String(day.getMonth()).padStart(2, "0") + String(day.getDate()).padStart(2, "0"); + } +}; +let Heatmap = _Heatmap; +__publicField(Heatmap, "DEFAULT_RANGE_COLOR_LIGHT", ["#ebedf0", "#dae2ef", "#c0ddf9", "#73b3f3", "#3886e1", "#17459e"]); +__publicField(Heatmap, "DEFAULT_RANGE_COLOR_DARK", ["#1f1f22", "#1e334a", "#1d466c", "#1d5689", "#1d69ac", "#1B95D1"]); +__publicField(Heatmap, "DEFAULT_LOCALE", { + months: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], + days: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], + on: "on", + less: "Less", + more: "More" +}); +__publicField(Heatmap, "DEFAULT_TOOLTIP_UNIT", "contributions"); +__publicField(Heatmap, "DAYS_IN_ONE_YEAR", 365); +__publicField(Heatmap, "DAYS_IN_WEEK", 7); +__publicField(Heatmap, "SQUARE_SIZE", 10); +var top = "top"; +var bottom = "bottom"; +var right = "right"; +var left = "left"; +var auto = "auto"; +var basePlacements = [top, bottom, right, left]; +var start = "start"; +var end = "end"; +var clippingParents = "clippingParents"; +var viewport = "viewport"; +var popper = "popper"; +var reference = "reference"; +var variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) { + return acc.concat([placement + "-" + start, placement + "-" + end]); +}, []); +var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) { + return acc.concat([placement, placement + "-" + start, placement + "-" + end]); +}, []); +var beforeRead = "beforeRead"; +var read = "read"; +var afterRead = "afterRead"; +var beforeMain = "beforeMain"; +var main = "main"; +var afterMain = "afterMain"; +var beforeWrite = "beforeWrite"; +var write = "write"; +var afterWrite = "afterWrite"; +var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; +function getNodeName(element) { + return element ? (element.nodeName || "").toLowerCase() : null; +} +function getWindow(node) { + if (node == null) { + return window; + } + if (node.toString() !== "[object Window]") { + var ownerDocument = node.ownerDocument; + return ownerDocument ? ownerDocument.defaultView || window : window; + } + return node; +} +function isElement$1(node) { + var OwnElement = getWindow(node).Element; + return node instanceof OwnElement || node instanceof Element; +} +function isHTMLElement(node) { + var OwnElement = getWindow(node).HTMLElement; + return node instanceof OwnElement || node instanceof HTMLElement; +} +function isShadowRoot(node) { + if (typeof ShadowRoot === "undefined") { + return false; + } + var OwnElement = getWindow(node).ShadowRoot; + return node instanceof OwnElement || node instanceof ShadowRoot; +} +function applyStyles(_ref) { + var state = _ref.state; + Object.keys(state.elements).forEach(function(name) { + var style = state.styles[name] || {}; + var attributes = state.attributes[name] || {}; + var element = state.elements[name]; + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } + Object.assign(element.style, style); + Object.keys(attributes).forEach(function(name2) { + var value = attributes[name2]; + if (value === false) { + element.removeAttribute(name2); + } else { + element.setAttribute(name2, value === true ? "" : value); + } + }); + }); +} +function effect$2(_ref2) { + var state = _ref2.state; + var initialStyles = { + popper: { + position: state.options.strategy, + left: "0", + top: "0", + margin: "0" + }, + arrow: { + position: "absolute" + }, + reference: {} + }; + Object.assign(state.elements.popper.style, initialStyles.popper); + state.styles = initialStyles; + if (state.elements.arrow) { + Object.assign(state.elements.arrow.style, initialStyles.arrow); + } + return function() { + Object.keys(state.elements).forEach(function(name) { + var element = state.elements[name]; + var attributes = state.attributes[name] || {}; + var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); + var style = styleProperties.reduce(function(style2, property) { + style2[property] = ""; + return style2; + }, {}); + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } + Object.assign(element.style, style); + Object.keys(attributes).forEach(function(attribute) { + element.removeAttribute(attribute); + }); + }); + }; +} +var applyStyles$1 = { + name: "applyStyles", + enabled: true, + phase: "write", + fn: applyStyles, + effect: effect$2, + requires: ["computeStyles"] +}; +function getBasePlacement$1(placement) { + return placement.split("-")[0]; +} +var max = Math.max; +var min = Math.min; +var round = Math.round; +function getBoundingClientRect(element, includeScale) { + if (includeScale === void 0) { + includeScale = false; + } + var rect = element.getBoundingClientRect(); + var scaleX = 1; + var scaleY = 1; + if (isHTMLElement(element) && includeScale) { + var offsetHeight = element.offsetHeight; + var offsetWidth = element.offsetWidth; + if (offsetWidth > 0) { + scaleX = round(rect.width) / offsetWidth || 1; + } + if (offsetHeight > 0) { + scaleY = round(rect.height) / offsetHeight || 1; + } + } + return { + width: rect.width / scaleX, + height: rect.height / scaleY, + top: rect.top / scaleY, + right: rect.right / scaleX, + bottom: rect.bottom / scaleY, + left: rect.left / scaleX, + x: rect.left / scaleX, + y: rect.top / scaleY + }; +} +function getLayoutRect(element) { + var clientRect = getBoundingClientRect(element); + var width = element.offsetWidth; + var height = element.offsetHeight; + if (Math.abs(clientRect.width - width) <= 1) { + width = clientRect.width; + } + if (Math.abs(clientRect.height - height) <= 1) { + height = clientRect.height; + } + return { + x: element.offsetLeft, + y: element.offsetTop, + width, + height + }; +} +function contains(parent, child) { + var rootNode = child.getRootNode && child.getRootNode(); + if (parent.contains(child)) { + return true; + } else if (rootNode && isShadowRoot(rootNode)) { + var next = child; + do { + if (next && parent.isSameNode(next)) { + return true; + } + next = next.parentNode || next.host; + } while (next); + } + return false; +} +function getComputedStyle(element) { + return getWindow(element).getComputedStyle(element); +} +function isTableElement(element) { + return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0; +} +function getDocumentElement(element) { + return ((isElement$1(element) ? element.ownerDocument : element.document) || window.document).documentElement; +} +function getParentNode(element) { + if (getNodeName(element) === "html") { + return element; + } + return element.assignedSlot || element.parentNode || (isShadowRoot(element) ? element.host : null) || getDocumentElement(element); +} +function getTrueOffsetParent(element) { + if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") { + return null; + } + return element.offsetParent; +} +function getContainingBlock(element) { + var isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") !== -1; + var isIE = navigator.userAgent.indexOf("Trident") !== -1; + if (isIE && isHTMLElement(element)) { + var elementCss = getComputedStyle(element); + if (elementCss.position === "fixed") { + return null; + } + } + var currentNode = getParentNode(element); + while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) { + var css = getComputedStyle(currentNode); + if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") { + return currentNode; + } else { + currentNode = currentNode.parentNode; + } + } + return null; +} +function getOffsetParent(element) { + var window2 = getWindow(element); + var offsetParent = getTrueOffsetParent(element); + while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") { + offsetParent = getTrueOffsetParent(offsetParent); + } + if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) { + return window2; + } + return offsetParent || getContainingBlock(element) || window2; +} +function getMainAxisFromPlacement(placement) { + return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y"; +} +function within(min$1, value, max$1) { + return max(min$1, min(value, max$1)); +} +function withinMaxClamp(min2, value, max2) { + var v = within(min2, value, max2); + return v > max2 ? max2 : v; +} +function getFreshSideObject() { + return { + top: 0, + right: 0, + bottom: 0, + left: 0 + }; +} +function mergePaddingObject(paddingObject) { + return Object.assign({}, getFreshSideObject(), paddingObject); +} +function expandToHashMap(value, keys) { + return keys.reduce(function(hashMap, key) { + hashMap[key] = value; + return hashMap; + }, {}); +} +var toPaddingObject = function toPaddingObject2(padding, state) { + padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, { + placement: state.placement + })) : padding; + return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements)); +}; +function arrow(_ref) { + var _state$modifiersData$; + var state = _ref.state, name = _ref.name, options = _ref.options; + var arrowElement = state.elements.arrow; + var popperOffsets2 = state.modifiersData.popperOffsets; + var basePlacement = getBasePlacement$1(state.placement); + var axis = getMainAxisFromPlacement(basePlacement); + var isVertical = [left, right].indexOf(basePlacement) >= 0; + var len = isVertical ? "height" : "width"; + if (!arrowElement || !popperOffsets2) { + return; + } + var paddingObject = toPaddingObject(options.padding, state); + var arrowRect = getLayoutRect(arrowElement); + var minProp = axis === "y" ? top : left; + var maxProp = axis === "y" ? bottom : right; + var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len]; + var startDiff = popperOffsets2[axis] - state.rects.reference[axis]; + var arrowOffsetParent = getOffsetParent(arrowElement); + var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; + var centerToReference = endDiff / 2 - startDiff / 2; + var min2 = paddingObject[minProp]; + var max2 = clientSize - arrowRect[len] - paddingObject[maxProp]; + var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; + var offset2 = within(min2, center, max2); + var axisProp = axis; + state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$); +} +function effect$1(_ref2) { + var state = _ref2.state, options = _ref2.options; + var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element; + if (arrowElement == null) { + return; + } + if (typeof arrowElement === "string") { + arrowElement = state.elements.popper.querySelector(arrowElement); + if (!arrowElement) { + return; + } + } + if (!contains(state.elements.popper, arrowElement)) { + return; + } + state.elements.arrow = arrowElement; +} +var arrow$1 = { + name: "arrow", + enabled: true, + phase: "main", + fn: arrow, + effect: effect$1, + requires: ["popperOffsets"], + requiresIfExists: ["preventOverflow"] +}; +function getVariation(placement) { + return placement.split("-")[1]; +} +var unsetSides = { + top: "auto", + right: "auto", + bottom: "auto", + left: "auto" +}; +function roundOffsetsByDPR(_ref) { + var x = _ref.x, y = _ref.y; + var win = window; + var dpr = win.devicePixelRatio || 1; + return { + x: round(x * dpr) / dpr || 0, + y: round(y * dpr) / dpr || 0 + }; +} +function mapToStyles(_ref2) { + var _Object$assign2; + var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed; + var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y; + var _ref3 = typeof roundOffsets === "function" ? roundOffsets({ + x, + y + }) : { + x, + y + }; + x = _ref3.x; + y = _ref3.y; + var hasX = offsets.hasOwnProperty("x"); + var hasY = offsets.hasOwnProperty("y"); + var sideX = left; + var sideY = top; + var win = window; + if (adaptive) { + var offsetParent = getOffsetParent(popper2); + var heightProp = "clientHeight"; + var widthProp = "clientWidth"; + if (offsetParent === getWindow(popper2)) { + offsetParent = getDocumentElement(popper2); + if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") { + heightProp = "scrollHeight"; + widthProp = "scrollWidth"; + } + } + offsetParent = offsetParent; + if (placement === top || (placement === left || placement === right) && variation === end) { + sideY = bottom; + var offsetY = isFixed && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp]; + y -= offsetY - popperRect.height; + y *= gpuAcceleration ? 1 : -1; + } + if (placement === left || (placement === top || placement === bottom) && variation === end) { + sideX = right; + var offsetX = isFixed && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp]; + x -= offsetX - popperRect.width; + x *= gpuAcceleration ? 1 : -1; + } + } + var commonStyles = Object.assign({ + position + }, adaptive && unsetSides); + var _ref4 = roundOffsets === true ? roundOffsetsByDPR({ + x, + y + }) : { + x, + y + }; + x = _ref4.x; + y = _ref4.y; + if (gpuAcceleration) { + var _Object$assign; + return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); + } + return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2)); +} +function computeStyles(_ref5) { + var state = _ref5.state, options = _ref5.options; + var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; + var commonStyles = { + placement: getBasePlacement$1(state.placement), + variation: getVariation(state.placement), + popper: state.elements.popper, + popperRect: state.rects.popper, + gpuAcceleration, + isFixed: state.options.strategy === "fixed" + }; + if (state.modifiersData.popperOffsets != null) { + state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.popperOffsets, + position: state.options.strategy, + adaptive, + roundOffsets + }))); + } + if (state.modifiersData.arrow != null) { + state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.arrow, + position: "absolute", + adaptive: false, + roundOffsets + }))); + } + state.attributes.popper = Object.assign({}, state.attributes.popper, { + "data-popper-placement": state.placement + }); +} +var computeStyles$1 = { + name: "computeStyles", + enabled: true, + phase: "beforeWrite", + fn: computeStyles, + data: {} +}; +var passive = { + passive: true +}; +function effect(_ref) { + var state = _ref.state, instance = _ref.instance, options = _ref.options; + var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize; + var window2 = getWindow(state.elements.popper); + var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); + if (scroll) { + scrollParents.forEach(function(scrollParent) { + scrollParent.addEventListener("scroll", instance.update, passive); + }); + } + if (resize) { + window2.addEventListener("resize", instance.update, passive); + } + return function() { + if (scroll) { + scrollParents.forEach(function(scrollParent) { + scrollParent.removeEventListener("scroll", instance.update, passive); + }); + } + if (resize) { + window2.removeEventListener("resize", instance.update, passive); + } + }; +} +var eventListeners = { + name: "eventListeners", + enabled: true, + phase: "write", + fn: function fn() { + }, + effect, + data: {} +}; +var hash$1 = { + left: "right", + right: "left", + bottom: "top", + top: "bottom" +}; +function getOppositePlacement(placement) { + return placement.replace(/left|right|bottom|top/g, function(matched) { + return hash$1[matched]; + }); +} +var hash = { + start: "end", + end: "start" +}; +function getOppositeVariationPlacement(placement) { + return placement.replace(/start|end/g, function(matched) { + return hash[matched]; + }); +} +function getWindowScroll(node) { + var win = getWindow(node); + var scrollLeft = win.pageXOffset; + var scrollTop = win.pageYOffset; + return { + scrollLeft, + scrollTop + }; +} +function getWindowScrollBarX(element) { + return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; +} +function getViewportRect(element) { + var win = getWindow(element); + var html = getDocumentElement(element); + var visualViewport = win.visualViewport; + var width = html.clientWidth; + var height = html.clientHeight; + var x = 0; + var y = 0; + if (visualViewport) { + width = visualViewport.width; + height = visualViewport.height; + if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + x = visualViewport.offsetLeft; + y = visualViewport.offsetTop; + } + } + return { + width, + height, + x: x + getWindowScrollBarX(element), + y + }; +} +function getDocumentRect(element) { + var _element$ownerDocumen; + var html = getDocumentElement(element); + var winScroll = getWindowScroll(element); + var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; + var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); + var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); + var x = -winScroll.scrollLeft + getWindowScrollBarX(element); + var y = -winScroll.scrollTop; + if (getComputedStyle(body || html).direction === "rtl") { + x += max(html.clientWidth, body ? body.clientWidth : 0) - width; + } + return { + width, + height, + x, + y + }; +} +function isScrollParent(element) { + var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY; + return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); +} +function getScrollParent(node) { + if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) { + return node.ownerDocument.body; + } + if (isHTMLElement(node) && isScrollParent(node)) { + return node; + } + return getScrollParent(getParentNode(node)); +} +function listScrollParents(element, list) { + var _element$ownerDocumen; + if (list === void 0) { + list = []; + } + var scrollParent = getScrollParent(element); + var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); + var win = getWindow(scrollParent); + var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; + var updatedList = list.concat(target); + return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target))); +} +function rectToClientRect(rect) { + return Object.assign({}, rect, { + left: rect.x, + top: rect.y, + right: rect.x + rect.width, + bottom: rect.y + rect.height + }); +} +function getInnerBoundingClientRect(element) { + var rect = getBoundingClientRect(element); + rect.top = rect.top + element.clientTop; + rect.left = rect.left + element.clientLeft; + rect.bottom = rect.top + element.clientHeight; + rect.right = rect.left + element.clientWidth; + rect.width = element.clientWidth; + rect.height = element.clientHeight; + rect.x = rect.left; + rect.y = rect.top; + return rect; +} +function getClientRectFromMixedType(element, clippingParent) { + return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement$1(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element))); +} +function getClippingParents(element) { + var clippingParents2 = listScrollParents(getParentNode(element)); + var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle(element).position) >= 0; + var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; + if (!isElement$1(clipperElement)) { + return []; + } + return clippingParents2.filter(function(clippingParent) { + return isElement$1(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body"; + }); +} +function getClippingRect(element, boundary, rootBoundary) { + var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary); + var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]); + var firstClippingParent = clippingParents2[0]; + var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) { + var rect = getClientRectFromMixedType(element, clippingParent); + accRect.top = max(rect.top, accRect.top); + accRect.right = min(rect.right, accRect.right); + accRect.bottom = min(rect.bottom, accRect.bottom); + accRect.left = max(rect.left, accRect.left); + return accRect; + }, getClientRectFromMixedType(element, firstClippingParent)); + clippingRect.width = clippingRect.right - clippingRect.left; + clippingRect.height = clippingRect.bottom - clippingRect.top; + clippingRect.x = clippingRect.left; + clippingRect.y = clippingRect.top; + return clippingRect; +} +function computeOffsets(_ref) { + var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement; + var basePlacement = placement ? getBasePlacement$1(placement) : null; + var variation = placement ? getVariation(placement) : null; + var commonX = reference2.x + reference2.width / 2 - element.width / 2; + var commonY = reference2.y + reference2.height / 2 - element.height / 2; + var offsets; + switch (basePlacement) { + case top: + offsets = { + x: commonX, + y: reference2.y - element.height + }; + break; + case bottom: + offsets = { + x: commonX, + y: reference2.y + reference2.height + }; + break; + case right: + offsets = { + x: reference2.x + reference2.width, + y: commonY + }; + break; + case left: + offsets = { + x: reference2.x - element.width, + y: commonY + }; + break; + default: + offsets = { + x: reference2.x, + y: reference2.y + }; + } + var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; + if (mainAxis != null) { + var len = mainAxis === "y" ? "height" : "width"; + switch (variation) { + case start: + offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2); + break; + case end: + offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2); + break; + } + } + return offsets; +} +function detectOverflow(state, options) { + if (options === void 0) { + options = {}; + } + var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding; + var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements)); + var altContext = elementContext === popper ? reference : popper; + var popperRect = state.rects.popper; + var element = state.elements[altBoundary ? altContext : elementContext]; + var clippingClientRect = getClippingRect(isElement$1(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary); + var referenceClientRect = getBoundingClientRect(state.elements.reference); + var popperOffsets2 = computeOffsets({ + reference: referenceClientRect, + element: popperRect, + strategy: "absolute", + placement + }); + var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2)); + var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; + var overflowOffsets = { + top: clippingClientRect.top - elementClientRect.top + paddingObject.top, + bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, + left: clippingClientRect.left - elementClientRect.left + paddingObject.left, + right: elementClientRect.right - clippingClientRect.right + paddingObject.right + }; + var offsetData = state.modifiersData.offset; + if (elementContext === popper && offsetData) { + var offset2 = offsetData[placement]; + Object.keys(overflowOffsets).forEach(function(key) { + var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; + var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x"; + overflowOffsets[key] += offset2[axis] * multiply; + }); + } + return overflowOffsets; +} +function computeAutoPlacement(state, options) { + if (options === void 0) { + options = {}; + } + var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; + var variation = getVariation(placement); + var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) { + return getVariation(placement2) === variation; + }) : basePlacements; + var allowedPlacements = placements$1.filter(function(placement2) { + return allowedAutoPlacements.indexOf(placement2) >= 0; + }); + if (allowedPlacements.length === 0) { + allowedPlacements = placements$1; + } + var overflows = allowedPlacements.reduce(function(acc, placement2) { + acc[placement2] = detectOverflow(state, { + placement: placement2, + boundary, + rootBoundary, + padding + })[getBasePlacement$1(placement2)]; + return acc; + }, {}); + return Object.keys(overflows).sort(function(a, b) { + return overflows[a] - overflows[b]; + }); +} +function getExpandedFallbackPlacements(placement) { + if (getBasePlacement$1(placement) === auto) { + return []; + } + var oppositePlacement = getOppositePlacement(placement); + return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; +} +function flip(_ref) { + var state = _ref.state, options = _ref.options, name = _ref.name; + if (state.modifiersData[name]._skip) { + return; + } + var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements; + var preferredPlacement = state.options.placement; + var basePlacement = getBasePlacement$1(preferredPlacement); + var isBasePlacement = basePlacement === preferredPlacement; + var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); + var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) { + return acc.concat(getBasePlacement$1(placement2) === auto ? computeAutoPlacement(state, { + placement: placement2, + boundary, + rootBoundary, + padding, + flipVariations, + allowedAutoPlacements + }) : placement2); + }, []); + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var checksMap = /* @__PURE__ */ new Map(); + var makeFallbackChecks = true; + var firstFittingPlacement = placements2[0]; + for (var i = 0; i < placements2.length; i++) { + var placement = placements2[i]; + var _basePlacement = getBasePlacement$1(placement); + var isStartVariation = getVariation(placement) === start; + var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; + var len = isVertical ? "width" : "height"; + var overflow = detectOverflow(state, { + placement, + boundary, + rootBoundary, + altBoundary, + padding + }); + var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; + if (referenceRect[len] > popperRect[len]) { + mainVariationSide = getOppositePlacement(mainVariationSide); + } + var altVariationSide = getOppositePlacement(mainVariationSide); + var checks = []; + if (checkMainAxis) { + checks.push(overflow[_basePlacement] <= 0); + } + if (checkAltAxis) { + checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); + } + if (checks.every(function(check) { + return check; + })) { + firstFittingPlacement = placement; + makeFallbackChecks = false; + break; + } + checksMap.set(placement, checks); + } + if (makeFallbackChecks) { + var numberOfChecks = flipVariations ? 3 : 1; + var _loop = function _loop2(_i2) { + var fittingPlacement = placements2.find(function(placement2) { + var checks2 = checksMap.get(placement2); + if (checks2) { + return checks2.slice(0, _i2).every(function(check) { + return check; + }); + } + }); + if (fittingPlacement) { + firstFittingPlacement = fittingPlacement; + return "break"; + } + }; + for (var _i = numberOfChecks; _i > 0; _i--) { + var _ret = _loop(_i); + if (_ret === "break") + break; + } + } + if (state.placement !== firstFittingPlacement) { + state.modifiersData[name]._skip = true; + state.placement = firstFittingPlacement; + state.reset = true; + } +} +var flip$1 = { + name: "flip", + enabled: true, + phase: "main", + fn: flip, + requiresIfExists: ["offset"], + data: { + _skip: false + } +}; +function getSideOffsets(overflow, rect, preventedOffsets) { + if (preventedOffsets === void 0) { + preventedOffsets = { + x: 0, + y: 0 + }; + } + return { + top: overflow.top - rect.height - preventedOffsets.y, + right: overflow.right - rect.width + preventedOffsets.x, + bottom: overflow.bottom - rect.height + preventedOffsets.y, + left: overflow.left - rect.width - preventedOffsets.x + }; +} +function isAnySideFullyClipped(overflow) { + return [top, right, bottom, left].some(function(side) { + return overflow[side] >= 0; + }); +} +function hide(_ref) { + var state = _ref.state, name = _ref.name; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var preventedOffsets = state.modifiersData.preventOverflow; + var referenceOverflow = detectOverflow(state, { + elementContext: "reference" + }); + var popperAltOverflow = detectOverflow(state, { + altBoundary: true + }); + var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); + var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); + var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); + var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); + state.modifiersData[name] = { + referenceClippingOffsets, + popperEscapeOffsets, + isReferenceHidden, + hasPopperEscaped + }; + state.attributes.popper = Object.assign({}, state.attributes.popper, { + "data-popper-reference-hidden": isReferenceHidden, + "data-popper-escaped": hasPopperEscaped + }); +} +var hide$1 = { + name: "hide", + enabled: true, + phase: "main", + requiresIfExists: ["preventOverflow"], + fn: hide +}; +function distanceAndSkiddingToXY(placement, rects, offset2) { + var basePlacement = getBasePlacement$1(placement); + var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; + var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, { + placement + })) : offset2, skidding = _ref[0], distance = _ref[1]; + skidding = skidding || 0; + distance = (distance || 0) * invertDistance; + return [left, right].indexOf(basePlacement) >= 0 ? { + x: distance, + y: skidding + } : { + x: skidding, + y: distance + }; +} +function offset(_ref2) { + var state = _ref2.state, options = _ref2.options, name = _ref2.name; + var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset; + var data = placements.reduce(function(acc, placement) { + acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2); + return acc; + }, {}); + var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y; + if (state.modifiersData.popperOffsets != null) { + state.modifiersData.popperOffsets.x += x; + state.modifiersData.popperOffsets.y += y; + } + state.modifiersData[name] = data; +} +var offset$1 = { + name: "offset", + enabled: true, + phase: "main", + requires: ["popperOffsets"], + fn: offset +}; +function popperOffsets(_ref) { + var state = _ref.state, name = _ref.name; + state.modifiersData[name] = computeOffsets({ + reference: state.rects.reference, + element: state.rects.popper, + strategy: "absolute", + placement: state.placement + }); +} +var popperOffsets$1 = { + name: "popperOffsets", + enabled: true, + phase: "read", + fn: popperOffsets, + data: {} +}; +function getAltAxis(axis) { + return axis === "x" ? "y" : "x"; +} +function preventOverflow(_ref) { + var state = _ref.state, options = _ref.options, name = _ref.name; + var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; + var overflow = detectOverflow(state, { + boundary, + rootBoundary, + padding, + altBoundary + }); + var basePlacement = getBasePlacement$1(state.placement); + var variation = getVariation(state.placement); + var isBasePlacement = !variation; + var mainAxis = getMainAxisFromPlacement(basePlacement); + var altAxis = getAltAxis(mainAxis); + var popperOffsets2 = state.modifiersData.popperOffsets; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, { + placement: state.placement + })) : tetherOffset; + var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? { + mainAxis: tetherOffsetValue, + altAxis: tetherOffsetValue + } : Object.assign({ + mainAxis: 0, + altAxis: 0 + }, tetherOffsetValue); + var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null; + var data = { + x: 0, + y: 0 + }; + if (!popperOffsets2) { + return; + } + if (checkMainAxis) { + var _offsetModifierState$; + var mainSide = mainAxis === "y" ? top : left; + var altSide = mainAxis === "y" ? bottom : right; + var len = mainAxis === "y" ? "height" : "width"; + var offset2 = popperOffsets2[mainAxis]; + var min$1 = offset2 + overflow[mainSide]; + var max$1 = offset2 - overflow[altSide]; + var additive = tether ? -popperRect[len] / 2 : 0; + var minLen = variation === start ? referenceRect[len] : popperRect[len]; + var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; + var arrowElement = state.elements.arrow; + var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { + width: 0, + height: 0 + }; + var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject(); + var arrowPaddingMin = arrowPaddingObject[mainSide]; + var arrowPaddingMax = arrowPaddingObject[altSide]; + var arrowLen = within(0, referenceRect[len], arrowRect[len]); + var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis; + var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis; + var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); + var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; + var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0; + var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset; + var tetherMax = offset2 + maxOffset - offsetModifierValue; + var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1); + popperOffsets2[mainAxis] = preventedOffset; + data[mainAxis] = preventedOffset - offset2; + } + if (checkAltAxis) { + var _offsetModifierState$2; + var _mainSide = mainAxis === "x" ? top : left; + var _altSide = mainAxis === "x" ? bottom : right; + var _offset = popperOffsets2[altAxis]; + var _len = altAxis === "y" ? "height" : "width"; + var _min = _offset + overflow[_mainSide]; + var _max = _offset - overflow[_altSide]; + var isOriginSide = [top, left].indexOf(basePlacement) !== -1; + var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0; + var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis; + var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max; + var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max); + popperOffsets2[altAxis] = _preventedOffset; + data[altAxis] = _preventedOffset - _offset; + } + state.modifiersData[name] = data; +} +var preventOverflow$1 = { + name: "preventOverflow", + enabled: true, + phase: "main", + fn: preventOverflow, + requiresIfExists: ["offset"] +}; +function getHTMLElementScroll(element) { + return { + scrollLeft: element.scrollLeft, + scrollTop: element.scrollTop + }; +} +function getNodeScroll(node) { + if (node === getWindow(node) || !isHTMLElement(node)) { + return getWindowScroll(node); + } else { + return getHTMLElementScroll(node); + } +} +function isElementScaled(element) { + var rect = element.getBoundingClientRect(); + var scaleX = round(rect.width) / element.offsetWidth || 1; + var scaleY = round(rect.height) / element.offsetHeight || 1; + return scaleX !== 1 || scaleY !== 1; +} +function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { + if (isFixed === void 0) { + isFixed = false; + } + var isOffsetParentAnElement = isHTMLElement(offsetParent); + var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent); + var documentElement = getDocumentElement(offsetParent); + var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled); + var scroll = { + scrollLeft: 0, + scrollTop: 0 + }; + var offsets = { + x: 0, + y: 0 + }; + if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { + if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) { + scroll = getNodeScroll(offsetParent); + } + if (isHTMLElement(offsetParent)) { + offsets = getBoundingClientRect(offsetParent, true); + offsets.x += offsetParent.clientLeft; + offsets.y += offsetParent.clientTop; + } else if (documentElement) { + offsets.x = getWindowScrollBarX(documentElement); + } + } + return { + x: rect.left + scroll.scrollLeft - offsets.x, + y: rect.top + scroll.scrollTop - offsets.y, + width: rect.width, + height: rect.height + }; +} +function order(modifiers) { + var map = /* @__PURE__ */ new Map(); + var visited = /* @__PURE__ */ new Set(); + var result = []; + modifiers.forEach(function(modifier) { + map.set(modifier.name, modifier); + }); + function sort(modifier) { + visited.add(modifier.name); + var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); + requires.forEach(function(dep) { + if (!visited.has(dep)) { + var depModifier = map.get(dep); + if (depModifier) { + sort(depModifier); + } + } + }); + result.push(modifier); + } + modifiers.forEach(function(modifier) { + if (!visited.has(modifier.name)) { + sort(modifier); + } + }); + return result; +} +function orderModifiers(modifiers) { + var orderedModifiers = order(modifiers); + return modifierPhases.reduce(function(acc, phase) { + return acc.concat(orderedModifiers.filter(function(modifier) { + return modifier.phase === phase; + })); + }, []); +} +function debounce$1(fn2) { + var pending; + return function() { + if (!pending) { + pending = new Promise(function(resolve) { + Promise.resolve().then(function() { + pending = void 0; + resolve(fn2()); + }); + }); + } + return pending; + }; +} +function mergeByName(modifiers) { + var merged = modifiers.reduce(function(merged2, current) { + var existing = merged2[current.name]; + merged2[current.name] = existing ? Object.assign({}, existing, current, { + options: Object.assign({}, existing.options, current.options), + data: Object.assign({}, existing.data, current.data) + }) : current; + return merged2; + }, {}); + return Object.keys(merged).map(function(key) { + return merged[key]; + }); +} +var DEFAULT_OPTIONS = { + placement: "bottom", + modifiers: [], + strategy: "absolute" +}; +function areValidElements() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return !args.some(function(element) { + return !(element && typeof element.getBoundingClientRect === "function"); + }); +} +function popperGenerator(generatorOptions) { + if (generatorOptions === void 0) { + generatorOptions = {}; + } + var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; + return function createPopper2(reference2, popper2, options) { + if (options === void 0) { + options = defaultOptions; + } + var state = { + placement: "bottom", + orderedModifiers: [], + options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), + modifiersData: {}, + elements: { + reference: reference2, + popper: popper2 + }, + attributes: {}, + styles: {} + }; + var effectCleanupFns = []; + var isDestroyed = false; + var instance = { + state, + setOptions: function setOptions(setOptionsAction) { + var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction; + cleanupModifierEffects(); + state.options = Object.assign({}, defaultOptions, state.options, options2); + state.scrollParents = { + reference: isElement$1(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [], + popper: listScrollParents(popper2) + }; + var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers))); + state.orderedModifiers = orderedModifiers.filter(function(m) { + return m.enabled; + }); + runModifierEffects(); + return instance.update(); + }, + forceUpdate: function forceUpdate() { + if (isDestroyed) { + return; + } + var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper; + if (!areValidElements(reference3, popper3)) { + return; + } + state.rects = { + reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"), + popper: getLayoutRect(popper3) + }; + state.reset = false; + state.placement = state.options.placement; + state.orderedModifiers.forEach(function(modifier) { + return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); + }); + for (var index2 = 0; index2 < state.orderedModifiers.length; index2++) { + if (state.reset === true) { + state.reset = false; + index2 = -1; + continue; + } + var _state$orderedModifie = state.orderedModifiers[index2], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name; + if (typeof fn2 === "function") { + state = fn2({ + state, + options: _options, + name, + instance + }) || state; + } + } + }, + update: debounce$1(function() { + return new Promise(function(resolve) { + instance.forceUpdate(); + resolve(state); + }); + }), + destroy: function destroy() { + cleanupModifierEffects(); + isDestroyed = true; + } + }; + if (!areValidElements(reference2, popper2)) { + return instance; + } + instance.setOptions(options).then(function(state2) { + if (!isDestroyed && options.onFirstUpdate) { + options.onFirstUpdate(state2); + } + }); + function runModifierEffects() { + state.orderedModifiers.forEach(function(_ref3) { + var name = _ref3.name, _ref3$options = _ref3.options, options2 = _ref3$options === void 0 ? {} : _ref3$options, effect3 = _ref3.effect; + if (typeof effect3 === "function") { + var cleanupFn = effect3({ + state, + name, + instance, + options: options2 + }); + var noopFn = function noopFn2() { + }; + effectCleanupFns.push(cleanupFn || noopFn); + } + }); + } + function cleanupModifierEffects() { + effectCleanupFns.forEach(function(fn2) { + return fn2(); + }); + effectCleanupFns = []; + } + return instance; + }; +} +var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; +var createPopper = /* @__PURE__ */ popperGenerator({ + defaultModifiers +}); +var BOX_CLASS = "tippy-box"; +var CONTENT_CLASS = "tippy-content"; +var BACKDROP_CLASS = "tippy-backdrop"; +var ARROW_CLASS = "tippy-arrow"; +var SVG_ARROW_CLASS = "tippy-svg-arrow"; +var TOUCH_OPTIONS = { + passive: true, + capture: true +}; +var TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO2() { + return document.body; +}; +function getValueAtIndexOrReturn(value, index2, defaultValue) { + if (Array.isArray(value)) { + var v = value[index2]; + return v == null ? Array.isArray(defaultValue) ? defaultValue[index2] : defaultValue : v; + } + return value; +} +function isType(value, type) { + var str = {}.toString.call(value); + return str.indexOf("[object") === 0 && str.indexOf(type + "]") > -1; +} +function invokeWithArgsOrReturn(value, args) { + return typeof value === "function" ? value.apply(void 0, args) : value; +} +function debounce(fn2, ms) { + if (ms === 0) { + return fn2; + } + var timeout; + return function(arg) { + clearTimeout(timeout); + timeout = setTimeout(function() { + fn2(arg); + }, ms); + }; +} +function removeProperties(obj, keys) { + var clone = Object.assign({}, obj); + keys.forEach(function(key) { + delete clone[key]; + }); + return clone; +} +function splitBySpaces(value) { + return value.split(/\s+/).filter(Boolean); +} +function normalizeToArray(value) { + return [].concat(value); +} +function pushIfUnique(arr, value) { + if (arr.indexOf(value) === -1) { + arr.push(value); + } +} +function unique(arr) { + return arr.filter(function(item, index2) { + return arr.indexOf(item) === index2; + }); +} +function getBasePlacement(placement) { + return placement.split("-")[0]; +} +function arrayFrom(value) { + return [].slice.call(value); +} +function removeUndefinedProps(obj) { + return Object.keys(obj).reduce(function(acc, key) { + if (obj[key] !== void 0) { + acc[key] = obj[key]; + } + return acc; + }, {}); +} +function div() { + return document.createElement("div"); +} +function isElement(value) { + return ["Element", "Fragment"].some(function(type) { + return isType(value, type); + }); +} +function isNodeList(value) { + return isType(value, "NodeList"); +} +function isMouseEvent(value) { + return isType(value, "MouseEvent"); +} +function isReferenceElement(value) { + return !!(value && value._tippy && value._tippy.reference === value); +} +function getArrayOfElements(value) { + if (isElement(value)) { + return [value]; + } + if (isNodeList(value)) { + return arrayFrom(value); + } + if (Array.isArray(value)) { + return value; + } + return arrayFrom(document.querySelectorAll(value)); +} +function setTransitionDuration(els, value) { + els.forEach(function(el) { + if (el) { + el.style.transitionDuration = value + "ms"; + } + }); +} +function setVisibilityState(els, state) { + els.forEach(function(el) { + if (el) { + el.setAttribute("data-state", state); + } + }); +} +function getOwnerDocument(elementOrElements) { + var _element$ownerDocumen; + var _normalizeToArray = normalizeToArray(elementOrElements), element = _normalizeToArray[0]; + return element != null && (_element$ownerDocumen = element.ownerDocument) != null && _element$ownerDocumen.body ? element.ownerDocument : document; +} +function isCursorOutsideInteractiveBorder(popperTreeData, event) { + var clientX = event.clientX, clientY = event.clientY; + return popperTreeData.every(function(_ref) { + var popperRect = _ref.popperRect, popperState = _ref.popperState, props = _ref.props; + var interactiveBorder = props.interactiveBorder; + var basePlacement = getBasePlacement(popperState.placement); + var offsetData = popperState.modifiersData.offset; + if (!offsetData) { + return true; + } + var topDistance = basePlacement === "bottom" ? offsetData.top.y : 0; + var bottomDistance = basePlacement === "top" ? offsetData.bottom.y : 0; + var leftDistance = basePlacement === "right" ? offsetData.left.x : 0; + var rightDistance = basePlacement === "left" ? offsetData.right.x : 0; + var exceedsTop = popperRect.top - clientY + topDistance > interactiveBorder; + var exceedsBottom = clientY - popperRect.bottom - bottomDistance > interactiveBorder; + var exceedsLeft = popperRect.left - clientX + leftDistance > interactiveBorder; + var exceedsRight = clientX - popperRect.right - rightDistance > interactiveBorder; + return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight; + }); +} +function updateTransitionEndListener(box, action, listener) { + var method = action + "EventListener"; + ["transitionend", "webkitTransitionEnd"].forEach(function(event) { + box[method](event, listener); + }); +} +function actualContains(parent, child) { + var target = child; + while (target) { + var _target$getRootNode; + if (parent.contains(target)) { + return true; + } + target = target.getRootNode == null ? void 0 : (_target$getRootNode = target.getRootNode()) == null ? void 0 : _target$getRootNode.host; + } + return false; +} +var currentInput = { + isTouch: false +}; +var lastMouseMoveTime = 0; +function onDocumentTouchStart() { + if (currentInput.isTouch) { + return; + } + currentInput.isTouch = true; + if (window.performance) { + document.addEventListener("mousemove", onDocumentMouseMove); + } +} +function onDocumentMouseMove() { + var now = performance.now(); + if (now - lastMouseMoveTime < 20) { + currentInput.isTouch = false; + document.removeEventListener("mousemove", onDocumentMouseMove); + } + lastMouseMoveTime = now; +} +function onWindowBlur() { + var activeElement = document.activeElement; + if (isReferenceElement(activeElement)) { + var instance = activeElement._tippy; + if (activeElement.blur && !instance.state.isVisible) { + activeElement.blur(); + } + } +} +function bindGlobalEventListeners() { + document.addEventListener("touchstart", onDocumentTouchStart, TOUCH_OPTIONS); + window.addEventListener("blur", onWindowBlur); +} +var isBrowser = typeof window !== "undefined" && typeof document !== "undefined"; +var isIE11 = isBrowser ? !!window.msCrypto : false; +var pluginProps = { + animateFill: false, + followCursor: false, + inlinePositioning: false, + sticky: false +}; +var renderProps = { + allowHTML: false, + animation: "fade", + arrow: true, + content: "", + inertia: false, + maxWidth: 350, + role: "tooltip", + theme: "", + zIndex: 9999 +}; +var defaultProps = Object.assign({ + appendTo: TIPPY_DEFAULT_APPEND_TO, + aria: { + content: "auto", + expanded: "auto" + }, + delay: 0, + duration: [300, 250], + getReferenceClientRect: null, + hideOnClick: true, + ignoreAttributes: false, + interactive: false, + interactiveBorder: 2, + interactiveDebounce: 0, + moveTransition: "", + offset: [0, 10], + onAfterUpdate: function onAfterUpdate() { + }, + onBeforeUpdate: function onBeforeUpdate() { + }, + onCreate: function onCreate() { + }, + onDestroy: function onDestroy() { + }, + onHidden: function onHidden() { + }, + onHide: function onHide() { + }, + onMount: function onMount() { + }, + onShow: function onShow() { + }, + onShown: function onShown() { + }, + onTrigger: function onTrigger() { + }, + onUntrigger: function onUntrigger() { + }, + onClickOutside: function onClickOutside() { + }, + placement: "top", + plugins: [], + popperOptions: {}, + render: null, + showOnCreate: false, + touch: true, + trigger: "mouseenter focus", + triggerTarget: null +}, pluginProps, renderProps); +var defaultKeys = Object.keys(defaultProps); +var setDefaultProps = function setDefaultProps2(partialProps) { + var keys = Object.keys(partialProps); + keys.forEach(function(key) { + defaultProps[key] = partialProps[key]; + }); +}; +function getExtendedPassedProps(passedProps) { + var plugins = passedProps.plugins || []; + var pluginProps2 = plugins.reduce(function(acc, plugin) { + var name = plugin.name, defaultValue = plugin.defaultValue; + if (name) { + var _name; + acc[name] = passedProps[name] !== void 0 ? passedProps[name] : (_name = defaultProps[name]) != null ? _name : defaultValue; + } + return acc; + }, {}); + return Object.assign({}, passedProps, pluginProps2); +} +function getDataAttributeProps(reference2, plugins) { + var propKeys = plugins ? Object.keys(getExtendedPassedProps(Object.assign({}, defaultProps, { + plugins + }))) : defaultKeys; + var props = propKeys.reduce(function(acc, key) { + var valueAsString = (reference2.getAttribute("data-tippy-" + key) || "").trim(); + if (!valueAsString) { + return acc; + } + if (key === "content") { + acc[key] = valueAsString; + } else { + try { + acc[key] = JSON.parse(valueAsString); + } catch (e) { + acc[key] = valueAsString; + } + } + return acc; + }, {}); + return props; +} +function evaluateProps(reference2, props) { + var out = Object.assign({}, props, { + content: invokeWithArgsOrReturn(props.content, [reference2]) + }, props.ignoreAttributes ? {} : getDataAttributeProps(reference2, props.plugins)); + out.aria = Object.assign({}, defaultProps.aria, out.aria); + out.aria = { + expanded: out.aria.expanded === "auto" ? props.interactive : out.aria.expanded, + content: out.aria.content === "auto" ? props.interactive ? null : "describedby" : out.aria.content + }; + return out; +} +var innerHTML = function innerHTML2() { + return "innerHTML"; +}; +function dangerouslySetInnerHTML(element, html) { + element[innerHTML()] = html; +} +function createArrowElement(value) { + var arrow2 = div(); + if (value === true) { + arrow2.className = ARROW_CLASS; + } else { + arrow2.className = SVG_ARROW_CLASS; + if (isElement(value)) { + arrow2.appendChild(value); + } else { + dangerouslySetInnerHTML(arrow2, value); + } + } + return arrow2; +} +function setContent(content, props) { + if (isElement(props.content)) { + dangerouslySetInnerHTML(content, ""); + content.appendChild(props.content); + } else if (typeof props.content !== "function") { + if (props.allowHTML) { + dangerouslySetInnerHTML(content, props.content); + } else { + content.textContent = props.content; + } + } +} +function getChildren(popper2) { + var box = popper2.firstElementChild; + var boxChildren = arrayFrom(box.children); + return { + box, + content: boxChildren.find(function(node) { + return node.classList.contains(CONTENT_CLASS); + }), + arrow: boxChildren.find(function(node) { + return node.classList.contains(ARROW_CLASS) || node.classList.contains(SVG_ARROW_CLASS); + }), + backdrop: boxChildren.find(function(node) { + return node.classList.contains(BACKDROP_CLASS); + }) + }; +} +function render(instance) { + var popper2 = div(); + var box = div(); + box.className = BOX_CLASS; + box.setAttribute("data-state", "hidden"); + box.setAttribute("tabindex", "-1"); + var content = div(); + content.className = CONTENT_CLASS; + content.setAttribute("data-state", "hidden"); + setContent(content, instance.props); + popper2.appendChild(box); + box.appendChild(content); + onUpdate(instance.props, instance.props); + function onUpdate(prevProps, nextProps) { + var _getChildren = getChildren(popper2), box2 = _getChildren.box, content2 = _getChildren.content, arrow2 = _getChildren.arrow; + if (nextProps.theme) { + box2.setAttribute("data-theme", nextProps.theme); + } else { + box2.removeAttribute("data-theme"); + } + if (typeof nextProps.animation === "string") { + box2.setAttribute("data-animation", nextProps.animation); + } else { + box2.removeAttribute("data-animation"); + } + if (nextProps.inertia) { + box2.setAttribute("data-inertia", ""); + } else { + box2.removeAttribute("data-inertia"); + } + box2.style.maxWidth = typeof nextProps.maxWidth === "number" ? nextProps.maxWidth + "px" : nextProps.maxWidth; + if (nextProps.role) { + box2.setAttribute("role", nextProps.role); + } else { + box2.removeAttribute("role"); + } + if (prevProps.content !== nextProps.content || prevProps.allowHTML !== nextProps.allowHTML) { + setContent(content2, instance.props); + } + if (nextProps.arrow) { + if (!arrow2) { + box2.appendChild(createArrowElement(nextProps.arrow)); + } else if (prevProps.arrow !== nextProps.arrow) { + box2.removeChild(arrow2); + box2.appendChild(createArrowElement(nextProps.arrow)); + } + } else if (arrow2) { + box2.removeChild(arrow2); + } + } + return { + popper: popper2, + onUpdate + }; +} +render.$$tippy = true; +var idCounter = 1; +var mouseMoveListeners = []; +var mountedInstances = []; +function createTippy(reference2, passedProps) { + var props = evaluateProps(reference2, Object.assign({}, defaultProps, getExtendedPassedProps(removeUndefinedProps(passedProps)))); + var showTimeout; + var hideTimeout; + var scheduleHideAnimationFrame; + var isVisibleFromClick = false; + var didHideDueToDocumentMouseDown = false; + var didTouchMove = false; + var ignoreOnFirstUpdate = false; + var lastTriggerEvent; + var currentTransitionEndListener; + var onFirstUpdate; + var listeners = []; + var debouncedOnMouseMove = debounce(onMouseMove, props.interactiveDebounce); + var currentTarget; + var id = idCounter++; + var popperInstance = null; + var plugins = unique(props.plugins); + var state = { + isEnabled: true, + isVisible: false, + isDestroyed: false, + isMounted: false, + isShown: false + }; + var instance = { + id, + reference: reference2, + popper: div(), + popperInstance, + props, + state, + plugins, + clearDelayTimeouts, + setProps, + setContent: setContent2, + show, + hide: hide2, + hideWithInteractivity, + enable, + disable, + unmount, + destroy + }; + if (!props.render) { + return instance; + } + var _props$render = props.render(instance), popper2 = _props$render.popper, onUpdate = _props$render.onUpdate; + popper2.setAttribute("data-tippy-root", ""); + popper2.id = "tippy-" + instance.id; + instance.popper = popper2; + reference2._tippy = instance; + popper2._tippy = instance; + var pluginsHooks = plugins.map(function(plugin) { + return plugin.fn(instance); + }); + var hasAriaExpanded = reference2.hasAttribute("aria-expanded"); + addListeners(); + handleAriaExpandedAttribute(); + handleStyles(); + invokeHook("onCreate", [instance]); + if (props.showOnCreate) { + scheduleShow(); + } + popper2.addEventListener("mouseenter", function() { + if (instance.props.interactive && instance.state.isVisible) { + instance.clearDelayTimeouts(); + } + }); + popper2.addEventListener("mouseleave", function() { + if (instance.props.interactive && instance.props.trigger.indexOf("mouseenter") >= 0) { + getDocument().addEventListener("mousemove", debouncedOnMouseMove); + } + }); + return instance; + function getNormalizedTouchSettings() { + var touch = instance.props.touch; + return Array.isArray(touch) ? touch : [touch, 0]; + } + function getIsCustomTouchBehavior() { + return getNormalizedTouchSettings()[0] === "hold"; + } + function getIsDefaultRenderFn() { + var _instance$props$rende; + return !!((_instance$props$rende = instance.props.render) != null && _instance$props$rende.$$tippy); + } + function getCurrentTarget() { + return currentTarget || reference2; + } + function getDocument() { + var parent = getCurrentTarget().parentNode; + return parent ? getOwnerDocument(parent) : document; + } + function getDefaultTemplateChildren() { + return getChildren(popper2); + } + function getDelay(isShow) { + if (instance.state.isMounted && !instance.state.isVisible || currentInput.isTouch || lastTriggerEvent && lastTriggerEvent.type === "focus") { + return 0; + } + return getValueAtIndexOrReturn(instance.props.delay, isShow ? 0 : 1, defaultProps.delay); + } + function handleStyles(fromHide) { + if (fromHide === void 0) { + fromHide = false; + } + popper2.style.pointerEvents = instance.props.interactive && !fromHide ? "" : "none"; + popper2.style.zIndex = "" + instance.props.zIndex; + } + function invokeHook(hook, args, shouldInvokePropsHook) { + if (shouldInvokePropsHook === void 0) { + shouldInvokePropsHook = true; + } + pluginsHooks.forEach(function(pluginHooks) { + if (pluginHooks[hook]) { + pluginHooks[hook].apply(pluginHooks, args); + } + }); + if (shouldInvokePropsHook) { + var _instance$props; + (_instance$props = instance.props)[hook].apply(_instance$props, args); + } + } + function handleAriaContentAttribute() { + var aria = instance.props.aria; + if (!aria.content) { + return; + } + var attr = "aria-" + aria.content; + var id2 = popper2.id; + var nodes = normalizeToArray(instance.props.triggerTarget || reference2); + nodes.forEach(function(node) { + var currentValue = node.getAttribute(attr); + if (instance.state.isVisible) { + node.setAttribute(attr, currentValue ? currentValue + " " + id2 : id2); + } else { + var nextValue = currentValue && currentValue.replace(id2, "").trim(); + if (nextValue) { + node.setAttribute(attr, nextValue); + } else { + node.removeAttribute(attr); + } + } + }); + } + function handleAriaExpandedAttribute() { + if (hasAriaExpanded || !instance.props.aria.expanded) { + return; + } + var nodes = normalizeToArray(instance.props.triggerTarget || reference2); + nodes.forEach(function(node) { + if (instance.props.interactive) { + node.setAttribute("aria-expanded", instance.state.isVisible && node === getCurrentTarget() ? "true" : "false"); + } else { + node.removeAttribute("aria-expanded"); + } + }); + } + function cleanupInteractiveMouseListeners() { + getDocument().removeEventListener("mousemove", debouncedOnMouseMove); + mouseMoveListeners = mouseMoveListeners.filter(function(listener) { + return listener !== debouncedOnMouseMove; + }); + } + function onDocumentPress(event) { + if (currentInput.isTouch) { + if (didTouchMove || event.type === "mousedown") { + return; + } + } + var actualTarget = event.composedPath && event.composedPath()[0] || event.target; + if (instance.props.interactive && actualContains(popper2, actualTarget)) { + return; + } + if (normalizeToArray(instance.props.triggerTarget || reference2).some(function(el) { + return actualContains(el, actualTarget); + })) { + if (currentInput.isTouch) { + return; + } + if (instance.state.isVisible && instance.props.trigger.indexOf("click") >= 0) { + return; + } + } else { + invokeHook("onClickOutside", [instance, event]); + } + if (instance.props.hideOnClick === true) { + instance.clearDelayTimeouts(); + instance.hide(); + didHideDueToDocumentMouseDown = true; + setTimeout(function() { + didHideDueToDocumentMouseDown = false; + }); + if (!instance.state.isMounted) { + removeDocumentPress(); + } + } + } + function onTouchMove() { + didTouchMove = true; + } + function onTouchStart() { + didTouchMove = false; + } + function addDocumentPress() { + var doc = getDocument(); + doc.addEventListener("mousedown", onDocumentPress, true); + doc.addEventListener("touchend", onDocumentPress, TOUCH_OPTIONS); + doc.addEventListener("touchstart", onTouchStart, TOUCH_OPTIONS); + doc.addEventListener("touchmove", onTouchMove, TOUCH_OPTIONS); + } + function removeDocumentPress() { + var doc = getDocument(); + doc.removeEventListener("mousedown", onDocumentPress, true); + doc.removeEventListener("touchend", onDocumentPress, TOUCH_OPTIONS); + doc.removeEventListener("touchstart", onTouchStart, TOUCH_OPTIONS); + doc.removeEventListener("touchmove", onTouchMove, TOUCH_OPTIONS); + } + function onTransitionedOut(duration, callback) { + onTransitionEnd(duration, function() { + if (!instance.state.isVisible && popper2.parentNode && popper2.parentNode.contains(popper2)) { + callback(); + } + }); + } + function onTransitionedIn(duration, callback) { + onTransitionEnd(duration, callback); + } + function onTransitionEnd(duration, callback) { + var box = getDefaultTemplateChildren().box; + function listener(event) { + if (event.target === box) { + updateTransitionEndListener(box, "remove", listener); + callback(); + } + } + if (duration === 0) { + return callback(); + } + updateTransitionEndListener(box, "remove", currentTransitionEndListener); + updateTransitionEndListener(box, "add", listener); + currentTransitionEndListener = listener; + } + function on(eventType, handler, options) { + if (options === void 0) { + options = false; + } + var nodes = normalizeToArray(instance.props.triggerTarget || reference2); + nodes.forEach(function(node) { + node.addEventListener(eventType, handler, options); + listeners.push({ + node, + eventType, + handler, + options + }); + }); + } + function addListeners() { + if (getIsCustomTouchBehavior()) { + on("touchstart", onTrigger2, { + passive: true + }); + on("touchend", onMouseLeave, { + passive: true + }); + } + splitBySpaces(instance.props.trigger).forEach(function(eventType) { + if (eventType === "manual") { + return; + } + on(eventType, onTrigger2); + switch (eventType) { + case "mouseenter": + on("mouseleave", onMouseLeave); + break; + case "focus": + on(isIE11 ? "focusout" : "blur", onBlurOrFocusOut); + break; + case "focusin": + on("focusout", onBlurOrFocusOut); + break; + } + }); + } + function removeListeners() { + listeners.forEach(function(_ref) { + var node = _ref.node, eventType = _ref.eventType, handler = _ref.handler, options = _ref.options; + node.removeEventListener(eventType, handler, options); + }); + listeners = []; + } + function onTrigger2(event) { + var _lastTriggerEvent; + var shouldScheduleClickHide = false; + if (!instance.state.isEnabled || isEventListenerStopped(event) || didHideDueToDocumentMouseDown) { + return; + } + var wasFocused = ((_lastTriggerEvent = lastTriggerEvent) == null ? void 0 : _lastTriggerEvent.type) === "focus"; + lastTriggerEvent = event; + currentTarget = event.currentTarget; + handleAriaExpandedAttribute(); + if (!instance.state.isVisible && isMouseEvent(event)) { + mouseMoveListeners.forEach(function(listener) { + return listener(event); + }); + } + if (event.type === "click" && (instance.props.trigger.indexOf("mouseenter") < 0 || isVisibleFromClick) && instance.props.hideOnClick !== false && instance.state.isVisible) { + shouldScheduleClickHide = true; + } else { + scheduleShow(event); + } + if (event.type === "click") { + isVisibleFromClick = !shouldScheduleClickHide; + } + if (shouldScheduleClickHide && !wasFocused) { + scheduleHide(event); + } + } + function onMouseMove(event) { + var target = event.target; + var isCursorOverReferenceOrPopper = getCurrentTarget().contains(target) || popper2.contains(target); + if (event.type === "mousemove" && isCursorOverReferenceOrPopper) { + return; + } + var popperTreeData = getNestedPopperTree().concat(popper2).map(function(popper3) { + var _instance$popperInsta; + var instance2 = popper3._tippy; + var state2 = (_instance$popperInsta = instance2.popperInstance) == null ? void 0 : _instance$popperInsta.state; + if (state2) { + return { + popperRect: popper3.getBoundingClientRect(), + popperState: state2, + props + }; + } + return null; + }).filter(Boolean); + if (isCursorOutsideInteractiveBorder(popperTreeData, event)) { + cleanupInteractiveMouseListeners(); + scheduleHide(event); + } + } + function onMouseLeave(event) { + var shouldBail = isEventListenerStopped(event) || instance.props.trigger.indexOf("click") >= 0 && isVisibleFromClick; + if (shouldBail) { + return; + } + if (instance.props.interactive) { + instance.hideWithInteractivity(event); + return; + } + scheduleHide(event); + } + function onBlurOrFocusOut(event) { + if (instance.props.trigger.indexOf("focusin") < 0 && event.target !== getCurrentTarget()) { + return; + } + if (instance.props.interactive && event.relatedTarget && popper2.contains(event.relatedTarget)) { + return; + } + scheduleHide(event); + } + function isEventListenerStopped(event) { + return currentInput.isTouch ? getIsCustomTouchBehavior() !== event.type.indexOf("touch") >= 0 : false; + } + function createPopperInstance() { + destroyPopperInstance(); + var _instance$props2 = instance.props, popperOptions = _instance$props2.popperOptions, placement = _instance$props2.placement, offset2 = _instance$props2.offset, getReferenceClientRect = _instance$props2.getReferenceClientRect, moveTransition = _instance$props2.moveTransition; + var arrow2 = getIsDefaultRenderFn() ? getChildren(popper2).arrow : null; + var computedReference = getReferenceClientRect ? { + getBoundingClientRect: getReferenceClientRect, + contextElement: getReferenceClientRect.contextElement || getCurrentTarget() + } : reference2; + var tippyModifier = { + name: "$$tippy", + enabled: true, + phase: "beforeWrite", + requires: ["computeStyles"], + fn: function fn2(_ref2) { + var state2 = _ref2.state; + if (getIsDefaultRenderFn()) { + var _getDefaultTemplateCh = getDefaultTemplateChildren(), box = _getDefaultTemplateCh.box; + ["placement", "reference-hidden", "escaped"].forEach(function(attr) { + if (attr === "placement") { + box.setAttribute("data-placement", state2.placement); + } else { + if (state2.attributes.popper["data-popper-" + attr]) { + box.setAttribute("data-" + attr, ""); + } else { + box.removeAttribute("data-" + attr); + } + } + }); + state2.attributes.popper = {}; + } + } + }; + var modifiers = [{ + name: "offset", + options: { + offset: offset2 + } + }, { + name: "preventOverflow", + options: { + padding: { + top: 2, + bottom: 2, + left: 5, + right: 5 + } + } + }, { + name: "flip", + options: { + padding: 5 + } + }, { + name: "computeStyles", + options: { + adaptive: !moveTransition + } + }, tippyModifier]; + if (getIsDefaultRenderFn() && arrow2) { + modifiers.push({ + name: "arrow", + options: { + element: arrow2, + padding: 3 + } + }); + } + modifiers.push.apply(modifiers, (popperOptions == null ? void 0 : popperOptions.modifiers) || []); + instance.popperInstance = createPopper(computedReference, popper2, Object.assign({}, popperOptions, { + placement, + onFirstUpdate, + modifiers + })); + } + function destroyPopperInstance() { + if (instance.popperInstance) { + instance.popperInstance.destroy(); + instance.popperInstance = null; + } + } + function mount() { + var appendTo = instance.props.appendTo; + var parentNode; + var node = getCurrentTarget(); + if (instance.props.interactive && appendTo === TIPPY_DEFAULT_APPEND_TO || appendTo === "parent") { + parentNode = node.parentNode; + } else { + parentNode = invokeWithArgsOrReturn(appendTo, [node]); + } + if (!parentNode.contains(popper2)) { + parentNode.appendChild(popper2); + } + instance.state.isMounted = true; + createPopperInstance(); + } + function getNestedPopperTree() { + return arrayFrom(popper2.querySelectorAll("[data-tippy-root]")); + } + function scheduleShow(event) { + instance.clearDelayTimeouts(); + if (event) { + invokeHook("onTrigger", [instance, event]); + } + addDocumentPress(); + var delay = getDelay(true); + var _getNormalizedTouchSe = getNormalizedTouchSettings(), touchValue = _getNormalizedTouchSe[0], touchDelay = _getNormalizedTouchSe[1]; + if (currentInput.isTouch && touchValue === "hold" && touchDelay) { + delay = touchDelay; + } + if (delay) { + showTimeout = setTimeout(function() { + instance.show(); + }, delay); + } else { + instance.show(); + } + } + function scheduleHide(event) { + instance.clearDelayTimeouts(); + invokeHook("onUntrigger", [instance, event]); + if (!instance.state.isVisible) { + removeDocumentPress(); + return; + } + if (instance.props.trigger.indexOf("mouseenter") >= 0 && instance.props.trigger.indexOf("click") >= 0 && ["mouseleave", "mousemove"].indexOf(event.type) >= 0 && isVisibleFromClick) { + return; + } + var delay = getDelay(false); + if (delay) { + hideTimeout = setTimeout(function() { + if (instance.state.isVisible) { + instance.hide(); + } + }, delay); + } else { + scheduleHideAnimationFrame = requestAnimationFrame(function() { + instance.hide(); + }); + } + } + function enable() { + instance.state.isEnabled = true; + } + function disable() { + instance.hide(); + instance.state.isEnabled = false; + } + function clearDelayTimeouts() { + clearTimeout(showTimeout); + clearTimeout(hideTimeout); + cancelAnimationFrame(scheduleHideAnimationFrame); + } + function setProps(partialProps) { + if (instance.state.isDestroyed) { + return; + } + invokeHook("onBeforeUpdate", [instance, partialProps]); + removeListeners(); + var prevProps = instance.props; + var nextProps = evaluateProps(reference2, Object.assign({}, prevProps, removeUndefinedProps(partialProps), { + ignoreAttributes: true + })); + instance.props = nextProps; + addListeners(); + if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) { + cleanupInteractiveMouseListeners(); + debouncedOnMouseMove = debounce(onMouseMove, nextProps.interactiveDebounce); + } + if (prevProps.triggerTarget && !nextProps.triggerTarget) { + normalizeToArray(prevProps.triggerTarget).forEach(function(node) { + node.removeAttribute("aria-expanded"); + }); + } else if (nextProps.triggerTarget) { + reference2.removeAttribute("aria-expanded"); + } + handleAriaExpandedAttribute(); + handleStyles(); + if (onUpdate) { + onUpdate(prevProps, nextProps); + } + if (instance.popperInstance) { + createPopperInstance(); + getNestedPopperTree().forEach(function(nestedPopper) { + requestAnimationFrame(nestedPopper._tippy.popperInstance.forceUpdate); + }); + } + invokeHook("onAfterUpdate", [instance, partialProps]); + } + function setContent2(content) { + instance.setProps({ + content + }); + } + function show() { + var isAlreadyVisible = instance.state.isVisible; + var isDestroyed = instance.state.isDestroyed; + var isDisabled = !instance.state.isEnabled; + var isTouchAndTouchDisabled = currentInput.isTouch && !instance.props.touch; + var duration = getValueAtIndexOrReturn(instance.props.duration, 0, defaultProps.duration); + if (isAlreadyVisible || isDestroyed || isDisabled || isTouchAndTouchDisabled) { + return; + } + if (getCurrentTarget().hasAttribute("disabled")) { + return; + } + invokeHook("onShow", [instance], false); + if (instance.props.onShow(instance) === false) { + return; + } + instance.state.isVisible = true; + if (getIsDefaultRenderFn()) { + popper2.style.visibility = "visible"; + } + handleStyles(); + addDocumentPress(); + if (!instance.state.isMounted) { + popper2.style.transition = "none"; + } + if (getIsDefaultRenderFn()) { + var _getDefaultTemplateCh2 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh2.box, content = _getDefaultTemplateCh2.content; + setTransitionDuration([box, content], 0); + } + onFirstUpdate = function onFirstUpdate2() { + var _instance$popperInsta2; + if (!instance.state.isVisible || ignoreOnFirstUpdate) { + return; + } + ignoreOnFirstUpdate = true; + void popper2.offsetHeight; + popper2.style.transition = instance.props.moveTransition; + if (getIsDefaultRenderFn() && instance.props.animation) { + var _getDefaultTemplateCh3 = getDefaultTemplateChildren(), _box = _getDefaultTemplateCh3.box, _content = _getDefaultTemplateCh3.content; + setTransitionDuration([_box, _content], duration); + setVisibilityState([_box, _content], "visible"); + } + handleAriaContentAttribute(); + handleAriaExpandedAttribute(); + pushIfUnique(mountedInstances, instance); + (_instance$popperInsta2 = instance.popperInstance) == null ? void 0 : _instance$popperInsta2.forceUpdate(); + invokeHook("onMount", [instance]); + if (instance.props.animation && getIsDefaultRenderFn()) { + onTransitionedIn(duration, function() { + instance.state.isShown = true; + invokeHook("onShown", [instance]); + }); + } + }; + mount(); + } + function hide2() { + var isAlreadyHidden = !instance.state.isVisible; + var isDestroyed = instance.state.isDestroyed; + var isDisabled = !instance.state.isEnabled; + var duration = getValueAtIndexOrReturn(instance.props.duration, 1, defaultProps.duration); + if (isAlreadyHidden || isDestroyed || isDisabled) { + return; + } + invokeHook("onHide", [instance], false); + if (instance.props.onHide(instance) === false) { + return; + } + instance.state.isVisible = false; + instance.state.isShown = false; + ignoreOnFirstUpdate = false; + isVisibleFromClick = false; + if (getIsDefaultRenderFn()) { + popper2.style.visibility = "hidden"; + } + cleanupInteractiveMouseListeners(); + removeDocumentPress(); + handleStyles(true); + if (getIsDefaultRenderFn()) { + var _getDefaultTemplateCh4 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh4.box, content = _getDefaultTemplateCh4.content; + if (instance.props.animation) { + setTransitionDuration([box, content], duration); + setVisibilityState([box, content], "hidden"); + } + } + handleAriaContentAttribute(); + handleAriaExpandedAttribute(); + if (instance.props.animation) { + if (getIsDefaultRenderFn()) { + onTransitionedOut(duration, instance.unmount); + } + } else { + instance.unmount(); + } + } + function hideWithInteractivity(event) { + getDocument().addEventListener("mousemove", debouncedOnMouseMove); + pushIfUnique(mouseMoveListeners, debouncedOnMouseMove); + debouncedOnMouseMove(event); + } + function unmount() { + if (instance.state.isVisible) { + instance.hide(); + } + if (!instance.state.isMounted) { + return; + } + destroyPopperInstance(); + getNestedPopperTree().forEach(function(nestedPopper) { + nestedPopper._tippy.unmount(); + }); + if (popper2.parentNode) { + popper2.parentNode.removeChild(popper2); + } + mountedInstances = mountedInstances.filter(function(i) { + return i !== instance; + }); + instance.state.isMounted = false; + invokeHook("onHidden", [instance]); + } + function destroy() { + if (instance.state.isDestroyed) { + return; + } + instance.clearDelayTimeouts(); + instance.unmount(); + removeListeners(); + delete reference2._tippy; + instance.state.isDestroyed = true; + invokeHook("onDestroy", [instance]); + } +} +function tippy$1(targets, optionalProps) { + if (optionalProps === void 0) { + optionalProps = {}; + } + var plugins = defaultProps.plugins.concat(optionalProps.plugins || []); + bindGlobalEventListeners(); + var passedProps = Object.assign({}, optionalProps, { + plugins + }); + var elements = getArrayOfElements(targets); + var instances = elements.reduce(function(acc, reference2) { + var instance = reference2 && createTippy(reference2, passedProps); + if (instance) { + acc.push(instance); + } + return acc; + }, []); + return isElement(targets) ? instances[0] : instances; +} +tippy$1.defaultProps = defaultProps; +tippy$1.setDefaultProps = setDefaultProps; +tippy$1.currentInput = currentInput; +var applyStylesModifier = Object.assign({}, applyStyles$1, { + effect: function effect2(_ref) { + var state = _ref.state; + var initialStyles = { + popper: { + position: state.options.strategy, + left: "0", + top: "0", + margin: "0" + }, + arrow: { + position: "absolute" + }, + reference: {} + }; + Object.assign(state.elements.popper.style, initialStyles.popper); + state.styles = initialStyles; + if (state.elements.arrow) { + Object.assign(state.elements.arrow.style, initialStyles.arrow); + } + } +}); +var createSingleton = function createSingleton2(tippyInstances, optionalProps) { + var _optionalProps$popper; + if (optionalProps === void 0) { + optionalProps = {}; + } + var individualInstances = tippyInstances; + var references = []; + var triggerTargets = []; + var currentTarget; + var overrides = optionalProps.overrides; + var interceptSetPropsCleanups = []; + var shownOnCreate = false; + function setTriggerTargets() { + triggerTargets = individualInstances.map(function(instance) { + return normalizeToArray(instance.props.triggerTarget || instance.reference); + }).reduce(function(acc, item) { + return acc.concat(item); + }, []); + } + function setReferences() { + references = individualInstances.map(function(instance) { + return instance.reference; + }); + } + function enableInstances(isEnabled) { + individualInstances.forEach(function(instance) { + if (isEnabled) { + instance.enable(); + } else { + instance.disable(); + } + }); + } + function interceptSetProps(singleton2) { + return individualInstances.map(function(instance) { + var originalSetProps2 = instance.setProps; + instance.setProps = function(props) { + originalSetProps2(props); + if (instance.reference === currentTarget) { + singleton2.setProps(props); + } + }; + return function() { + instance.setProps = originalSetProps2; + }; + }); + } + function prepareInstance(singleton2, target) { + var index2 = triggerTargets.indexOf(target); + if (target === currentTarget) { + return; + } + currentTarget = target; + var overrideProps = (overrides || []).concat("content").reduce(function(acc, prop) { + acc[prop] = individualInstances[index2].props[prop]; + return acc; + }, {}); + singleton2.setProps(Object.assign({}, overrideProps, { + getReferenceClientRect: typeof overrideProps.getReferenceClientRect === "function" ? overrideProps.getReferenceClientRect : function() { + var _references$index; + return (_references$index = references[index2]) == null ? void 0 : _references$index.getBoundingClientRect(); + } + })); + } + enableInstances(false); + setReferences(); + setTriggerTargets(); + var plugin = { + fn: function fn2() { + return { + onDestroy: function onDestroy2() { + enableInstances(true); + }, + onHidden: function onHidden2() { + currentTarget = null; + }, + onClickOutside: function onClickOutside2(instance) { + if (instance.props.showOnCreate && !shownOnCreate) { + shownOnCreate = true; + currentTarget = null; + } + }, + onShow: function onShow2(instance) { + if (instance.props.showOnCreate && !shownOnCreate) { + shownOnCreate = true; + prepareInstance(instance, references[0]); + } + }, + onTrigger: function onTrigger2(instance, event) { + prepareInstance(instance, event.currentTarget); + } + }; + } + }; + var singleton = tippy$1(div(), Object.assign({}, removeProperties(optionalProps, ["overrides"]), { + plugins: [plugin].concat(optionalProps.plugins || []), + triggerTarget: triggerTargets, + popperOptions: Object.assign({}, optionalProps.popperOptions, { + modifiers: [].concat(((_optionalProps$popper = optionalProps.popperOptions) == null ? void 0 : _optionalProps$popper.modifiers) || [], [applyStylesModifier]) + }) + })); + var originalShow = singleton.show; + singleton.show = function(target) { + originalShow(); + if (!currentTarget && target == null) { + return prepareInstance(singleton, references[0]); + } + if (currentTarget && target == null) { + return; + } + if (typeof target === "number") { + return references[target] && prepareInstance(singleton, references[target]); + } + if (individualInstances.indexOf(target) >= 0) { + var ref2 = target.reference; + return prepareInstance(singleton, ref2); + } + if (references.indexOf(target) >= 0) { + return prepareInstance(singleton, target); + } + }; + singleton.showNext = function() { + var first = references[0]; + if (!currentTarget) { + return singleton.show(0); + } + var index2 = references.indexOf(currentTarget); + singleton.show(references[index2 + 1] || first); + }; + singleton.showPrevious = function() { + var last = references[references.length - 1]; + if (!currentTarget) { + return singleton.show(last); + } + var index2 = references.indexOf(currentTarget); + var target = references[index2 - 1] || last; + singleton.show(target); + }; + var originalSetProps = singleton.setProps; + singleton.setProps = function(props) { + overrides = props.overrides || overrides; + originalSetProps(props); + }; + singleton.setInstances = function(nextInstances) { + enableInstances(true); + interceptSetPropsCleanups.forEach(function(fn2) { + return fn2(); + }); + individualInstances = nextInstances; + enableInstances(false); + setReferences(); + setTriggerTargets(); + interceptSetPropsCleanups = interceptSetProps(singleton); + singleton.setProps({ + triggerTarget: triggerTargets + }); + }; + interceptSetPropsCleanups = interceptSetProps(singleton); + return singleton; +}; +tippy$1.setDefaultProps({ + render +}); +var tippy = ""; +var svgArrow = ""; +var CalendarHeatmap_vue_vue_type_style_index_0_lang = ""; +var _export_sfc = (sfc, props) => { + const target = sfc.__vccOpts || sfc; + for (const [key, val] of props) { + target[key] = val; + } + return target; +}; +const _sfc_main = /* @__PURE__ */ defineComponent({ + name: "CalendarHeatmap", + props: { + endDate: { + required: true + }, + max: { + type: Number + }, + rangeColor: { + type: Array + }, + values: { + type: Array, + required: true + }, + locale: { + type: Object + }, + tooltip: { + type: Boolean, + default: true + }, + showFuture: { + type: Boolean, + default: false + }, + tooltipUnit: { + type: String, + default: Heatmap.DEFAULT_TOOLTIP_UNIT + }, + tooltipFormatter: { + type: Function + }, + vertical: { + type: Boolean, + default: false + }, + noDataText: { + type: [Boolean, String], + default: null + }, + round: { + type: Number, + default: 0 + }, + darkMode: Boolean + }, + emits: ["dayClick"], + setup(props) { + const SQUARE_BORDER_SIZE = Heatmap.SQUARE_SIZE / 5, SQUARE_SIZE = Heatmap.SQUARE_SIZE + SQUARE_BORDER_SIZE, LEFT_SECTION_WIDTH = Math.ceil(Heatmap.SQUARE_SIZE * 2.5), RIGHT_SECTION_WIDTH = SQUARE_SIZE * 3, TOP_SECTION_HEIGHT = Heatmap.SQUARE_SIZE + Heatmap.SQUARE_SIZE / 2, BOTTOM_SECTION_HEIGHT = Heatmap.SQUARE_SIZE + Heatmap.SQUARE_SIZE / 2, yearWrapperTransform = `translate(${LEFT_SECTION_WIDTH}, ${TOP_SECTION_HEIGHT})`, svg = ref(null), now = ref(new Date()), heatmap = ref(new Heatmap(props.endDate, props.values, props.max)), width = ref(0), height = ref(0), viewbox = ref("0 0 0 0"), legendViewbox = ref("0 0 0 0"), daysLabelWrapperTransform = ref(""), monthsLabelWrapperTransform = ref(""), legendWrapperTransform = ref(""), lo = ref({}), rangeColor = ref(props.rangeColor || (props.darkMode ? Heatmap.DEFAULT_RANGE_COLOR_DARK : Heatmap.DEFAULT_RANGE_COLOR_LIGHT)); + const { values, tooltipUnit, tooltipFormatter, noDataText, max: max2, vertical, locale } = toRefs(props); + let tippyInstances, tippySingleton; + function initTippy() { + tippyInstances = tippy$1(Array.from(svg.value.querySelectorAll(".vch__day__square[data-tippy-content]"))); + if (tippySingleton) { + tippySingleton.setInstances(tippyInstances); + } else { + tippySingleton = createSingleton(tippyInstances, { + moveTransition: "transform 0.1s ease-out", + allowHTML: true + }); + } + } + function tooltipOptions(day) { + if (props.tooltip) { + if (props.tooltipFormatter) { + return props.tooltipFormatter(day, props.tooltipUnit); + } + if (day.count !== void 0) { + return `${day.count} ${props.tooltipUnit} ${lo.value.on} ${lo.value.months[day.date.getMonth()]} ${day.date.getDate()}, ${day.date.getFullYear()}`; + } else if (props.noDataText) { + return `${props.noDataText}`; + } else if (props.noDataText !== false) { + return `No ${props.tooltipUnit} ${lo.value.on} ${lo.value.months[day.date.getMonth()]} ${day.date.getDate()}, ${day.date.getFullYear()}`; + } + } + return void 0; + } + function getWeekPosition(index2) { + if (props.vertical) { + return `translate(0, ${SQUARE_SIZE * heatmap.value.weekCount - (index2 + 1) * SQUARE_SIZE})`; + } + return `translate(${index2 * SQUARE_SIZE}, 0)`; + } + function getDayPosition(index2) { + if (props.vertical) { + return `translate(${index2 * SQUARE_SIZE}, 0)`; + } + return `translate(0, ${index2 * SQUARE_SIZE})`; + } + function getMonthLabelPosition(month) { + if (props.vertical) { + return { x: 3, y: SQUARE_SIZE * heatmap.value.weekCount - SQUARE_SIZE * month.index - SQUARE_SIZE / 4 }; + } + return { x: SQUARE_SIZE * month.index, y: SQUARE_SIZE - SQUARE_BORDER_SIZE }; + } + watch([toRef(props, "rangeColor"), toRef(props, "darkMode")], ([rc, dm]) => { + rangeColor.value = rc || (dm ? Heatmap.DEFAULT_RANGE_COLOR_DARK : Heatmap.DEFAULT_RANGE_COLOR_LIGHT); + }); + watch(vertical, (v) => { + if (v) { + width.value = LEFT_SECTION_WIDTH + SQUARE_SIZE * Heatmap.DAYS_IN_WEEK + RIGHT_SECTION_WIDTH; + height.value = TOP_SECTION_HEIGHT + SQUARE_SIZE * heatmap.value.weekCount + SQUARE_BORDER_SIZE; + daysLabelWrapperTransform.value = `translate(${LEFT_SECTION_WIDTH}, 0)`; + monthsLabelWrapperTransform.value = `translate(0, ${TOP_SECTION_HEIGHT})`; + } else { + width.value = LEFT_SECTION_WIDTH + SQUARE_SIZE * heatmap.value.weekCount + SQUARE_BORDER_SIZE; + height.value = TOP_SECTION_HEIGHT + SQUARE_SIZE * Heatmap.DAYS_IN_WEEK; + daysLabelWrapperTransform.value = `translate(0, ${TOP_SECTION_HEIGHT})`; + monthsLabelWrapperTransform.value = `translate(${LEFT_SECTION_WIDTH}, 0)`; + } + }, { immediate: true }); + watch([width, height], ([w, h]) => viewbox.value = ` 0 0 ${w} ${h}`, { immediate: true }); + watch([width, height, rangeColor], ([w, h, rc]) => { + legendWrapperTransform.value = vertical.value ? `translate(${LEFT_SECTION_WIDTH + SQUARE_SIZE * Heatmap.DAYS_IN_WEEK}, ${TOP_SECTION_HEIGHT})` : `translate(${w - SQUARE_SIZE * rc.length - 30}, ${h - BOTTOM_SECTION_HEIGHT})`; + }, { immediate: true }); + watch(locale, (l) => lo.value = l ? __spreadValues(__spreadValues({}, Heatmap.DEFAULT_LOCALE), l) : Heatmap.DEFAULT_LOCALE, { immediate: true }); + watch(rangeColor, (rc) => legendViewbox.value = `0 0 ${Heatmap.SQUARE_SIZE * (rc.length + 1)} ${Heatmap.SQUARE_SIZE}`, { immediate: true }); + watch([values, tooltipUnit, tooltipFormatter, noDataText, max2, rangeColor], () => { + heatmap.value = new Heatmap(props.endDate, props.values, props.max); + tippyInstances == null ? void 0 : tippyInstances.map((i) => i.destroy()); + nextTick(initTippy); + }); + onMounted(initTippy); + onBeforeUnmount(() => { + tippySingleton == null ? void 0 : tippySingleton.destroy(); + tippyInstances == null ? void 0 : tippyInstances.map((i) => i.destroy()); + }); + return { + SQUARE_BORDER_SIZE, + SQUARE_SIZE, + LEFT_SECTION_WIDTH, + RIGHT_SECTION_WIDTH, + TOP_SECTION_HEIGHT, + BOTTOM_SECTION_HEIGHT, + svg, + heatmap, + now, + width, + height, + viewbox, + daysLabelWrapperTransform, + monthsLabelWrapperTransform, + yearWrapperTransform, + legendWrapperTransform, + lo, + legendViewbox, + curRangeColor: rangeColor, + tooltipOptions, + getWeekPosition, + getDayPosition, + getMonthLabelPosition + }; + } +}); +const _hoisted_1 = ["viewBox"]; +const _hoisted_2 = ["transform"]; +const _hoisted_3 = ["x", "y"]; +const _hoisted_4 = ["transform"]; +const _hoisted_5 = ["x", "y"]; +const _hoisted_6 = ["x", "y"]; +const _hoisted_7 = ["x", "y"]; +const _hoisted_8 = ["transform"]; +const _hoisted_9 = ["x"]; +const _hoisted_10 = ["rx", "ry", "width", "height", "x", "y"]; +const _hoisted_11 = ["x", "y"]; +const _hoisted_12 = ["transform"]; +const _hoisted_13 = ["transform"]; +const _hoisted_14 = ["rx", "ry", "transform", "width", "height", "data-tippy-content", "onClick"]; +const _hoisted_15 = { class: "vch__legend" }; +const _hoisted_16 = { class: "vch__legend-left" }; +const _hoisted_17 = { class: "vch__legend-right" }; +const _hoisted_18 = { class: "vch__legend" }; +const _hoisted_19 = ["viewBox", "height"]; +const _hoisted_20 = { class: "vch__legend__wrapper" }; +const _hoisted_21 = ["rx", "ry", "width", "height", "x"]; +function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createElementBlock("div", { + class: normalizeClass({ "vch__container": true, "dark-mode": _ctx.darkMode }) + }, [ + (openBlock(), createElementBlock("svg", { + class: "vch__wrapper", + ref: "svg", + viewBox: _ctx.viewbox + }, [ + createElementVNode("g", { + class: "vch__months__labels__wrapper", + transform: _ctx.monthsLabelWrapperTransform + }, [ + (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.heatmap.firstFullWeekOfMonths, (month, index2) => { + return openBlock(), createElementBlock("text", { + class: "vch__month__label", + key: index2, + x: _ctx.getMonthLabelPosition(month).x, + y: _ctx.getMonthLabelPosition(month).y + }, toDisplayString(_ctx.lo.months[month.value]), 9, _hoisted_3); + }), 128)) + ], 8, _hoisted_2), + createElementVNode("g", { + class: "vch__days__labels__wrapper", + transform: _ctx.daysLabelWrapperTransform + }, [ + createElementVNode("text", { + class: "vch__day__label", + x: _ctx.vertical ? _ctx.SQUARE_SIZE : 0, + y: _ctx.vertical ? _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE : 20 + }, toDisplayString(_ctx.lo.days[1]), 9, _hoisted_5), + createElementVNode("text", { + class: "vch__day__label", + x: _ctx.vertical ? _ctx.SQUARE_SIZE * 3 : 0, + y: _ctx.vertical ? _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE : 44 + }, toDisplayString(_ctx.lo.days[3]), 9, _hoisted_6), + createElementVNode("text", { + class: "vch__day__label", + x: _ctx.vertical ? _ctx.SQUARE_SIZE * 5 : 0, + y: _ctx.vertical ? _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE : 69 + }, toDisplayString(_ctx.lo.days[5]), 9, _hoisted_7) + ], 8, _hoisted_4), + _ctx.vertical ? (openBlock(), createElementBlock("g", { + key: 0, + class: "vch__legend__wrapper", + transform: _ctx.legendWrapperTransform + }, [ + createElementVNode("text", { + x: _ctx.SQUARE_SIZE * 1.25, + y: "8" + }, toDisplayString(_ctx.lo.less), 9, _hoisted_9), + (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.curRangeColor, (color, index2) => { + return openBlock(), createElementBlock("rect", { + key: index2, + rx: _ctx.round, + ry: _ctx.round, + style: normalizeStyle({ fill: color }), + width: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + height: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + x: _ctx.SQUARE_SIZE * 1.75, + y: _ctx.SQUARE_SIZE * (index2 + 1) + }, null, 12, _hoisted_10); + }), 128)), + createElementVNode("text", { + x: _ctx.SQUARE_SIZE * 1.25, + y: _ctx.SQUARE_SIZE * (_ctx.curRangeColor.length + 2) - _ctx.SQUARE_BORDER_SIZE + }, toDisplayString(_ctx.lo.more), 9, _hoisted_11) + ], 8, _hoisted_8)) : createCommentVNode("", true), + createElementVNode("g", { + class: "vch__year__wrapper", + transform: _ctx.yearWrapperTransform + }, [ + (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.heatmap.calendar, (week, weekIndex) => { + return openBlock(), createElementBlock("g", { + class: "vch__month__wrapper", + key: weekIndex, + transform: _ctx.getWeekPosition(weekIndex) + }, [ + (openBlock(true), createElementBlock(Fragment, null, renderList(week, (day, dayIndex) => { + return openBlock(), createElementBlock(Fragment, { key: dayIndex }, [ + day.date < _ctx.now || _ctx.showFuture ? (openBlock(), createElementBlock("rect", { + key: 0, + class: "vch__day__square", + rx: _ctx.round, + ry: _ctx.round, + transform: _ctx.getDayPosition(dayIndex), + width: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + height: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + style: normalizeStyle({ fill: _ctx.curRangeColor[day.colorIndex] }), + "data-tippy-content": _ctx.tooltipOptions(day), + onClick: ($event) => _ctx.$emit("dayClick", day) + }, null, 12, _hoisted_14)) : createCommentVNode("", true) + ], 64); + }), 128)) + ], 8, _hoisted_13); + }), 128)) + ], 8, _hoisted_12) + ], 8, _hoisted_1)), + createElementVNode("div", _hoisted_15, [ + renderSlot(_ctx.$slots, "legend", {}, () => [ + createElementVNode("div", _hoisted_16, [ + renderSlot(_ctx.$slots, "vch__legend-left") + ]), + createElementVNode("div", _hoisted_17, [ + renderSlot(_ctx.$slots, "legend-right", {}, () => [ + createElementVNode("div", _hoisted_18, [ + createElementVNode("div", null, toDisplayString(_ctx.lo.less), 1), + !_ctx.vertical ? (openBlock(), createElementBlock("svg", { + key: 0, + class: "vch__external-legend-wrapper", + viewBox: _ctx.legendViewbox, + height: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE + }, [ + createElementVNode("g", _hoisted_20, [ + (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.curRangeColor, (color, index2) => { + return openBlock(), createElementBlock("rect", { + key: index2, + rx: _ctx.round, + ry: _ctx.round, + style: normalizeStyle({ fill: color }), + width: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + height: _ctx.SQUARE_SIZE - _ctx.SQUARE_BORDER_SIZE, + x: _ctx.SQUARE_SIZE * index2 + }, null, 12, _hoisted_21); + }), 128)) + ]) + ], 8, _hoisted_19)) : createCommentVNode("", true), + createElementVNode("div", null, toDisplayString(_ctx.lo.more), 1) + ]) + ]) + ]) + ]) + ]) + ], 2); +} +var CalendarHeatmap = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]); +function install(Vue) { + Vue.component(CalendarHeatmap.name, CalendarHeatmap); +} +var index = { install }; +export { CalendarHeatmap, Heatmap, index as default }; diff --git a/dist/vue3-calendar-heatmap.umd.js b/dist/vue3-calendar-heatmap.umd.js new file mode 100644 index 0000000..fc40fa1 --- /dev/null +++ b/dist/vue3-calendar-heatmap.umd.js @@ -0,0 +1 @@ +var Si=Object.defineProperty;var pr=Object.getOwnPropertySymbols;var Di=Object.prototype.hasOwnProperty,_i=Object.prototype.propertyIsEnumerable;var Rt=(N,u,O)=>u in N?Si(N,u,{enumerable:!0,configurable:!0,writable:!0,value:O}):N[u]=O,ct=(N,u)=>{for(var O in u||(u={}))Di.call(u,O)&&Rt(N,O,u[O]);if(pr)for(var O of pr(u))_i.call(u,O)&&Rt(N,O,u[O]);return N};var V=(N,u,O)=>(Rt(N,typeof u!="symbol"?u+"":u,O),O);(function(N,u){typeof exports=="object"&&typeof module!="undefined"?u(exports,require("vue")):typeof define=="function"&&define.amd?define(["exports","vue"],u):(N=typeof globalThis!="undefined"?globalThis:N||self,u(N.CalendarHeatmap={},N.Vue))})(this,function(N,u){"use strict";const pe=class{constructor(t,r,i){V(this,"startDate");V(this,"endDate");V(this,"max");V(this,"_values");V(this,"_firstFullWeekOfMonths");V(this,"_activities");V(this,"_calendar");this.endDate=this.parseDate(t),this.max=i||Math.ceil(Math.max(...r.map(a=>a.count))/5*4),this.startDate=this.shiftDate(t,-pe.DAYS_IN_ONE_YEAR),this._values=r}set values(t){this.max=Math.ceil(Math.max(...t.map(r=>r.count))/5*4),this._values=t,this._firstFullWeekOfMonths=void 0,this._calendar=void 0,this._activities=void 0}get values(){return this._values}get activities(){if(!this._activities){this._activities=new Map;for(let t=0,r=this.values.length;t=this.max?5:Math.ceil(t*100/this.max*.03)+1}getCountEmptyDaysAtStart(){return this.startDate.getDay()}getCountEmptyDaysAtEnd(){return pe.DAYS_IN_WEEK-1-this.endDate.getDay()}getDaysCount(){return pe.DAYS_IN_ONE_YEAR+1+this.getCountEmptyDaysAtStart()+this.getCountEmptyDaysAtEnd()}shiftDate(t,r){const i=new Date(t);return i.setDate(i.getDate()+r),i}parseDate(t){return t instanceof Date?t:new Date(t)}keyDayParser(t){const r=this.parseDate(t);return String(r.getFullYear())+String(r.getMonth()).padStart(2,"0")+String(r.getDate()).padStart(2,"0")}};let O=pe;V(O,"DEFAULT_RANGE_COLOR_LIGHT",["#ebedf0","#dae2ef","#c0ddf9","#73b3f3","#3886e1","#17459e"]),V(O,"DEFAULT_RANGE_COLOR_DARK",["#1f1f22","#1e334a","#1d466c","#1d5689","#1d69ac","#1B95D1"]),V(O,"DEFAULT_LOCALE",{months:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],days:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],on:"on",less:"Less",more:"More"}),V(O,"DEFAULT_TOOLTIP_UNIT","contributions"),V(O,"DAYS_IN_ONE_YEAR",365),V(O,"DAYS_IN_WEEK",7),V(O,"SQUARE_SIZE",10);var H="top",q="bottom",z="right",Q="left",ft="auto",Be=[H,q,z,Q],Oe="start",Me="end",dr="clippingParents",xt="viewport",Ue="popper",vr="reference",Ct=Be.reduce(function(e,t){return e.concat([t+"-"+Oe,t+"-"+Me])},[]),Lt=[].concat(Be,[ft]).reduce(function(e,t){return e.concat([t,t+"-"+Oe,t+"-"+Me])},[]),hr="beforeRead",mr="read",gr="afterRead",yr="beforeMain",br="main",Er="afterMain",wr="beforeWrite",Or="write",Ar="afterWrite",Sr=[hr,mr,gr,yr,br,Er,wr,Or,Ar];function re(e){return e?(e.nodeName||"").toLowerCase():null}function J(e){if(e==null)return window;if(e.toString()!=="[object Window]"){var t=e.ownerDocument;return t&&t.defaultView||window}return e}function Ae(e){var t=J(e).Element;return e instanceof t||e instanceof Element}function G(e){var t=J(e).HTMLElement;return e instanceof t||e instanceof HTMLElement}function It(e){if(typeof ShadowRoot=="undefined")return!1;var t=J(e).ShadowRoot;return e instanceof t||e instanceof ShadowRoot}function Dr(e){var t=e.state;Object.keys(t.elements).forEach(function(r){var i=t.styles[r]||{},a=t.attributes[r]||{},o=t.elements[r];!G(o)||!re(o)||(Object.assign(o.style,i),Object.keys(a).forEach(function(s){var c=a[s];c===!1?o.removeAttribute(s):o.setAttribute(s,c===!0?"":c)}))})}function _r(e){var t=e.state,r={popper:{position:t.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};return Object.assign(t.elements.popper.style,r.popper),t.styles=r,t.elements.arrow&&Object.assign(t.elements.arrow.style,r.arrow),function(){Object.keys(t.elements).forEach(function(i){var a=t.elements[i],o=t.attributes[i]||{},s=Object.keys(t.styles.hasOwnProperty(i)?t.styles[i]:r[i]),c=s.reduce(function(f,v){return f[v]="",f},{});!G(a)||!re(a)||(Object.assign(a.style,c),Object.keys(o).forEach(function(f){a.removeAttribute(f)}))})}}var kt={name:"applyStyles",enabled:!0,phase:"write",fn:Dr,effect:_r,requires:["computeStyles"]};function ne(e){return e.split("-")[0]}var he=Math.max,Ze=Math.min,Se=Math.round;function De(e,t){t===void 0&&(t=!1);var r=e.getBoundingClientRect(),i=1,a=1;if(G(e)&&t){var o=e.offsetHeight,s=e.offsetWidth;s>0&&(i=Se(r.width)/s||1),o>0&&(a=Se(r.height)/o||1)}return{width:r.width/i,height:r.height/a,top:r.top/a,right:r.right/i,bottom:r.bottom/a,left:r.left/i,x:r.left/i,y:r.top/a}}function pt(e){var t=De(e),r=e.offsetWidth,i=e.offsetHeight;return Math.abs(t.width-r)<=1&&(r=t.width),Math.abs(t.height-i)<=1&&(i=t.height),{x:e.offsetLeft,y:e.offsetTop,width:r,height:i}}function Bt(e,t){var r=t.getRootNode&&t.getRootNode();if(e.contains(t))return!0;if(r&&It(r)){var i=t;do{if(i&&e.isSameNode(i))return!0;i=i.parentNode||i.host}while(i)}return!1}function oe(e){return J(e).getComputedStyle(e)}function Tr(e){return["table","td","th"].indexOf(re(e))>=0}function fe(e){return((Ae(e)?e.ownerDocument:e.document)||window.document).documentElement}function Ye(e){return re(e)==="html"?e:e.assignedSlot||e.parentNode||(It(e)?e.host:null)||fe(e)}function Mt(e){return!G(e)||oe(e).position==="fixed"?null:e.offsetParent}function Rr(e){var t=navigator.userAgent.toLowerCase().indexOf("firefox")!==-1,r=navigator.userAgent.indexOf("Trident")!==-1;if(r&&G(e)){var i=oe(e);if(i.position==="fixed")return null}for(var a=Ye(e);G(a)&&["html","body"].indexOf(re(a))<0;){var o=oe(a);if(o.transform!=="none"||o.perspective!=="none"||o.contain==="paint"||["transform","perspective"].indexOf(o.willChange)!==-1||t&&o.willChange==="filter"||t&&o.filter&&o.filter!=="none")return a;a=a.parentNode}return null}function $e(e){for(var t=J(e),r=Mt(e);r&&Tr(r)&&oe(r).position==="static";)r=Mt(r);return r&&(re(r)==="html"||re(r)==="body"&&oe(r).position==="static")?t:r||Rr(e)||t}function dt(e){return["top","bottom"].indexOf(e)>=0?"x":"y"}function Ne(e,t,r){return he(e,Ze(t,r))}function xr(e,t,r){var i=Ne(e,t,r);return i>r?r:i}function Ut(){return{top:0,right:0,bottom:0,left:0}}function $t(e){return Object.assign({},Ut(),e)}function Nt(e,t){return t.reduce(function(r,i){return r[i]=e,r},{})}var Cr=function(t,r){return t=typeof t=="function"?t(Object.assign({},r.rects,{placement:r.placement})):t,$t(typeof t!="number"?t:Nt(t,Be))};function Lr(e){var t,r=e.state,i=e.name,a=e.options,o=r.elements.arrow,s=r.modifiersData.popperOffsets,c=ne(r.placement),f=dt(c),v=[Q,z].indexOf(c)>=0,p=v?"height":"width";if(!(!o||!s)){var S=Cr(a.padding,r),R=pt(o),g=f==="y"?H:Q,A=f==="y"?q:z,E=r.rects.reference[p]+r.rects.reference[f]-s[f]-r.rects.popper[p],D=s[f]-r.rects.reference[f],b=$e(o),T=b?f==="y"?b.clientHeight||0:b.clientWidth||0:0,x=E/2-D/2,n=S[g],m=T-R[p]-S[A],d=T/2-R[p]/2+x,_=Ne(n,d,m),I=f;r.modifiersData[i]=(t={},t[I]=_,t.centerOffset=_-d,t)}}function Ir(e){var t=e.state,r=e.options,i=r.element,a=i===void 0?"[data-popper-arrow]":i;a!=null&&(typeof a=="string"&&(a=t.elements.popper.querySelector(a),!a)||!Bt(t.elements.popper,a)||(t.elements.arrow=a))}var kr={name:"arrow",enabled:!0,phase:"main",fn:Lr,effect:Ir,requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function _e(e){return e.split("-")[1]}var Br={top:"auto",right:"auto",bottom:"auto",left:"auto"};function Mr(e){var t=e.x,r=e.y,i=window,a=i.devicePixelRatio||1;return{x:Se(t*a)/a||0,y:Se(r*a)/a||0}}function Pt(e){var t,r=e.popper,i=e.popperRect,a=e.placement,o=e.variation,s=e.offsets,c=e.position,f=e.gpuAcceleration,v=e.adaptive,p=e.roundOffsets,S=e.isFixed,R=s.x,g=R===void 0?0:R,A=s.y,E=A===void 0?0:A,D=typeof p=="function"?p({x:g,y:E}):{x:g,y:E};g=D.x,E=D.y;var b=s.hasOwnProperty("x"),T=s.hasOwnProperty("y"),x=Q,n=H,m=window;if(v){var d=$e(r),_="clientHeight",I="clientWidth";if(d===J(r)&&(d=fe(r),oe(d).position!=="static"&&c==="absolute"&&(_="scrollHeight",I="scrollWidth")),d=d,a===H||(a===Q||a===z)&&o===Me){n=q;var M=S&&m.visualViewport?m.visualViewport.height:d[_];E-=M-i.height,E*=f?1:-1}if(a===Q||(a===H||a===q)&&o===Me){x=z;var $=S&&m.visualViewport?m.visualViewport.width:d[I];g-=$-i.width,g*=f?1:-1}}var L=Object.assign({position:c},v&&Br),k=p===!0?Mr({x:g,y:E}):{x:g,y:E};if(g=k.x,E=k.y,f){var U;return Object.assign({},L,(U={},U[n]=T?"0":"",U[x]=b?"0":"",U.transform=(m.devicePixelRatio||1)<=1?"translate("+g+"px, "+E+"px)":"translate3d("+g+"px, "+E+"px, 0)",U))}return Object.assign({},L,(t={},t[n]=T?E+"px":"",t[x]=b?g+"px":"",t.transform="",t))}function Ur(e){var t=e.state,r=e.options,i=r.gpuAcceleration,a=i===void 0?!0:i,o=r.adaptive,s=o===void 0?!0:o,c=r.roundOffsets,f=c===void 0?!0:c,v={placement:ne(t.placement),variation:_e(t.placement),popper:t.elements.popper,popperRect:t.rects.popper,gpuAcceleration:a,isFixed:t.options.strategy==="fixed"};t.modifiersData.popperOffsets!=null&&(t.styles.popper=Object.assign({},t.styles.popper,Pt(Object.assign({},v,{offsets:t.modifiersData.popperOffsets,position:t.options.strategy,adaptive:s,roundOffsets:f})))),t.modifiersData.arrow!=null&&(t.styles.arrow=Object.assign({},t.styles.arrow,Pt(Object.assign({},v,{offsets:t.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:f})))),t.attributes.popper=Object.assign({},t.attributes.popper,{"data-popper-placement":t.placement})}var $r={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:Ur,data:{}},qe={passive:!0};function Nr(e){var t=e.state,r=e.instance,i=e.options,a=i.scroll,o=a===void 0?!0:a,s=i.resize,c=s===void 0?!0:s,f=J(t.elements.popper),v=[].concat(t.scrollParents.reference,t.scrollParents.popper);return o&&v.forEach(function(p){p.addEventListener("scroll",r.update,qe)}),c&&f.addEventListener("resize",r.update,qe),function(){o&&v.forEach(function(p){p.removeEventListener("scroll",r.update,qe)}),c&&f.removeEventListener("resize",r.update,qe)}}var Pr={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:Nr,data:{}},Fr={left:"right",right:"left",bottom:"top",top:"bottom"};function ze(e){return e.replace(/left|right|bottom|top/g,function(t){return Fr[t]})}var Wr={start:"end",end:"start"};function Ft(e){return e.replace(/start|end/g,function(t){return Wr[t]})}function vt(e){var t=J(e),r=t.pageXOffset,i=t.pageYOffset;return{scrollLeft:r,scrollTop:i}}function ht(e){return De(fe(e)).left+vt(e).scrollLeft}function jr(e){var t=J(e),r=fe(e),i=t.visualViewport,a=r.clientWidth,o=r.clientHeight,s=0,c=0;return i&&(a=i.width,o=i.height,/^((?!chrome|android).)*safari/i.test(navigator.userAgent)||(s=i.offsetLeft,c=i.offsetTop)),{width:a,height:o,x:s+ht(e),y:c}}function Vr(e){var t,r=fe(e),i=vt(e),a=(t=e.ownerDocument)==null?void 0:t.body,o=he(r.scrollWidth,r.clientWidth,a?a.scrollWidth:0,a?a.clientWidth:0),s=he(r.scrollHeight,r.clientHeight,a?a.scrollHeight:0,a?a.clientHeight:0),c=-i.scrollLeft+ht(e),f=-i.scrollTop;return oe(a||r).direction==="rtl"&&(c+=he(r.clientWidth,a?a.clientWidth:0)-o),{width:o,height:s,x:c,y:f}}function mt(e){var t=oe(e),r=t.overflow,i=t.overflowX,a=t.overflowY;return/auto|scroll|overlay|hidden/.test(r+a+i)}function Wt(e){return["html","body","#document"].indexOf(re(e))>=0?e.ownerDocument.body:G(e)&&mt(e)?e:Wt(Ye(e))}function Pe(e,t){var r;t===void 0&&(t=[]);var i=Wt(e),a=i===((r=e.ownerDocument)==null?void 0:r.body),o=J(i),s=a?[o].concat(o.visualViewport||[],mt(i)?i:[]):i,c=t.concat(s);return a?c:c.concat(Pe(Ye(s)))}function gt(e){return Object.assign({},e,{left:e.x,top:e.y,right:e.x+e.width,bottom:e.y+e.height})}function Hr(e){var t=De(e);return t.top=t.top+e.clientTop,t.left=t.left+e.clientLeft,t.bottom=t.top+e.clientHeight,t.right=t.left+e.clientWidth,t.width=e.clientWidth,t.height=e.clientHeight,t.x=t.left,t.y=t.top,t}function jt(e,t){return t===xt?gt(jr(e)):Ae(t)?Hr(t):gt(Vr(fe(e)))}function Qr(e){var t=Pe(Ye(e)),r=["absolute","fixed"].indexOf(oe(e).position)>=0,i=r&&G(e)?$e(e):e;return Ae(i)?t.filter(function(a){return Ae(a)&&Bt(a,i)&&re(a)!=="body"}):[]}function Zr(e,t,r){var i=t==="clippingParents"?Qr(e):[].concat(t),a=[].concat(i,[r]),o=a[0],s=a.reduce(function(c,f){var v=jt(e,f);return c.top=he(v.top,c.top),c.right=Ze(v.right,c.right),c.bottom=Ze(v.bottom,c.bottom),c.left=he(v.left,c.left),c},jt(e,o));return s.width=s.right-s.left,s.height=s.bottom-s.top,s.x=s.left,s.y=s.top,s}function Vt(e){var t=e.reference,r=e.element,i=e.placement,a=i?ne(i):null,o=i?_e(i):null,s=t.x+t.width/2-r.width/2,c=t.y+t.height/2-r.height/2,f;switch(a){case H:f={x:s,y:t.y-r.height};break;case q:f={x:s,y:t.y+t.height};break;case z:f={x:t.x+t.width,y:c};break;case Q:f={x:t.x-r.width,y:c};break;default:f={x:t.x,y:t.y}}var v=a?dt(a):null;if(v!=null){var p=v==="y"?"height":"width";switch(o){case Oe:f[v]=f[v]-(t[p]/2-r[p]/2);break;case Me:f[v]=f[v]+(t[p]/2-r[p]/2);break}}return f}function Fe(e,t){t===void 0&&(t={});var r=t,i=r.placement,a=i===void 0?e.placement:i,o=r.boundary,s=o===void 0?dr:o,c=r.rootBoundary,f=c===void 0?xt:c,v=r.elementContext,p=v===void 0?Ue:v,S=r.altBoundary,R=S===void 0?!1:S,g=r.padding,A=g===void 0?0:g,E=$t(typeof A!="number"?A:Nt(A,Be)),D=p===Ue?vr:Ue,b=e.rects.popper,T=e.elements[R?D:p],x=Zr(Ae(T)?T:T.contextElement||fe(e.elements.popper),s,f),n=De(e.elements.reference),m=Vt({reference:n,element:b,strategy:"absolute",placement:a}),d=gt(Object.assign({},b,m)),_=p===Ue?d:n,I={top:x.top-_.top+E.top,bottom:_.bottom-x.bottom+E.bottom,left:x.left-_.left+E.left,right:_.right-x.right+E.right},M=e.modifiersData.offset;if(p===Ue&&M){var $=M[a];Object.keys(I).forEach(function(L){var k=[z,q].indexOf(L)>=0?1:-1,U=[H,q].indexOf(L)>=0?"y":"x";I[L]+=$[U]*k})}return I}function Yr(e,t){t===void 0&&(t={});var r=t,i=r.placement,a=r.boundary,o=r.rootBoundary,s=r.padding,c=r.flipVariations,f=r.allowedAutoPlacements,v=f===void 0?Lt:f,p=_e(i),S=p?c?Ct:Ct.filter(function(A){return _e(A)===p}):Be,R=S.filter(function(A){return v.indexOf(A)>=0});R.length===0&&(R=S);var g=R.reduce(function(A,E){return A[E]=Fe(e,{placement:E,boundary:a,rootBoundary:o,padding:s})[ne(E)],A},{});return Object.keys(g).sort(function(A,E){return g[A]-g[E]})}function qr(e){if(ne(e)===ft)return[];var t=ze(e);return[Ft(e),t,Ft(t)]}function zr(e){var t=e.state,r=e.options,i=e.name;if(!t.modifiersData[i]._skip){for(var a=r.mainAxis,o=a===void 0?!0:a,s=r.altAxis,c=s===void 0?!0:s,f=r.fallbackPlacements,v=r.padding,p=r.boundary,S=r.rootBoundary,R=r.altBoundary,g=r.flipVariations,A=g===void 0?!0:g,E=r.allowedAutoPlacements,D=t.options.placement,b=ne(D),T=b===D,x=f||(T||!A?[ze(D)]:qr(D)),n=[D].concat(x).reduce(function(se,te){return se.concat(ne(te)===ft?Yr(t,{placement:te,boundary:p,rootBoundary:S,padding:v,flipVariations:A,allowedAutoPlacements:E}):te)},[]),m=t.rects.reference,d=t.rects.popper,_=new Map,I=!0,M=n[0],$=0;$=0,Y=Z?"width":"height",P=Fe(t,{placement:L,boundary:p,rootBoundary:S,altBoundary:R,padding:v}),F=Z?U?z:Q:U?q:H;m[Y]>d[Y]&&(F=ze(F));var y=ze(F),W=[];if(o&&W.push(P[k]<=0),c&&W.push(P[F]<=0,P[y]<=0),W.every(function(se){return se})){M=L,I=!1;break}_.set(L,W)}if(I)for(var K=A?3:1,ye=function(te){var le=n.find(function(xe){var ue=_.get(xe);if(ue)return ue.slice(0,te).every(function(Ce){return Ce})});if(le)return M=le,"break"},ae=K;ae>0;ae--){var be=ye(ae);if(be==="break")break}t.placement!==M&&(t.modifiersData[i]._skip=!0,t.placement=M,t.reset=!0)}}var Gr={name:"flip",enabled:!0,phase:"main",fn:zr,requiresIfExists:["offset"],data:{_skip:!1}};function Ht(e,t,r){return r===void 0&&(r={x:0,y:0}),{top:e.top-t.height-r.y,right:e.right-t.width+r.x,bottom:e.bottom-t.height+r.y,left:e.left-t.width-r.x}}function Qt(e){return[H,z,q,Q].some(function(t){return e[t]>=0})}function Kr(e){var t=e.state,r=e.name,i=t.rects.reference,a=t.rects.popper,o=t.modifiersData.preventOverflow,s=Fe(t,{elementContext:"reference"}),c=Fe(t,{altBoundary:!0}),f=Ht(s,i),v=Ht(c,a,o),p=Qt(f),S=Qt(v);t.modifiersData[r]={referenceClippingOffsets:f,popperEscapeOffsets:v,isReferenceHidden:p,hasPopperEscaped:S},t.attributes.popper=Object.assign({},t.attributes.popper,{"data-popper-reference-hidden":p,"data-popper-escaped":S})}var Xr={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:Kr};function Jr(e,t,r){var i=ne(e),a=[Q,H].indexOf(i)>=0?-1:1,o=typeof r=="function"?r(Object.assign({},t,{placement:e})):r,s=o[0],c=o[1];return s=s||0,c=(c||0)*a,[Q,z].indexOf(i)>=0?{x:c,y:s}:{x:s,y:c}}function en(e){var t=e.state,r=e.options,i=e.name,a=r.offset,o=a===void 0?[0,0]:a,s=Lt.reduce(function(p,S){return p[S]=Jr(S,t.rects,o),p},{}),c=s[t.placement],f=c.x,v=c.y;t.modifiersData.popperOffsets!=null&&(t.modifiersData.popperOffsets.x+=f,t.modifiersData.popperOffsets.y+=v),t.modifiersData[i]=s}var tn={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:en};function rn(e){var t=e.state,r=e.name;t.modifiersData[r]=Vt({reference:t.rects.reference,element:t.rects.popper,strategy:"absolute",placement:t.placement})}var nn={name:"popperOffsets",enabled:!0,phase:"read",fn:rn,data:{}};function an(e){return e==="x"?"y":"x"}function on(e){var t=e.state,r=e.options,i=e.name,a=r.mainAxis,o=a===void 0?!0:a,s=r.altAxis,c=s===void 0?!1:s,f=r.boundary,v=r.rootBoundary,p=r.altBoundary,S=r.padding,R=r.tether,g=R===void 0?!0:R,A=r.tetherOffset,E=A===void 0?0:A,D=Fe(t,{boundary:f,rootBoundary:v,padding:S,altBoundary:p}),b=ne(t.placement),T=_e(t.placement),x=!T,n=dt(b),m=an(n),d=t.modifiersData.popperOffsets,_=t.rects.reference,I=t.rects.popper,M=typeof E=="function"?E(Object.assign({},t.rects,{placement:t.placement})):E,$=typeof M=="number"?{mainAxis:M,altAxis:M}:Object.assign({mainAxis:0,altAxis:0},M),L=t.modifiersData.offset?t.modifiersData.offset[t.placement]:null,k={x:0,y:0};if(!!d){if(o){var U,Z=n==="y"?H:Q,Y=n==="y"?q:z,P=n==="y"?"height":"width",F=d[n],y=F+D[Z],W=F-D[Y],K=g?-I[P]/2:0,ye=T===Oe?_[P]:I[P],ae=T===Oe?-I[P]:-_[P],be=t.elements.arrow,se=g&&be?pt(be):{width:0,height:0},te=t.modifiersData["arrow#persistent"]?t.modifiersData["arrow#persistent"].padding:Ut(),le=te[Z],xe=te[Y],ue=Ne(0,_[P],se[P]),Ce=x?_[P]/2-K-ue-le-$.mainAxis:ye-ue-le-$.mainAxis,de=x?-_[P]/2+K+ue+xe+$.mainAxis:ae+ue+xe+$.mainAxis,Le=t.elements.arrow&&$e(t.elements.arrow),Je=Le?n==="y"?Le.clientTop||0:Le.clientLeft||0:0,We=(U=L==null?void 0:L[n])!=null?U:0,et=F+Ce-We-Je,tt=F+de-We,je=Ne(g?Ze(y,et):y,F,g?he(W,tt):W);d[n]=je,k[n]=je-F}if(c){var Ve,rt=n==="x"?H:Q,nt=n==="x"?q:z,ce=d[m],ve=m==="y"?"height":"width",He=ce+D[rt],Ee=ce-D[nt],Qe=[H,Q].indexOf(b)!==-1,it=(Ve=L==null?void 0:L[m])!=null?Ve:0,at=Qe?He:ce-_[ve]-I[ve]-it+$.altAxis,ot=Qe?ce+_[ve]+I[ve]-it-$.altAxis:Ee,st=g&&Qe?xr(at,ce,ot):Ne(g?at:He,ce,g?ot:Ee);d[m]=st,k[m]=st-ce}t.modifiersData[i]=k}}var sn={name:"preventOverflow",enabled:!0,phase:"main",fn:on,requiresIfExists:["offset"]};function ln(e){return{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}}function un(e){return e===J(e)||!G(e)?vt(e):ln(e)}function cn(e){var t=e.getBoundingClientRect(),r=Se(t.width)/e.offsetWidth||1,i=Se(t.height)/e.offsetHeight||1;return r!==1||i!==1}function fn(e,t,r){r===void 0&&(r=!1);var i=G(t),a=G(t)&&cn(t),o=fe(t),s=De(e,a),c={scrollLeft:0,scrollTop:0},f={x:0,y:0};return(i||!i&&!r)&&((re(t)!=="body"||mt(o))&&(c=un(t)),G(t)?(f=De(t,!0),f.x+=t.clientLeft,f.y+=t.clientTop):o&&(f.x=ht(o))),{x:s.left+c.scrollLeft-f.x,y:s.top+c.scrollTop-f.y,width:s.width,height:s.height}}function pn(e){var t=new Map,r=new Set,i=[];e.forEach(function(o){t.set(o.name,o)});function a(o){r.add(o.name);var s=[].concat(o.requires||[],o.requiresIfExists||[]);s.forEach(function(c){if(!r.has(c)){var f=t.get(c);f&&a(f)}}),i.push(o)}return e.forEach(function(o){r.has(o.name)||a(o)}),i}function dn(e){var t=pn(e);return Sr.reduce(function(r,i){return r.concat(t.filter(function(a){return a.phase===i}))},[])}function vn(e){var t;return function(){return t||(t=new Promise(function(r){Promise.resolve().then(function(){t=void 0,r(e())})})),t}}function hn(e){var t=e.reduce(function(r,i){var a=r[i.name];return r[i.name]=a?Object.assign({},a,i,{options:Object.assign({},a.options,i.options),data:Object.assign({},a.data,i.data)}):i,r},{});return Object.keys(t).map(function(r){return t[r]})}var Zt={placement:"bottom",modifiers:[],strategy:"absolute"};function Yt(){for(var e=arguments.length,t=new Array(e),r=0;r-1}function Xt(e,t){return typeof e=="function"?e.apply(void 0,t):e}function Jt(e,t){if(t===0)return e;var r;return function(i){clearTimeout(r),r=setTimeout(function(){e(i)},t)}}function wn(e,t){var r=Object.assign({},e);return t.forEach(function(i){delete r[i]}),r}function On(e){return e.split(/\s+/).filter(Boolean)}function ge(e){return[].concat(e)}function er(e,t){e.indexOf(t)===-1&&e.push(t)}function An(e){return e.filter(function(t,r){return e.indexOf(t)===r})}function Sn(e){return e.split("-")[0]}function Ge(e){return[].slice.call(e)}function tr(e){return Object.keys(e).reduce(function(t,r){return e[r]!==void 0&&(t[r]=e[r]),t},{})}function Te(){return document.createElement("div")}function Ke(e){return["Element","Fragment"].some(function(t){return bt(e,t)})}function Dn(e){return bt(e,"NodeList")}function _n(e){return bt(e,"MouseEvent")}function Tn(e){return!!(e&&e._tippy&&e._tippy.reference===e)}function Rn(e){return Ke(e)?[e]:Dn(e)?Ge(e):Array.isArray(e)?e:Ge(document.querySelectorAll(e))}function Et(e,t){e.forEach(function(r){r&&(r.style.transitionDuration=t+"ms")})}function rr(e,t){e.forEach(function(r){r&&r.setAttribute("data-state",t)})}function xn(e){var t,r=ge(e),i=r[0];return i!=null&&(t=i.ownerDocument)!=null&&t.body?i.ownerDocument:document}function Cn(e,t){var r=t.clientX,i=t.clientY;return e.every(function(a){var o=a.popperRect,s=a.popperState,c=a.props,f=c.interactiveBorder,v=Sn(s.placement),p=s.modifiersData.offset;if(!p)return!0;var S=v==="bottom"?p.top.y:0,R=v==="top"?p.bottom.y:0,g=v==="right"?p.left.x:0,A=v==="left"?p.right.x:0,E=o.top-i+S>f,D=i-o.bottom-R>f,b=o.left-r+g>f,T=r-o.right-A>f;return E||D||b||T})}function wt(e,t,r){var i=t+"EventListener";["transitionend","webkitTransitionEnd"].forEach(function(a){e[i](a,r)})}function nr(e,t){for(var r=t;r;){var i;if(e.contains(r))return!0;r=r.getRootNode==null||(i=r.getRootNode())==null?void 0:i.host}return!1}var ie={isTouch:!1},ir=0;function Ln(){ie.isTouch||(ie.isTouch=!0,window.performance&&document.addEventListener("mousemove",ar))}function ar(){var e=performance.now();e-ir<20&&(ie.isTouch=!1,document.removeEventListener("mousemove",ar)),ir=e}function In(){var e=document.activeElement;if(Tn(e)){var t=e._tippy;e.blur&&!t.state.isVisible&&e.blur()}}function kn(){document.addEventListener("touchstart",Ln,me),window.addEventListener("blur",In)}var Bn=typeof window!="undefined"&&typeof document!="undefined",Mn=Bn?!!window.msCrypto:!1,Un={animateFill:!1,followCursor:!1,inlinePositioning:!1,sticky:!1},$n={allowHTML:!1,animation:"fade",arrow:!0,content:"",inertia:!1,maxWidth:350,role:"tooltip",theme:"",zIndex:9999},ee=Object.assign({appendTo:Kt,aria:{content:"auto",expanded:"auto"},delay:0,duration:[300,250],getReferenceClientRect:null,hideOnClick:!0,ignoreAttributes:!1,interactive:!1,interactiveBorder:2,interactiveDebounce:0,moveTransition:"",offset:[0,10],onAfterUpdate:function(){},onBeforeUpdate:function(){},onCreate:function(){},onDestroy:function(){},onHidden:function(){},onHide:function(){},onMount:function(){},onShow:function(){},onShown:function(){},onTrigger:function(){},onUntrigger:function(){},onClickOutside:function(){},placement:"top",plugins:[],popperOptions:{},render:null,showOnCreate:!1,touch:!0,trigger:"mouseenter focus",triggerTarget:null},Un,$n),Nn=Object.keys(ee),Pn=function(t){var r=Object.keys(t);r.forEach(function(i){ee[i]=t[i]})};function or(e){var t=e.plugins||[],r=t.reduce(function(i,a){var o=a.name,s=a.defaultValue;if(o){var c;i[o]=e[o]!==void 0?e[o]:(c=ee[o])!=null?c:s}return i},{});return Object.assign({},e,r)}function Fn(e,t){var r=t?Object.keys(or(Object.assign({},ee,{plugins:t}))):Nn,i=r.reduce(function(a,o){var s=(e.getAttribute("data-tippy-"+o)||"").trim();if(!s)return a;if(o==="content")a[o]=s;else try{a[o]=JSON.parse(s)}catch{a[o]=s}return a},{});return i}function sr(e,t){var r=Object.assign({},t,{content:Xt(t.content,[e])},t.ignoreAttributes?{}:Fn(e,t.plugins));return r.aria=Object.assign({},ee.aria,r.aria),r.aria={expanded:r.aria.expanded==="auto"?t.interactive:r.aria.expanded,content:r.aria.content==="auto"?t.interactive?null:"describedby":r.aria.content},r}var Wn=function(){return"innerHTML"};function Ot(e,t){e[Wn()]=t}function lr(e){var t=Te();return e===!0?t.className=zt:(t.className=Gt,Ke(e)?t.appendChild(e):Ot(t,e)),t}function ur(e,t){Ke(t.content)?(Ot(e,""),e.appendChild(t.content)):typeof t.content!="function"&&(t.allowHTML?Ot(e,t.content):e.textContent=t.content)}function At(e){var t=e.firstElementChild,r=Ge(t.children);return{box:t,content:r.find(function(i){return i.classList.contains(qt)}),arrow:r.find(function(i){return i.classList.contains(zt)||i.classList.contains(Gt)}),backdrop:r.find(function(i){return i.classList.contains(En)})}}function cr(e){var t=Te(),r=Te();r.className=bn,r.setAttribute("data-state","hidden"),r.setAttribute("tabindex","-1");var i=Te();i.className=qt,i.setAttribute("data-state","hidden"),ur(i,e.props),t.appendChild(r),r.appendChild(i),a(e.props,e.props);function a(o,s){var c=At(t),f=c.box,v=c.content,p=c.arrow;s.theme?f.setAttribute("data-theme",s.theme):f.removeAttribute("data-theme"),typeof s.animation=="string"?f.setAttribute("data-animation",s.animation):f.removeAttribute("data-animation"),s.inertia?f.setAttribute("data-inertia",""):f.removeAttribute("data-inertia"),f.style.maxWidth=typeof s.maxWidth=="number"?s.maxWidth+"px":s.maxWidth,s.role?f.setAttribute("role",s.role):f.removeAttribute("role"),(o.content!==s.content||o.allowHTML!==s.allowHTML)&&ur(v,e.props),s.arrow?p?o.arrow!==s.arrow&&(f.removeChild(p),f.appendChild(lr(s.arrow))):f.appendChild(lr(s.arrow)):p&&f.removeChild(p)}return{popper:t,onUpdate:a}}cr.$$tippy=!0;var jn=1,Xe=[],St=[];function Vn(e,t){var r=sr(e,Object.assign({},ee,or(tr(t)))),i,a,o,s=!1,c=!1,f=!1,v=!1,p,S,R,g=[],A=Jt(et,r.interactiveDebounce),E,D=jn++,b=null,T=An(r.plugins),x={isEnabled:!0,isVisible:!1,isDestroyed:!1,isMounted:!1,isShown:!1},n={id:D,reference:e,popper:Te(),popperInstance:b,props:r,state:x,plugins:T,clearDelayTimeouts:at,setProps:ot,setContent:st,show:yi,hide:bi,hideWithInteractivity:Ei,enable:Qe,disable:it,unmount:wi,destroy:Oi};if(!r.render)return n;var m=r.render(n),d=m.popper,_=m.onUpdate;d.setAttribute("data-tippy-root",""),d.id="tippy-"+n.id,n.popper=d,e._tippy=n,d._tippy=n;var I=T.map(function(l){return l.fn(n)}),M=e.hasAttribute("aria-expanded");return Le(),K(),F(),y("onCreate",[n]),r.showOnCreate&&He(),d.addEventListener("mouseenter",function(){n.props.interactive&&n.state.isVisible&&n.clearDelayTimeouts()}),d.addEventListener("mouseleave",function(){n.props.interactive&&n.props.trigger.indexOf("mouseenter")>=0&&Z().addEventListener("mousemove",A)}),n;function $(){var l=n.props.touch;return Array.isArray(l)?l:[l,0]}function L(){return $()[0]==="hold"}function k(){var l;return!!((l=n.props.render)!=null&&l.$$tippy)}function U(){return E||e}function Z(){var l=U().parentNode;return l?xn(l):document}function Y(){return At(d)}function P(l){return n.state.isMounted&&!n.state.isVisible||ie.isTouch||p&&p.type==="focus"?0:yt(n.props.delay,l?0:1,ee.delay)}function F(l){l===void 0&&(l=!1),d.style.pointerEvents=n.props.interactive&&!l?"":"none",d.style.zIndex=""+n.props.zIndex}function y(l,h,w){if(w===void 0&&(w=!0),I.forEach(function(C){C[l]&&C[l].apply(C,h)}),w){var B;(B=n.props)[l].apply(B,h)}}function W(){var l=n.props.aria;if(!!l.content){var h="aria-"+l.content,w=d.id,B=ge(n.props.triggerTarget||e);B.forEach(function(C){var j=C.getAttribute(h);if(n.state.isVisible)C.setAttribute(h,j?j+" "+w:w);else{var X=j&&j.replace(w,"").trim();X?C.setAttribute(h,X):C.removeAttribute(h)}})}}function K(){if(!(M||!n.props.aria.expanded)){var l=ge(n.props.triggerTarget||e);l.forEach(function(h){n.props.interactive?h.setAttribute("aria-expanded",n.state.isVisible&&h===U()?"true":"false"):h.removeAttribute("aria-expanded")})}}function ye(){Z().removeEventListener("mousemove",A),Xe=Xe.filter(function(l){return l!==A})}function ae(l){if(!(ie.isTouch&&(f||l.type==="mousedown"))){var h=l.composedPath&&l.composedPath()[0]||l.target;if(!(n.props.interactive&&nr(d,h))){if(ge(n.props.triggerTarget||e).some(function(w){return nr(w,h)})){if(ie.isTouch||n.state.isVisible&&n.props.trigger.indexOf("click")>=0)return}else y("onClickOutside",[n,l]);n.props.hideOnClick===!0&&(n.clearDelayTimeouts(),n.hide(),c=!0,setTimeout(function(){c=!1}),n.state.isMounted||le())}}}function be(){f=!0}function se(){f=!1}function te(){var l=Z();l.addEventListener("mousedown",ae,!0),l.addEventListener("touchend",ae,me),l.addEventListener("touchstart",se,me),l.addEventListener("touchmove",be,me)}function le(){var l=Z();l.removeEventListener("mousedown",ae,!0),l.removeEventListener("touchend",ae,me),l.removeEventListener("touchstart",se,me),l.removeEventListener("touchmove",be,me)}function xe(l,h){Ce(l,function(){!n.state.isVisible&&d.parentNode&&d.parentNode.contains(d)&&h()})}function ue(l,h){Ce(l,h)}function Ce(l,h){var w=Y().box;function B(C){C.target===w&&(wt(w,"remove",B),h())}if(l===0)return h();wt(w,"remove",S),wt(w,"add",B),S=B}function de(l,h,w){w===void 0&&(w=!1);var B=ge(n.props.triggerTarget||e);B.forEach(function(C){C.addEventListener(l,h,w),g.push({node:C,eventType:l,handler:h,options:w})})}function Le(){L()&&(de("touchstart",We,{passive:!0}),de("touchend",tt,{passive:!0})),On(n.props.trigger).forEach(function(l){if(l!=="manual")switch(de(l,We),l){case"mouseenter":de("mouseleave",tt);break;case"focus":de(Mn?"focusout":"blur",je);break;case"focusin":de("focusout",je);break}})}function Je(){g.forEach(function(l){var h=l.node,w=l.eventType,B=l.handler,C=l.options;h.removeEventListener(w,B,C)}),g=[]}function We(l){var h,w=!1;if(!(!n.state.isEnabled||Ve(l)||c)){var B=((h=p)==null?void 0:h.type)==="focus";p=l,E=l.currentTarget,K(),!n.state.isVisible&&_n(l)&&Xe.forEach(function(C){return C(l)}),l.type==="click"&&(n.props.trigger.indexOf("mouseenter")<0||s)&&n.props.hideOnClick!==!1&&n.state.isVisible?w=!0:He(l),l.type==="click"&&(s=!w),w&&!B&&Ee(l)}}function et(l){var h=l.target,w=U().contains(h)||d.contains(h);if(!(l.type==="mousemove"&&w)){var B=ve().concat(d).map(function(C){var j,X=C._tippy,Ie=(j=X.popperInstance)==null?void 0:j.state;return Ie?{popperRect:C.getBoundingClientRect(),popperState:Ie,props:r}:null}).filter(Boolean);Cn(B,l)&&(ye(),Ee(l))}}function tt(l){var h=Ve(l)||n.props.trigger.indexOf("click")>=0&&s;if(!h){if(n.props.interactive){n.hideWithInteractivity(l);return}Ee(l)}}function je(l){n.props.trigger.indexOf("focusin")<0&&l.target!==U()||n.props.interactive&&l.relatedTarget&&d.contains(l.relatedTarget)||Ee(l)}function Ve(l){return ie.isTouch?L()!==l.type.indexOf("touch")>=0:!1}function rt(){nt();var l=n.props,h=l.popperOptions,w=l.placement,B=l.offset,C=l.getReferenceClientRect,j=l.moveTransition,X=k()?At(d).arrow:null,Ie=C?{getBoundingClientRect:C,contextElement:C.contextElement||U()}:e,fr={name:"$$tippy",enabled:!0,phase:"beforeWrite",requires:["computeStyles"],fn:function(lt){var ke=lt.state;if(k()){var Ai=Y(),Tt=Ai.box;["placement","reference-hidden","escaped"].forEach(function(ut){ut==="placement"?Tt.setAttribute("data-placement",ke.placement):ke.attributes.popper["data-popper-"+ut]?Tt.setAttribute("data-"+ut,""):Tt.removeAttribute("data-"+ut)}),ke.attributes.popper={}}}},we=[{name:"offset",options:{offset:B}},{name:"preventOverflow",options:{padding:{top:2,bottom:2,left:5,right:5}}},{name:"flip",options:{padding:5}},{name:"computeStyles",options:{adaptive:!j}},fr];k()&&X&&we.push({name:"arrow",options:{element:X,padding:3}}),we.push.apply(we,(h==null?void 0:h.modifiers)||[]),n.popperInstance=yn(Ie,d,Object.assign({},h,{placement:w,onFirstUpdate:R,modifiers:we}))}function nt(){n.popperInstance&&(n.popperInstance.destroy(),n.popperInstance=null)}function ce(){var l=n.props.appendTo,h,w=U();n.props.interactive&&l===Kt||l==="parent"?h=w.parentNode:h=Xt(l,[w]),h.contains(d)||h.appendChild(d),n.state.isMounted=!0,rt()}function ve(){return Ge(d.querySelectorAll("[data-tippy-root]"))}function He(l){n.clearDelayTimeouts(),l&&y("onTrigger",[n,l]),te();var h=P(!0),w=$(),B=w[0],C=w[1];ie.isTouch&&B==="hold"&&C&&(h=C),h?i=setTimeout(function(){n.show()},h):n.show()}function Ee(l){if(n.clearDelayTimeouts(),y("onUntrigger",[n,l]),!n.state.isVisible){le();return}if(!(n.props.trigger.indexOf("mouseenter")>=0&&n.props.trigger.indexOf("click")>=0&&["mouseleave","mousemove"].indexOf(l.type)>=0&&s)){var h=P(!1);h?a=setTimeout(function(){n.state.isVisible&&n.hide()},h):o=requestAnimationFrame(function(){n.hide()})}}function Qe(){n.state.isEnabled=!0}function it(){n.hide(),n.state.isEnabled=!1}function at(){clearTimeout(i),clearTimeout(a),cancelAnimationFrame(o)}function ot(l){if(!n.state.isDestroyed){y("onBeforeUpdate",[n,l]),Je();var h=n.props,w=sr(e,Object.assign({},h,tr(l),{ignoreAttributes:!0}));n.props=w,Le(),h.interactiveDebounce!==w.interactiveDebounce&&(ye(),A=Jt(et,w.interactiveDebounce)),h.triggerTarget&&!w.triggerTarget?ge(h.triggerTarget).forEach(function(B){B.removeAttribute("aria-expanded")}):w.triggerTarget&&e.removeAttribute("aria-expanded"),K(),F(),_&&_(h,w),n.popperInstance&&(rt(),ve().forEach(function(B){requestAnimationFrame(B._tippy.popperInstance.forceUpdate)})),y("onAfterUpdate",[n,l])}}function st(l){n.setProps({content:l})}function yi(){var l=n.state.isVisible,h=n.state.isDestroyed,w=!n.state.isEnabled,B=ie.isTouch&&!n.props.touch,C=yt(n.props.duration,0,ee.duration);if(!(l||h||w||B)&&!U().hasAttribute("disabled")&&(y("onShow",[n],!1),n.props.onShow(n)!==!1)){if(n.state.isVisible=!0,k()&&(d.style.visibility="visible"),F(),te(),n.state.isMounted||(d.style.transition="none"),k()){var j=Y(),X=j.box,Ie=j.content;Et([X,Ie],0)}R=function(){var we;if(!(!n.state.isVisible||v)){if(v=!0,d.offsetHeight,d.style.transition=n.props.moveTransition,k()&&n.props.animation){var _t=Y(),lt=_t.box,ke=_t.content;Et([lt,ke],C),rr([lt,ke],"visible")}W(),K(),er(St,n),(we=n.popperInstance)==null||we.forceUpdate(),y("onMount",[n]),n.props.animation&&k()&&ue(C,function(){n.state.isShown=!0,y("onShown",[n])})}},ce()}}function bi(){var l=!n.state.isVisible,h=n.state.isDestroyed,w=!n.state.isEnabled,B=yt(n.props.duration,1,ee.duration);if(!(l||h||w)&&(y("onHide",[n],!1),n.props.onHide(n)!==!1)){if(n.state.isVisible=!1,n.state.isShown=!1,v=!1,s=!1,k()&&(d.style.visibility="hidden"),ye(),le(),F(!0),k()){var C=Y(),j=C.box,X=C.content;n.props.animation&&(Et([j,X],B),rr([j,X],"hidden"))}W(),K(),n.props.animation?k()&&xe(B,n.unmount):n.unmount()}}function Ei(l){Z().addEventListener("mousemove",A),er(Xe,A),A(l)}function wi(){n.state.isVisible&&n.hide(),!!n.state.isMounted&&(nt(),ve().forEach(function(l){l._tippy.unmount()}),d.parentNode&&d.parentNode.removeChild(d),St=St.filter(function(l){return l!==n}),n.state.isMounted=!1,y("onHidden",[n]))}function Oi(){n.state.isDestroyed||(n.clearDelayTimeouts(),n.unmount(),Je(),delete e._tippy,n.state.isDestroyed=!0,y("onDestroy",[n]))}}function Re(e,t){t===void 0&&(t={});var r=ee.plugins.concat(t.plugins||[]);kn();var i=Object.assign({},t,{plugins:r}),a=Rn(e),o=a.reduce(function(s,c){var f=c&&Vn(c,i);return f&&s.push(f),s},[]);return Ke(e)?o[0]:o}Re.defaultProps=ee,Re.setDefaultProps=Pn,Re.currentInput=ie;var Hn=Object.assign({},kt,{effect:function(t){var r=t.state,i={popper:{position:r.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};Object.assign(r.elements.popper.style,i.popper),r.styles=i,r.elements.arrow&&Object.assign(r.elements.arrow.style,i.arrow)}}),Qn=function(t,r){var i;r===void 0&&(r={});var a=t,o=[],s=[],c,f=r.overrides,v=[],p=!1;function S(){s=a.map(function(n){return ge(n.props.triggerTarget||n.reference)}).reduce(function(n,m){return n.concat(m)},[])}function R(){o=a.map(function(n){return n.reference})}function g(n){a.forEach(function(m){n?m.enable():m.disable()})}function A(n){return a.map(function(m){var d=m.setProps;return m.setProps=function(_){d(_),m.reference===c&&n.setProps(_)},function(){m.setProps=d}})}function E(n,m){var d=s.indexOf(m);if(m!==c){c=m;var _=(f||[]).concat("content").reduce(function(I,M){return I[M]=a[d].props[M],I},{});n.setProps(Object.assign({},_,{getReferenceClientRect:typeof _.getReferenceClientRect=="function"?_.getReferenceClientRect:function(){var I;return(I=o[d])==null?void 0:I.getBoundingClientRect()}}))}}g(!1),R(),S();var D={fn:function(){return{onDestroy:function(){g(!0)},onHidden:function(){c=null},onClickOutside:function(d){d.props.showOnCreate&&!p&&(p=!0,c=null)},onShow:function(d){d.props.showOnCreate&&!p&&(p=!0,E(d,o[0]))},onTrigger:function(d,_){E(d,_.currentTarget)}}}},b=Re(Te(),Object.assign({},wn(r,["overrides"]),{plugins:[D].concat(r.plugins||[]),triggerTarget:s,popperOptions:Object.assign({},r.popperOptions,{modifiers:[].concat(((i=r.popperOptions)==null?void 0:i.modifiers)||[],[Hn])})})),T=b.show;b.show=function(n){if(T(),!c&&n==null)return E(b,o[0]);if(!(c&&n==null)){if(typeof n=="number")return o[n]&&E(b,o[n]);if(a.indexOf(n)>=0){var m=n.reference;return E(b,m)}if(o.indexOf(n)>=0)return E(b,n)}},b.showNext=function(){var n=o[0];if(!c)return b.show(0);var m=o.indexOf(c);b.show(o[m+1]||n)},b.showPrevious=function(){var n=o[o.length-1];if(!c)return b.show(n);var m=o.indexOf(c),d=o[m-1]||n;b.show(d)};var x=b.setProps;return b.setProps=function(n){f=n.overrides||f,x(n)},b.setInstances=function(n){g(!0),v.forEach(function(m){return m()}),a=n,g(!1),R(),S(),v=A(b),b.setProps({triggerTarget:s})},v=A(b),b};Re.setDefaultProps({render:cr});var Ti="",Ri="",xi="",Zn=(e,t)=>{const r=e.__vccOpts||e;for(const[i,a]of t)r[i]=a;return r};const Yn=u.defineComponent({name:"CalendarHeatmap",props:{endDate:{required:!0},max:{type:Number},rangeColor:{type:Array},values:{type:Array,required:!0},locale:{type:Object},tooltip:{type:Boolean,default:!0},showFuture:{type:Boolean,default:!1},tooltipUnit:{type:String,default:O.DEFAULT_TOOLTIP_UNIT},tooltipFormatter:{type:Function},vertical:{type:Boolean,default:!1},noDataText:{type:[Boolean,String],default:null},round:{type:Number,default:0},darkMode:Boolean},emits:["dayClick"],setup(e){const t=O.SQUARE_SIZE/5,r=O.SQUARE_SIZE+t,i=Math.ceil(O.SQUARE_SIZE*2.5),a=r*3,o=O.SQUARE_SIZE+O.SQUARE_SIZE/2,s=O.SQUARE_SIZE+O.SQUARE_SIZE/2,c=`translate(${i}, ${o})`,f=u.ref(null),v=u.ref(new Date),p=u.ref(new O(e.endDate,e.values,e.max)),S=u.ref(0),R=u.ref(0),g=u.ref("0 0 0 0"),A=u.ref("0 0 0 0"),E=u.ref(""),D=u.ref(""),b=u.ref(""),T=u.ref({}),x=u.ref(e.rangeColor||(e.darkMode?O.DEFAULT_RANGE_COLOR_DARK:O.DEFAULT_RANGE_COLOR_LIGHT)),{values:n,tooltipUnit:m,tooltipFormatter:d,noDataText:_,max:I,vertical:M,locale:$}=u.toRefs(e);let L,k;function U(){L=Re(Array.from(f.value.querySelectorAll(".vch__day__square[data-tippy-content]"))),k?k.setInstances(L):k=Qn(L,{moveTransition:"transform 0.1s ease-out",allowHTML:!0})}function Z(y){if(e.tooltip){if(e.tooltipFormatter)return e.tooltipFormatter(y,e.tooltipUnit);if(y.count!==void 0)return`${y.count} ${e.tooltipUnit} ${T.value.on} ${T.value.months[y.date.getMonth()]} ${y.date.getDate()}, ${y.date.getFullYear()}`;if(e.noDataText)return`${e.noDataText}`;if(e.noDataText!==!1)return`No ${e.tooltipUnit} ${T.value.on} ${T.value.months[y.date.getMonth()]} ${y.date.getDate()}, ${y.date.getFullYear()}`}}function Y(y){return e.vertical?`translate(0, ${r*p.value.weekCount-(y+1)*r})`:`translate(${y*r}, 0)`}function P(y){return e.vertical?`translate(${y*r}, 0)`:`translate(0, ${y*r})`}function F(y){return e.vertical?{x:3,y:r*p.value.weekCount-r*y.index-r/4}:{x:r*y.index,y:r-t}}return u.watch([u.toRef(e,"rangeColor"),u.toRef(e,"darkMode")],([y,W])=>{x.value=y||(W?O.DEFAULT_RANGE_COLOR_DARK:O.DEFAULT_RANGE_COLOR_LIGHT)}),u.watch(M,y=>{y?(S.value=i+r*O.DAYS_IN_WEEK+a,R.value=o+r*p.value.weekCount+t,E.value=`translate(${i}, 0)`,D.value=`translate(0, ${o})`):(S.value=i+r*p.value.weekCount+t,R.value=o+r*O.DAYS_IN_WEEK,E.value=`translate(0, ${o})`,D.value=`translate(${i}, 0)`)},{immediate:!0}),u.watch([S,R],([y,W])=>g.value=` 0 0 ${y} ${W}`,{immediate:!0}),u.watch([S,R,x],([y,W,K])=>{b.value=M.value?`translate(${i+r*O.DAYS_IN_WEEK}, ${o})`:`translate(${y-r*K.length-30}, ${W-s})`},{immediate:!0}),u.watch($,y=>T.value=y?ct(ct({},O.DEFAULT_LOCALE),y):O.DEFAULT_LOCALE,{immediate:!0}),u.watch(x,y=>A.value=`0 0 ${O.SQUARE_SIZE*(y.length+1)} ${O.SQUARE_SIZE}`,{immediate:!0}),u.watch([n,m,d,_,I,x],()=>{p.value=new O(e.endDate,e.values,e.max),L==null||L.map(y=>y.destroy()),u.nextTick(U)}),u.onMounted(U),u.onBeforeUnmount(()=>{k==null||k.destroy(),L==null||L.map(y=>y.destroy())}),{SQUARE_BORDER_SIZE:t,SQUARE_SIZE:r,LEFT_SECTION_WIDTH:i,RIGHT_SECTION_WIDTH:a,TOP_SECTION_HEIGHT:o,BOTTOM_SECTION_HEIGHT:s,svg:f,heatmap:p,now:v,width:S,height:R,viewbox:g,daysLabelWrapperTransform:E,monthsLabelWrapperTransform:D,yearWrapperTransform:c,legendWrapperTransform:b,lo:T,legendViewbox:A,curRangeColor:x,tooltipOptions:Z,getWeekPosition:Y,getDayPosition:P,getMonthLabelPosition:F}}}),qn=["viewBox"],zn=["transform"],Gn=["x","y"],Kn=["transform"],Xn=["x","y"],Jn=["x","y"],ei=["x","y"],ti=["transform"],ri=["x"],ni=["rx","ry","width","height","x","y"],ii=["x","y"],ai=["transform"],oi=["transform"],si=["rx","ry","transform","width","height","data-tippy-content","onClick"],li={class:"vch__legend"},ui={class:"vch__legend-left"},ci={class:"vch__legend-right"},fi={class:"vch__legend"},pi=["viewBox","height"],di={class:"vch__legend__wrapper"},vi=["rx","ry","width","height","x"];function hi(e,t,r,i,a,o){return u.openBlock(),u.createElementBlock("div",{class:u.normalizeClass({vch__container:!0,"dark-mode":e.darkMode})},[(u.openBlock(),u.createElementBlock("svg",{class:"vch__wrapper",ref:"svg",viewBox:e.viewbox},[u.createElementVNode("g",{class:"vch__months__labels__wrapper",transform:e.monthsLabelWrapperTransform},[(u.openBlock(!0),u.createElementBlock(u.Fragment,null,u.renderList(e.heatmap.firstFullWeekOfMonths,(s,c)=>(u.openBlock(),u.createElementBlock("text",{class:"vch__month__label",key:c,x:e.getMonthLabelPosition(s).x,y:e.getMonthLabelPosition(s).y},u.toDisplayString(e.lo.months[s.value]),9,Gn))),128))],8,zn),u.createElementVNode("g",{class:"vch__days__labels__wrapper",transform:e.daysLabelWrapperTransform},[u.createElementVNode("text",{class:"vch__day__label",x:e.vertical?e.SQUARE_SIZE:0,y:e.vertical?e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE:20},u.toDisplayString(e.lo.days[1]),9,Xn),u.createElementVNode("text",{class:"vch__day__label",x:e.vertical?e.SQUARE_SIZE*3:0,y:e.vertical?e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE:44},u.toDisplayString(e.lo.days[3]),9,Jn),u.createElementVNode("text",{class:"vch__day__label",x:e.vertical?e.SQUARE_SIZE*5:0,y:e.vertical?e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE:69},u.toDisplayString(e.lo.days[5]),9,ei)],8,Kn),e.vertical?(u.openBlock(),u.createElementBlock("g",{key:0,class:"vch__legend__wrapper",transform:e.legendWrapperTransform},[u.createElementVNode("text",{x:e.SQUARE_SIZE*1.25,y:"8"},u.toDisplayString(e.lo.less),9,ri),(u.openBlock(!0),u.createElementBlock(u.Fragment,null,u.renderList(e.curRangeColor,(s,c)=>(u.openBlock(),u.createElementBlock("rect",{key:c,rx:e.round,ry:e.round,style:u.normalizeStyle({fill:s}),width:e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE,height:e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE,x:e.SQUARE_SIZE*1.75,y:e.SQUARE_SIZE*(c+1)},null,12,ni))),128)),u.createElementVNode("text",{x:e.SQUARE_SIZE*1.25,y:e.SQUARE_SIZE*(e.curRangeColor.length+2)-e.SQUARE_BORDER_SIZE},u.toDisplayString(e.lo.more),9,ii)],8,ti)):u.createCommentVNode("",!0),u.createElementVNode("g",{class:"vch__year__wrapper",transform:e.yearWrapperTransform},[(u.openBlock(!0),u.createElementBlock(u.Fragment,null,u.renderList(e.heatmap.calendar,(s,c)=>(u.openBlock(),u.createElementBlock("g",{class:"vch__month__wrapper",key:c,transform:e.getWeekPosition(c)},[(u.openBlock(!0),u.createElementBlock(u.Fragment,null,u.renderList(s,(f,v)=>(u.openBlock(),u.createElementBlock(u.Fragment,{key:v},[f.datee.$emit("dayClick",f)},null,12,si)):u.createCommentVNode("",!0)],64))),128))],8,oi))),128))],8,ai)],8,qn)),u.createElementVNode("div",li,[u.renderSlot(e.$slots,"legend",{},()=>[u.createElementVNode("div",ui,[u.renderSlot(e.$slots,"vch__legend-left")]),u.createElementVNode("div",ci,[u.renderSlot(e.$slots,"legend-right",{},()=>[u.createElementVNode("div",fi,[u.createElementVNode("div",null,u.toDisplayString(e.lo.less),1),e.vertical?u.createCommentVNode("",!0):(u.openBlock(),u.createElementBlock("svg",{key:0,class:"vch__external-legend-wrapper",viewBox:e.legendViewbox,height:e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE},[u.createElementVNode("g",di,[(u.openBlock(!0),u.createElementBlock(u.Fragment,null,u.renderList(e.curRangeColor,(s,c)=>(u.openBlock(),u.createElementBlock("rect",{key:c,rx:e.round,ry:e.round,style:u.normalizeStyle({fill:s}),width:e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE,height:e.SQUARE_SIZE-e.SQUARE_BORDER_SIZE,x:e.SQUARE_SIZE*c},null,12,vi))),128))])],8,pi)),u.createElementVNode("div",null,u.toDisplayString(e.lo.more),1)])])])])])],2)}var Dt=Zn(Yn,[["render",hi]]);function mi(e){e.component(Dt.name,Dt)}var gi={install:mi};N.CalendarHeatmap=Dt,N.Heatmap=O,N.default=gi,Object.defineProperty(N,"__esModule",{value:!0}),N[Symbol.toStringTag]="Module"}); diff --git a/package.json b/package.json index 7e7e0c7..fbeb1e3 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "vue3-calendar-heatmap", - "version": "2.0.0", + "version": "2.0.1", "description": "A lightweight calendar heatmap Vue 3 component built on SVG, inspired by julienr114's vue-calendar-heatmap ans github's contribution calendar graph", "keywords": [ "vue", @@ -20,14 +20,15 @@ "src/**/*.vue" ], "author": { - "name": "Volker Nauruhn", - "email": "mensch.meier@live.de", - "url": "razorness.de" + "name": "Nicolas Boé", + "email": "contact@nicolas-boe.fr", + "url": "nicolas-boe.fr" }, + "private": true, "license": "MIT", "repository": { "type": "git", - "url": "https://github.com/razorness/vue3-calendar-heatmap.git" + "url": "https://github.com/wikola/vue3-calendar-heatmap.git" }, "sideEffects": false, "scripts": { diff --git a/src/App.vue b/src/App.vue index ce41047..ea66ab8 100644 --- a/src/App.vue +++ b/src/App.vue @@ -1,46 +1,62 @@ -