Vendor

(self["webpackChunkxcloud_keyboard_mouse"] =
self["webpackChunkxcloud_keyboard_mouse"] || []).push([[736],{
/***/ 45722:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "Z": () => (/* binding */ useForwardedRef)
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ =
__webpack_require__(67294);
function useStatefulRef(initialVal = null) {

let [cur, setCur] = react__WEBPACK_IMPORTED_MODULE_0__.useState(initialVal);
const { current: ref } = react__WEBPACK_IMPORTED_MODULE_0__.useRef({
current: cur
});
Object.defineProperty(ref, "current", {
get: () => cur,
set: (value) => {
if (!Object.is(cur, value)) {
cur = value;
setCur(value);
}
}
});
return ref;
}
function useForwardedRef(forwardedRef) {
const innerRef = useStatefulRef(null);
react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
if (!forwardedRef)
return;
if (typeof forwardedRef === "function") {
forwardedRef(innerRef.current);
} else {
forwardedRef.current = innerRef.current;
}
});
return innerRef;
}
/***/ }),
/***/ 32222:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));

exports.DEFAULT_CALENDAR_STRINGS = exports.DEFAULT_DATE_FORMATTING =
exports.DEFAULT_DATE_GRID_STRINGS = exports.formatYear = exports.formatMonth =
exports.formatMonthYear = exports.formatMonthDayYear = exports.formatDay = void 0;
var tslib_1 = __webpack_require__(56779);
/**
* Format date to a day string representation
* @param date - input date to format
*/
var formatDay = function (date) { return date.getDate().toString(); };
exports.formatDay = formatDay;
/**
* Format date to a month-day-year string
* @param strings - localized strings
*/
var formatMonthDayYear = function (date, strings) {
return strings.months[date.getMonth()] + ' ' + date.getDate() + ', ' +
date.getFullYear();
};
exports.formatMonthDayYear = formatMonthDayYear;
/**
* Format date to a month-year string
*/
var formatMonthYear = function (date, strings) {
return strings.months[date.getMonth()] + ' ' + date.getFullYear();
};
exports.formatMonthYear = formatMonthYear;
/**
* Format date to a month string
*/
var formatMonth = function (date, strings) { return
strings.months[date.getMonth()]; };
exports.formatMonth = formatMonth;
/**
* Format date to a year string representation
*/
var formatYear = function (date) { return date.getFullYear().toString(); };
exports.formatYear = formatYear;
exports.DEFAULT_DATE_GRID_STRINGS = {
months: [
'January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December',
],
shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'],
days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday'],
shortDays: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
};
exports.DEFAULT_DATE_FORMATTING = {
formatDay: exports.formatDay,
formatMonth: exports.formatMonth,
formatYear: exports.formatYear,
formatMonthDayYear: exports.formatMonthDayYear,
formatMonthYear: exports.formatMonthYear,
};
exports.DEFAULT_CALENDAR_STRINGS = tslib_1.__assign(tslib_1.__assign({},
exports.DEFAULT_DATE_GRID_STRINGS), { goToToday: 'Go to today',
weekNumberFormatString: 'Week number {0}', prevMonthAriaLabel: 'Previous month',
nextMonthAriaLabel: 'Next month', prevYearAriaLabel: 'Previous year',
nextYearAriaLabel: 'Next year', prevYearRangeAriaLabel: 'Previous year range',
nextYearRangeAriaLabel: 'Next year range', closeButtonAriaLabel: 'Close',
selectedDateFormatString: 'Selected date {0}', todayDateFormatString: "Today's date
{0}", monthPickerHeaderAriaLabel: '{0}, change year', yearPickerHeaderAriaLabel:
'{0}, change month', dayMarkedAriaLabel: 'marked' });
//# sourceMappingURL=dateFormatting.defaults.js.map
/***/ }),
/***/ 78605:
/***/ ((__unused_webpack_module, exports) => {
"use strict";

//# sourceMappingURL=dateFormatting.types.js.map
/***/ }),
/***/ 37365:
"use strict";

tslib_1.__exportStar(__webpack_require__(78605), exports);
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 59145:
"use strict";

//# sourceMappingURL=dateGrid.types.js.map
/***/ }),
/***/ 50884:
"use strict";

exports.findAvailableDate = void 0;
var isRestrictedDate_1 = __webpack_require__(13898);
var isAfterMaxDate_1 = __webpack_require__(39780);
var isBeforeMinDate_1 = __webpack_require__(18561);
var dateMath_1 = __webpack_require__(71318);
/**
* Returns closest available date given the restriction òptions`, or undefined
otherwise
* @param options - list of search options
*/
var findAvailableDate = function (options) {
var targetDate = options.targetDate, initialDate = options.initialDate,
direction = options.direction, restrictedDateOptions = tslib_1.__rest(options,
["targetDate", "initialDate", "direction"]);
var availableDate = targetDate;
// if the target date is available, return it immediately
if (!isRestrictedDate_1.isRestrictedDate(targetDate, restrictedDateOptions)) {
return targetDate;
}
while (dateMath_1.compareDatePart(initialDate, availableDate) !== 0 &&
isRestrictedDate_1.isRestrictedDate(availableDate, restrictedDateOptions)
&&
!isAfterMaxDate_1.isAfterMaxDate(availableDate, restrictedDateOptions) &&
!isBeforeMinDate_1.isBeforeMinDate(availableDate, restrictedDateOptions)) {
availableDate = dateMath_1.addDays(availableDate, direction);
}
if (dateMath_1.compareDatePart(initialDate, availableDate) !== 0 && !
isRestrictedDate_1.isRestrictedDate(availableDate, restrictedDateOptions)) {
return availableDate;
}
return undefined;
};
exports.findAvailableDate = findAvailableDate;
//# sourceMappingURL=findAvailableDate.js.map
/***/ }),
/***/ 50430:
"use strict";

exports.getBoundedDateRange = void 0;
/**
* Generates a list of dates, bounded by min and max dates
* @param dateRange - input date range
* @param minDate - min date to limit the range
* @param maxDate - max date to limit the range
*/
var getBoundedDateRange = function (dateRange, minDate, maxDate) {
var boundedDateRange = tslib_1.__spreadArray([], dateRange);
if (minDate) {
boundedDateRange = boundedDateRange.filter(function (date) { return
dateMath_1.compareDatePart(date, minDate) >= 0; });
}
if (maxDate) {
boundedDateRange = boundedDateRange.filter(function (date) { return
dateMath_1.compareDatePart(date, maxDate) <= 0; });
}
return boundedDateRange;
};
exports.getBoundedDateRange = getBoundedDateRange;
//# sourceMappingURL=getBoundedDateRange.js.map
/***/ }),
/***/ 14082:
"use strict";

exports.getDateRangeTypeToUse = void 0;
var dateValues_1 = __webpack_require__(49998);
var isContiguous_1 = __webpack_require__(39193);
/**
* Return corrected date range type, given `dateRangeType` and list of working
days.
* For non-contiguous working days and working week range type, returns general
week range type.
* For other cases returns input date range type.
* @param dateRangeType - input type of range
* @param workWeekDays - list of working days in a week
*/
var getDateRangeTypeToUse = function (dateRangeType, workWeekDays, firstDayOfWeek)
{
if (workWeekDays && dateRangeType === dateValues_1.DateRangeType.WorkWeek) {
if (!isContiguous_1.isContiguous(workWeekDays, true, firstDayOfWeek) ||
workWeekDays.length === 0) {
return dateValues_1.DateRangeType.Week;
}
}
return dateRangeType;
};
exports.getDateRangeTypeToUse = getDateRangeTypeToUse;
//# sourceMappingURL=getDateRangeTypeToUse.js.map
/***/ }),
/***/ 95837:
"use strict";

exports.getDayGrid = void 0;
var getDateRangeTypeToUse_1 = __webpack_require__(14082);
var getBoundedDateRange_1 = __webpack_require__(50430);
var isRestrictedDate_1 = __webpack_require__(13898);
/**
* Generates a grid of days, given the òptions`.
* Returns one additional week at the begining from the previous range
* and one at the end from the future range
* @param options - parameters to specify date related restrictions for the
resulting grid
*/
var getDayGrid = function (options) {
var selectedDate = options.selectedDate, dateRangeType = options.dateRangeType,
firstDayOfWeek = options.firstDayOfWeek, today = options.today, minDate =
options.minDate, maxDate = options.maxDate, weeksToShow = options.weeksToShow,
workWeekDays = options.workWeekDays, daysToSelectInDayView =
options.daysToSelectInDayView, restrictedDates = options.restrictedDates,
markedDays = options.markedDays;
var restrictedDateOptions = { minDate: minDate, maxDate: maxDate,
restrictedDates: restrictedDates };
var todaysDate = today || new Date();
var navigatedDate = options.navigatedDate ? options.navigatedDate : todaysDate;
var date;
if (weeksToShow && weeksToShow <= 4) {
// if showing less than a full month, just use date == navigatedDate
date = new Date(navigatedDate.getFullYear(), navigatedDate.getMonth(),
navigatedDate.getDate());
}
else {
date = new Date(navigatedDate.getFullYear(), navigatedDate.getMonth(), 1);
}
var weeks = [];
// Cycle the date backwards to get to the first day of the week.
while (date.getDay() !== firstDayOfWeek) {
date.setDate(date.getDate() - 1);
}
// add the transition week as last week of previous range
date = dateMath_1.addDays(date, -dateValues_1.DAYS_IN_WEEK);
// a flag to indicate whether all days of the week are outside the month
var isAllDaysOfWeekOutOfMonth = false;
// in work week view if the days aren't contiguous we use week view instead
var selectedDateRangeType =
getDateRangeTypeToUse_1.getDateRangeTypeToUse(dateRangeType, workWeekDays,
firstDayOfWeek);
var selectedDates = [];
if (selectedDate) {
selectedDates = dateMath_1.getDateRangeArray(selectedDate,
selectedDateRangeType, firstDayOfWeek, workWeekDays, daysToSelectInDayView);
selectedDates = getBoundedDateRange_1.getBoundedDateRange(selectedDates,
minDate, maxDate);
}
var shouldGetWeeks = true;
for (var weekIndex = 0; shouldGetWeeks; weekIndex++) {
var week = [];
isAllDaysOfWeekOutOfMonth = true;
var _loop_1 = function (dayIndex) {
var originalDate = new Date(date.getTime());
var dayInfo = {
key: date.toString(),
date: date.getDate().toString(),
originalDate: originalDate,
isInMonth: date.getMonth() === navigatedDate.getMonth(),
isToday: dateMath_1.compareDates(todaysDate, date),
isSelected: dateMath_1.isInDateRangeArray(date, selectedDates),
isInBounds: !isRestrictedDate_1.isRestrictedDate(date,
restrictedDateOptions),
isMarked: (markedDays === null || markedDays === void 0 ? void 0 :
markedDays.some(function (markedDay) { return dateMath_1.compareDates(originalDate,
markedDay); })) || false,
};
week.push(dayInfo);
if (dayInfo.isInMonth) {
isAllDaysOfWeekOutOfMonth = false;
}
date.setDate(date.getDate() + 1);
};
for (var dayIndex = 0; dayIndex < dateValues_1.DAYS_IN_WEEK; dayIndex++) {
_loop_1(dayIndex);
}
// We append the condition of the loop depending upon the
showSixWeeksByDefault prop.
shouldGetWeeks = weeksToShow ? weekIndex < weeksToShow + 1 : !
isAllDaysOfWeekOutOfMonth || weekIndex === 0;
// we don't check shouldGetWeeks before pushing because we want to add one
extra week for transition state
weeks.push(week);
}
return weeks;
};
exports.getDayGrid = getDayGrid;
//# sourceMappingURL=getDayGrid.js.map
/***/ }),
/***/ 69870:
"use strict";

/***/ }),
/***/ 39780:
"use strict";

exports.isAfterMaxDate = void 0;
/**
* Checks if `date` happens later than max date
* @param date - date to check
* @param options - object with max date to check against
*/
var isAfterMaxDate = function (date, options) {
var maxDate = options.maxDate;
return maxDate ? dateMath_1.compareDatePart(date, maxDate) >= 1 : false;
};
exports.isAfterMaxDate = isAfterMaxDate;
//# sourceMappingURL=isAfterMaxDate.js.map
/***/ }),
/***/ 18561:
"use strict";

exports.isBeforeMinDate = void 0;
/**
* Checks if `date` happens earlier than min date
* @param options - object with min date to check against
*/
var isBeforeMinDate = function (date, options) {
var minDate = options.minDate;
return minDate ? dateMath_1.compareDatePart(minDate, date) >= 1 : false;
};
exports.isBeforeMinDate = isBeforeMinDate;
//# sourceMappingURL=isBeforeMinDate.js.map
/***/ }),
/***/ 39193:
"use strict";

exports.isContiguous = void 0;
/**
* Returns whether provided week days are contiguous.
* @param days - list of days in a week
* @param isSingleWeek - decides whether the contiguous logic applies across week
boundaries or not
* @param firstDayOfWeek - decides which day of week is the first one in the order.
*/
var isContiguous = function (days, isSingleWeek, firstDayOfWeek) {
var daySet = new Set(days);
var amountOfNoNeighbors = 0;
for (var _i = 0, days_1 = days; _i < days_1.length; _i++) {
var day = days_1[_i];
var nextDay = (day + 1) % 7;
if (!(daySet.has(nextDay) && (!isSingleWeek || firstDayOfWeek !==
nextDay))) {
amountOfNoNeighbors++;
}
}
// In case the full week is provided, then each day has a neighbor
//, otherwise the last day does not have a neighbor.
return amountOfNoNeighbors < 2;
};
exports.isContiguous = isContiguous;
//# sourceMappingURL=isContiguous.js.map
/***/ }),
/***/ 13898:
"use strict";

exports.isRestrictedDate = void 0;
var isBeforeMinDate_1 = __webpack_require__(18561);
var isAfterMaxDate_1 = __webpack_require__(39780);
/**
* Checks if `date` falls into the restricted òptions`
* @param options - restriction options (min date, max date and list of restricted
dates)
*/
var isRestrictedDate = function (date, options) {
var restrictedDates = options.restrictedDates, minDate = options.minDate,
maxDate = options.maxDate;
if (!restrictedDates && !minDate && !maxDate) {
return false;
}
var inRestrictedDates = restrictedDates && restrictedDates.some(function (rd) {
return dateMath_1.compareDates(rd, date); });
return inRestrictedDates || isBeforeMinDate_1.isBeforeMinDate(date, options) ||
isAfterMaxDate_1.isAfterMaxDate(date, options);
};
exports.isRestrictedDate = isRestrictedDate;
//# sourceMappingURL=isRestrictedDate.js.map
/***/ }),
/***/ 71318:
"use strict";

exports.getDatePartHashValue = exports.getEndDateOfWeek =
exports.getStartDateOfWeek = exports.getWeekNumber = exports.getWeekNumbersInMonth
= exports.isInDateRangeArray = exports.getDateRangeArray = exports.compareDatePart
= exports.compareDates = exports.setMonth = exports.getYearEnd =
exports.getYearStart = exports.getMonthEnd = exports.getMonthStart =
exports.addYears = exports.addMonths = exports.addWeeks = exports.addDays = void 0;
var timeConstants_1 = __webpack_require__(82261);
/**
* Returns a date offset from the given date by the specified number of days.
* @param date - The origin date
* @param days - The number of days to offset. 'days' can be negative.
* @returns A new Date object offset from the origin date by the given number of
days
*/
function addDays(date, days) {
var result = new Date(date.getTime());
result.setDate(result.getDate() + days);
return result;
}
exports.addDays = addDays;
/**
* Returns a date offset from the given date by the specified number of weeks.
* @param weeks - The number of weeks to offset. 'weeks' can be negative.
weeks
*/
function addWeeks(date, weeks) {
return addDays(date, weeks * timeConstants_1.TimeConstants.DaysInOneWeek);
}
exports.addWeeks = addWeeks;
/**
* Returns a date offset from the given date by the specified number of months.
* The method tries to preserve the day-of-month; however, if the new month does
not have enough days
* to contain the original day-of-month, we'll use the last day of the new month.
* @param months - The number of months to offset. 'months' can be negative.
months
*/
function addMonths(date, months) {
var newMonth = result.getMonth() + months;
result.setMonth(newMonth);
// We want to maintain the same day-of-month, but that may not be possible if
the new month doesn't have enough days.
// Loop until we back up to a day the new month has.
// (Weird modulo math is due to Javascript's treatment of negative numbers in
modulo)
if (result.getMonth() !==
((newMonth % timeConstants_1.TimeConstants.MonthInOneYear) +
timeConstants_1.TimeConstants.MonthInOneYear) %
timeConstants_1.TimeConstants.MonthInOneYear) {
result = addDays(result, -result.getDate());
}
return result;
}
exports.addMonths = addMonths;
/**
* Returns a date offset from the given date by the specified number of years.
* @param years - The number of years to offset. 'years' can be negative.
years
*/
function addYears(date, years) {
result.setFullYear(date.getFullYear() + years);
// We want to maintain the same day-of-month, but that may not be possible if
the new month doesn't have enough days.
// Loop until we back up to a day the new month has.
// (Weird modulo math is due to Javascript's treatment of negative numbers in
modulo)
if (result.getMonth() !==
((date.getMonth() % timeConstants_1.TimeConstants.MonthInOneYear) +
timeConstants_1.TimeConstants.MonthInOneYear) %
timeConstants_1.TimeConstants.MonthInOneYear) {
result = addDays(result, -result.getDate());
}
return result;
}
exports.addYears = addYears;
/**
* Returns a date that is the first day of the month of the provided date.
* @returns A new Date object with the day set to the first day of the month.
*/
function getMonthStart(date) {
return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
}
exports.getMonthStart = getMonthStart;
/**
* Returns a date that is the last day of the month of the provided date.
* @returns A new Date object with the day set to the last day of the month.
*/
function getMonthEnd(date) {
return new Date(date.getFullYear(), date.getMonth() + 1, 0, 0, 0, 0, 0);
}
exports.getMonthEnd = getMonthEnd;
/**
* Returns a date that is the first day of the year of the provided date.
* @returns A new Date object with the day set to the first day of the year.
*/
function getYearStart(date) {
return new Date(date.getFullYear(), 0, 1, 0, 0, 0, 0);
}
exports.getYearStart = getYearStart;
/**
* Returns a date that is the last day of the year of the provided date.
* @returns A new Date object with the day set to the last day of the year.
*/
function getYearEnd(date) {
return new Date(date.getFullYear() + 1, 0, 0, 0, 0, 0, 0);
}
exports.getYearEnd = getYearEnd;
/**
* Returns a date that is a copy of the given date, aside from the month changing
to the given month.
* @param month - The 0-based index of the month to set on the date.
* @returns A new Date object with the given month set.
*/
function setMonth(date, month) {
return addMonths(date, month - date.getMonth());
}
exports.setMonth = setMonth;
/**
* Compares two dates, and returns true if the two dates (not accounting for time-
of-day) are equal.
* @returns True if the two dates represent the same date (regardless of time-of-
day), false otherwise.
*/
function compareDates(date1, date2) {
if (!date1 && !date2) {
return true;
}
else if (!date1 || !date2) {
return false;
}
else {
return (date1.getFullYear() === date2.getFullYear() &&
date1.getMonth() === date2.getMonth() &&
date1.getDate() === date2.getDate());
}
}
exports.compareDates = compareDates;
/**
* Compare the date parts of two dates
* @param date1 - The first date to compare
* @param date2 - The second date to compare
* @returns A negative value if date1 is earlier than date2, 0 if the dates are
equal, or a positive value
* if date1 is later than date2.
*/
function compareDatePart(date1, date2) {
return getDatePartHashValue(date1) - getDatePartHashValue(date2);
}
exports.compareDatePart = compareDatePart;
/**
* Gets the date range array including the specified date. The date range array is
calculated as the list
* of dates accounting for the specified first day of the week and date range type.
* @param date - The input date
* @param dateRangeType - The desired date range type, i.e., day, week, month, etc.
* @param firstDayOfWeek - The first day of the week.
* @param workWeekDays - The allowed days in work week. If not provided, assumes
all days are allowed.
* @param daysToSelectInDayView - The number of days to include when using
dateRangeType === DateRangeType.Day
* for multiday view. Defaults to 1
* @returns An array of dates representing the date range containing the specified
date.
*/
function getDateRangeArray(date, dateRangeType, firstDayOfWeek, workWeekDays,
daysToSelectInDayView) {
if (daysToSelectInDayView === void 0) { daysToSelectInDayView = 1; }
var datesArray = [];
var startDate;
var endDate = null;
if (!workWeekDays) {
workWeekDays = [dateValues_1.DayOfWeek.Monday,
dateValues_1.DayOfWeek.Tuesday, dateValues_1.DayOfWeek.Wednesday,
dateValues_1.DayOfWeek.Thursday, dateValues_1.DayOfWeek.Friday];
}
daysToSelectInDayView = Math.max(daysToSelectInDayView, 1);
switch (dateRangeType) {
case dateValues_1.DateRangeType.Day:
startDate = getDatePart(date);
endDate = addDays(startDate, daysToSelectInDayView);
break;
case dateValues_1.DateRangeType.Week:
case dateValues_1.DateRangeType.WorkWeek:
startDate = getStartDateOfWeek(getDatePart(date), firstDayOfWeek);
endDate = addDays(startDate,
timeConstants_1.TimeConstants.DaysInOneWeek);
break;
case dateValues_1.DateRangeType.Month:
startDate = new Date(date.getFullYear(), date.getMonth(), 1);
endDate = addMonths(startDate, 1);
break;
default:
throw new Error('Unexpected object: ' + dateRangeType);
}
// Populate the dates array with the dates in range
var nextDate = startDate;
do {
if (dateRangeType !== dateValues_1.DateRangeType.WorkWeek) {
// push all days not in work week view
datesArray.push(nextDate);
}
else if (workWeekDays.indexOf(nextDate.getDay()) !== -1) {
datesArray.push(nextDate);
}
nextDate = addDays(nextDate, 1);
} while (!compareDates(nextDate, endDate));
return datesArray;
}
exports.getDateRangeArray = getDateRangeArray;
/**
* Checks whether the specified date is in the given date range.
* @param dateRange - An array of dates to do the lookup on
* @returns True if the date matches one of the dates in the specified array, false
otherwise.
*/
function isInDateRangeArray(date, dateRange) {
for (var _i = 0, dateRange_1 = dateRange; _i < dateRange_1.length; _i++) {
var dateInRange = dateRange_1[_i];
if (compareDates(date, dateInRange)) {
return true;
}
}
return false;
}
exports.isInDateRangeArray = isInDateRangeArray;
/**
* Returns the week number for a date.
* Week numbers are 1 - 52 (53) in a year
* @param navigatedDate - A date to find the week number for.
* @param firstDayOfWeek - The first day of the week (0-6, Sunday = 0)
* @param firstWeekOfYear - The first week of the year (1-2)
* @returns The weeks number array for the current month.
*/
function getWeekNumbersInMonth(weeksInMonth, firstDayOfWeek, firstWeekOfYear,
navigatedDate) {
var selectedYear = navigatedDate.getFullYear();
var selectedMonth = navigatedDate.getMonth();
var dayOfMonth = 1;
var fistDayOfMonth = new Date(selectedYear, selectedMonth, dayOfMonth);
var endOfFirstWeek = dayOfMonth +
(firstDayOfWeek + timeConstants_1.TimeConstants.DaysInOneWeek - 1) -
adjustWeekDay(firstDayOfWeek, fistDayOfMonth.getDay());
var endOfWeekRange = new Date(selectedYear, selectedMonth, endOfFirstWeek);
dayOfMonth = endOfWeekRange.getDate();
var weeksArray = [];
for (var i = 0; i < weeksInMonth; i++) {
// Get week number for end of week
weeksArray.push(getWeekNumber(endOfWeekRange, firstDayOfWeek,
firstWeekOfYear));
dayOfMonth += timeConstants_1.TimeConstants.DaysInOneWeek;
endOfWeekRange = new Date(selectedYear, selectedMonth, dayOfMonth);
}
return weeksArray;
}
exports.getWeekNumbersInMonth = getWeekNumbersInMonth;
/**
* Returns the week number for a date.
* Week numbers are 1 - 52 (53) in a year
* @param date - A date to find the week number for.
* @param firstDayOfWeek - The first day of the week (0-6, Sunday = 0)
* @param firstWeekOfYear - The first week of the year (1-2)
* @returns The week's number in the year.
*/
function getWeekNumber(date, firstDayOfWeek, firstWeekOfYear) {
// First four-day week of the year - minumum days count
var fourDayWeek = 4;
switch (firstWeekOfYear) {
case dateValues_1.FirstWeekOfYear.FirstFullWeek:
return getWeekOfYearFullDays(date, firstDayOfWeek,
case dateValues_1.FirstWeekOfYear.FirstFourDayWeek:
return getWeekOfYearFullDays(date, firstDayOfWeek, fourDayWeek);
default:
return getFirstDayWeekOfYear(date, firstDayOfWeek);
}
}
exports.getWeekNumber = getWeekNumber;
/**
* Gets the date for the first day of the week based on the given date assuming
* the specified first day of the week.
* @param date - The date to find the beginning of the week date for.
* @returns A new date object representing the first day of the week containing the
input date.
*/
function getStartDateOfWeek(date, firstDayOfWeek) {
var daysOffset = firstDayOfWeek - date.getDay();
if (daysOffset > 0) {
// If first day of week is > date, go 1 week back, to ensure resulting date
is in the past.
daysOffset -= timeConstants_1.TimeConstants.DaysInOneWeek;
}
return addDays(date, daysOffset);
}
exports.getStartDateOfWeek = getStartDateOfWeek;
/**
* Gets the date for the last day of the week based on the given date assuming
* the specified first day of the week.
* @param date - The date to find the beginning of the week date for.
* @returns A new date object representing the first day of the week containing the
input date.
*/
function getEndDateOfWeek(date, firstDayOfWeek) {
var lastDayOfWeek = firstDayOfWeek - 1 >= 0 ? firstDayOfWeek - 1 :
timeConstants_1.TimeConstants.DaysInOneWeek - 1;
var daysOffset = lastDayOfWeek - date.getDay();
if (daysOffset < 0) {
// If last day of week is < date, go 1 week forward, to ensure resulting
date is in the future.
daysOffset += timeConstants_1.TimeConstants.DaysInOneWeek;
}
return addDays(date, daysOffset);
}
exports.getEndDateOfWeek = getEndDateOfWeek;
/**
* Gets a new date with the time portion zeroed out, i.e., set to midnight
* @returns A new date with the time set to midnight
*/
function getDatePart(date) {
return new Date(date.getFullYear(), date.getMonth(), date.getDate());
}
/**
* Helper function to assist in date comparisons
*/
function getDatePartHashValue(date) {
// Generate date hash value created as sum of Date (up to 31 = 5 bits), Month
(up to 11 = 4 bits) and Year.
// eslint-disable-next-line no-bitwise
return date.getDate() + (date.getMonth() << 5) + (date.getFullYear() << 9);
}
exports.getDatePartHashValue = getDatePartHashValue;
/**
* Helper function for `getWeekNumber`.
* Returns week number for a date.
* @param date - current selected date.
* @param firstDayOfWeek - The first day of week (0-6, Sunday = 0)
* @param numberOfFullDays - week settings.
*/
function getWeekOfYearFullDays(date, firstDayOfWeek, numberOfFullDays) {
var dayOfYear = getDayOfYear(date) - 1;
var num = date.getDay() - (dayOfYear %
var lastDayOfPrevYear = new Date(date.getFullYear() - 1,
dateValues_1.MonthOfYear.December, 31);
var daysInYear = getDayOfYear(lastDayOfPrevYear) - 1;
var num2 = (firstDayOfWeek - num + 2 *
timeConstants_1.TimeConstants.DaysInOneWeek) %
timeConstants_1.TimeConstants.DaysInOneWeek;
if (num2 !== 0 && num2 >= numberOfFullDays) {
num2 -= timeConstants_1.TimeConstants.DaysInOneWeek;
}
var num3 = dayOfYear - num2;
if (num3 < 0) {
num -= daysInYear % timeConstants_1.TimeConstants.DaysInOneWeek;
num2 = (firstDayOfWeek - num + 2 *
if (num2 !== 0 && num2 + 1 >= numberOfFullDays) {
num2 -= timeConstants_1.TimeConstants.DaysInOneWeek;
}
num3 = daysInYear - num2;
}
return Math.floor(num3 / timeConstants_1.TimeConstants.DaysInOneWeek + 1);
}
/**
* Returns week number for a date.
* @param date - current selected date.
*/
function getFirstDayWeekOfYear(date, firstDayOfWeek) {
var num = getDayOfYear(date) - 1;
var num2 = date.getDay() - (num % timeConstants_1.TimeConstants.DaysInOneWeek);
var num3 = (num2 - firstDayOfWeek + 2 *
return Math.floor((num + num3) / timeConstants_1.TimeConstants.DaysInOneWeek +
1);
}
/**
* Returns adjusted week day number when `firstDayOfWeek` is other than Sunday.
* For Week Day Number comparison checks
* @param dateWeekDay - shifts number forward to 1 week in case passed as true
* @returns The day of week adjusted to `firstDayOfWeek`; e.g. when
`firstDayOfWeek` is Monday (1),
* Sunday becomes 7.
*/
function adjustWeekDay(firstDayOfWeek, dateWeekDay) {
return firstDayOfWeek !== dateValues_1.DayOfWeek.Sunday && dateWeekDay <
firstDayOfWeek
? dateWeekDay + timeConstants_1.TimeConstants.DaysInOneWeek
: dateWeekDay;
}
/**
* Returns the day number for a date in a year:
* the number of days since January 1st in the particular year.
* @param date - A date to find the day number for.
* @returns The day's number in the year.
*/
function getDayOfYear(date) {
var month = date.getMonth();
var year = date.getFullYear();
var daysUntilDate = 0;
for (var i = 0; i < month; i++) {
daysUntilDate += daysInMonth(i + 1, year);
}
daysUntilDate += date.getDate();
return daysUntilDate;
}
/**
* Returns the number of days in the month
* @param month - The month number to target (months 1-12).
* @param year - The year to target.
* @returns The number of days in the month.
*/
function daysInMonth(month, year) {
return new Date(year, month, 0).getDate();
}
//# sourceMappingURL=dateMath.js.map
/***/ }),
/***/ 49998:
"use strict";

exports.DAYS_IN_WEEK = exports.DateRangeType = exports.FirstWeekOfYear =
exports.MonthOfYear = exports.DayOfWeek = void 0;
/**
* The days of the week
* {@docCategory DateTimeUtilities}
*/
var DayOfWeek;
(function (DayOfWeek) {
DayOfWeek[DayOfWeek["Sunday"] = 0] = "Sunday";
DayOfWeek[DayOfWeek["Monday"] = 1] = "Monday";
DayOfWeek[DayOfWeek["Tuesday"] = 2] = "Tuesday";
DayOfWeek[DayOfWeek["Wednesday"] = 3] = "Wednesday";
DayOfWeek[DayOfWeek["Thursday"] = 4] = "Thursday";
DayOfWeek[DayOfWeek["Friday"] = 5] = "Friday";
DayOfWeek[DayOfWeek["Saturday"] = 6] = "Saturday";
})(DayOfWeek = exports.DayOfWeek || (exports.DayOfWeek = {}));
/**
* The months
*/
var MonthOfYear;
(function (MonthOfYear) {
MonthOfYear[MonthOfYear["January"] = 0] = "January";
MonthOfYear[MonthOfYear["February"] = 1] = "February";
MonthOfYear[MonthOfYear["March"] = 2] = "March";
MonthOfYear[MonthOfYear["April"] = 3] = "April";
MonthOfYear[MonthOfYear["May"] = 4] = "May";
MonthOfYear[MonthOfYear["June"] = 5] = "June";
MonthOfYear[MonthOfYear["July"] = 6] = "July";
MonthOfYear[MonthOfYear["August"] = 7] = "August";
MonthOfYear[MonthOfYear["September"] = 8] = "September";
MonthOfYear[MonthOfYear["October"] = 9] = "October";
MonthOfYear[MonthOfYear["November"] = 10] = "November";
MonthOfYear[MonthOfYear["December"] = 11] = "December";
})(MonthOfYear = exports.MonthOfYear || (exports.MonthOfYear = {}));
/**
* First week of the year settings types
*/
var FirstWeekOfYear;
(function (FirstWeekOfYear) {
FirstWeekOfYear[FirstWeekOfYear["FirstDay"] = 0] = "FirstDay";
FirstWeekOfYear[FirstWeekOfYear["FirstFullWeek"] = 1] = "FirstFullWeek";
FirstWeekOfYear[FirstWeekOfYear["FirstFourDayWeek"] = 2] = "FirstFourDayWeek";
})(FirstWeekOfYear = exports.FirstWeekOfYear || (exports.FirstWeekOfYear = {}));
/**
* The supported date range types
*/
var DateRangeType;
(function (DateRangeType) {
DateRangeType[DateRangeType["Day"] = 0] = "Day";
DateRangeType[DateRangeType["Week"] = 1] = "Week";
DateRangeType[DateRangeType["Month"] = 2] = "Month";
DateRangeType[DateRangeType["WorkWeek"] = 3] = "WorkWeek";
})(DateRangeType = exports.DateRangeType || (exports.DateRangeType = {}));
exports.DAYS_IN_WEEK = 7;
//# sourceMappingURL=dateValues.js.map
/***/ }),
/***/ 82261:
"use strict";

exports.TimeConstants = void 0;
exports.TimeConstants = {
MillisecondsInOneDay: 86400000,
MillisecondsIn1Sec: 1000,
MillisecondsIn1Min: 60000,
MillisecondsIn30Mins: 1800000,
MillisecondsIn1Hour: 3600000,
MinutesInOneDay: 1440,
MinutesInOneHour: 60,
DaysInOneWeek: 7,
MonthInOneYear: 12,
HoursInOneDay: 24,
SecondsInOneMinute: 60,
OffsetTo24HourFormat: 12,
/**
* Matches a time string. Groups:
* 1. hours (with or without leading 0)
* 2. minutes
* 3. seconds (optional)
* 4. meridiem (am/pm, case-insensitive, optional)
*/
TimeFormatRegex: /^(\d\d?):(\d\d):?(\d\d)? ?([ap]m)?/i,
};
//# sourceMappingURL=timeConstants.js.map
/***/ }),
/***/ 45733:
"use strict";

/***/ }),
/***/ 50403:
"use strict";

exports.formatTimeString = void 0;
/**
* Format a date object to a localized time string using the browser's default
locale
* @param date - Input date to format
* @param showSeconds - Whether to show seconds in the formatted string
* @param useHour12 - Whether to use 12-hour time
*/
var formatTimeString = function (date, showSeconds, useHour12) {
return date.toLocaleTimeString([], {
hour: 'numeric',
minute: '2-digit',
second: showSeconds ? '2-digit' : undefined,
hour12: useHour12,
});
};
exports.formatTimeString = formatTimeString;
/***/ }),
/***/ 45111:
"use strict";

exports.getDateFromTimeSelection = exports.ceilMinuteToIncrement =
exports.addMinutes = void 0;
var timeConstants_1 = __webpack_require__(82261);
/**
* Returns a date offset from the given date by the specified number of minutes.
* @param minutes - The number of minutes to offset. 'minutes' can be negative.
minutes
*/
var addMinutes = function (date, minutes) {
result.setTime(result.getTime() + minutes *
timeConstants_1.TimeConstants.MinutesInOneHour *
timeConstants_1.TimeConstants.MillisecondsIn1Sec);
return result;
};
exports.addMinutes = addMinutes;
/**
* Rounds the date's minute up to the next available increment. For example, if
`date` has time 1:21
* and ìncrements` is 5, the resulting time will be 1:25.
* @param date - Date to ceil minutes
* @param increments - Time increments
* @returns Date with ceiled minute
*/
var ceilMinuteToIncrement = function (date, increments) {
var minute = result.getMinutes();
if (timeConstants_1.TimeConstants.MinutesInOneHour % increments) {
result.setMinutes(0);
}
else {
var times = timeConstants_1.TimeConstants.MinutesInOneHour / increments;
for (var i = 1; i <= times; i++) {
if (minute > increments * (i - 1) && minute <= increments * i) {
minute = increments * i;
break;
}
}
result.setMinutes(minute);
}
return result;
};
exports.ceilMinuteToIncrement = ceilMinuteToIncrement;
/**
* Returns a date object from the selected time.
* @param useHour12 - If the time picker uses 12 or 24 hour formatting
* @param baseDate - The baseline date to calculate the offset of the selected time
* @param selectedTime - A string representing the user selected time
* @returns A new date object offset from the baseDate using the selected time.
*/
var getDateFromTimeSelection = function (useHour12, baseDate, selectedTime) {
var _a = timeConstants_1.TimeConstants.TimeFormatRegex.exec(selectedTime) ||
[], selectedHours = _a[1], selectedMinutes = _a[2], selectedSeconds = _a[3],
selectedAp = _a[4];
var hours = +selectedHours;
var minutes = +selectedMinutes;
var seconds = selectedSeconds ? +selectedSeconds : 0;
if (useHour12 && selectedAp) {
if (selectedAp.toLowerCase() === 'pm' && hours !==
timeConstants_1.TimeConstants.OffsetTo24HourFormat) {
hours += timeConstants_1.TimeConstants.OffsetTo24HourFormat;
}
else if (selectedAp.toLowerCase() === 'am' && hours ===
timeConstants_1.TimeConstants.OffsetTo24HourFormat) {
hours -= timeConstants_1.TimeConstants.OffsetTo24HourFormat;
}
}
var hoursOffset;
if (baseDate.getHours() > hours || (baseDate.getHours() === hours &&
baseDate.getMinutes() > minutes)) {
hoursOffset = timeConstants_1.TimeConstants.HoursInOneDay -
baseDate.getHours() + hours;
}
else {
hoursOffset = Math.abs(baseDate.getHours() - hours);
}
var offset = timeConstants_1.TimeConstants.MillisecondsIn1Sec *
timeConstants_1.TimeConstants.MinutesInOneHour * hoursOffset *
timeConstants_1.TimeConstants.SecondsInOneMinute +
seconds * timeConstants_1.TimeConstants.MillisecondsIn1Sec;
var date = new Date(baseDate.getTime() + offset);
date.setMinutes(minutes);
date.setSeconds(seconds);
return date;
};
exports.getDateFromTimeSelection = getDateFromTimeSelection;
//# sourceMappingURL=timeMath.js.map
/***/ }),
/***/ 1723:
"use strict";

// Do not modify this file; it is generated as part of publish.
// The checked in version is a placeholder only and will not be updated.
var set_version_1 = __webpack_require__(74984);
set_version_1.setVersion('@fluentui/date-time-utilities', '8.5.1');
//# sourceMappingURL=version.js.map
/***/ }),
/***/ 56779:
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ "__assign": () => (/* binding */ __assign),
/* harmony export */ "__asyncDelegator": () => (/* binding */ __asyncDelegator),
/* harmony export */ "__asyncGenerator": () => (/* binding */ __asyncGenerator),
/* harmony export */ "__asyncValues": () => (/* binding */ __asyncValues),
/* harmony export */ "__await": () => (/* binding */ __await),
/* harmony export */ "__awaiter": () => (/* binding */ __awaiter),
/* harmony export */ "__classPrivateFieldGet": () => (/* binding */
__classPrivateFieldGet),
/* harmony export */ "__classPrivateFieldIn": () => (/* binding */
__classPrivateFieldIn),
/* harmony export */ "__classPrivateFieldSet": () => (/* binding */
__classPrivateFieldSet),
/* harmony export */ "__createBinding": () => (/* binding */ __createBinding),
/* harmony export */ "__decorate": () => (/* binding */ __decorate),
/* harmony export */ "__exportStar": () => (/* binding */ __exportStar),
/* harmony export */ "__extends": () => (/* binding */ __extends),
/* harmony export */ "__generator": () => (/* binding */ __generator),
/* harmony export */ "__importDefault": () => (/* binding */ __importDefault),
/* harmony export */ "__importStar": () => (/* binding */ __importStar),
/* harmony export */ "__makeTemplateObject": () => (/* binding */
__makeTemplateObject),
/* harmony export */ "__metadata": () => (/* binding */ __metadata),
/* harmony export */ "__param": () => (/* binding */ __param),
/* harmony export */ "__read": () => (/* binding */ __read),
/* harmony export */ "__rest": () => (/* binding */ __rest),
/* harmony export */ "__spread": () => (/* binding */ __spread),
/* harmony export */ "__spreadArray": () => (/* binding */ __spreadArray),
/* harmony export */ "__spreadArrays": () => (/* binding */ __spreadArrays),
/* harmony export */ "__values": () => (/* binding */ __values)
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {

extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ =
b; }) ||
function (d, b) { for (var p in b) if
(Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a
constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new
__());
}
var __assign = function() {

__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] =
s[p];
}
return t;
}
return __assign.apply(this, arguments);
}
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p)
< 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 &&
Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {

var c = arguments.length, r = c < 3 ? target : desc === null ? desc =
Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r =
Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r
= (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {

return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {

if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {

function adopt(value) { return value instanceof P ? value : new P(function
(resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e)
{ reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch
(e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) :
adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {

var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return
t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof
Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] ||
((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) &&
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
{ _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op;
break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op);
break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done:
true };
}
}
var __createBinding = Object.create ? (function(o, m, k, k2) {

if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable ||
desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m) if (p !== "default" && !
Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not
defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s +=
arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {

if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l;
i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {

if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not
defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"),
i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function
(a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3],
e); } }
function step(r) { r.value instanceof __await ?
Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0]
[1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }),
verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value:
__await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) :
o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"),
i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function
(resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v)
{ resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {

if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value:
raw }); } else { cooked.raw = raw; }
return cooked;
};
var __setModuleDefault = Object.create ? (function(o, v) {

Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" &&
Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {

if (kind === "a" && !f) throw new TypeError("Private accessor was defined
without a getter");
if (typeof state === "function" ? receiver !== state || !f : !
state.has(receiver)) throw new TypeError("Cannot read private member from an object
whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value :
state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {

if (kind === "m") throw new TypeError("Private method is not writable");
without a setter");
state.has(receiver)) throw new TypeError("Cannot write private member to an object
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value :
state.set(receiver, value)), value;
}
function __classPrivateFieldIn(state, receiver) {

if (receiver === null || (typeof receiver !== "object" && typeof receiver !==
"function")) throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
}
/***/ }),
/***/ 85845:
"use strict";

//# sourceMappingURL=IVirtualElement.js.map
/***/ }),
/***/ 40809:
"use strict";

exports.elementContains = void 0;
var getParent_1 = __webpack_require__(58667);
/**
* Determines whether or not a parent element contains a given child element.
* If àllowVirtualParents` is true, this method may return `true` if the child
* has the parent in its virtual element hierarchy.
*
* @public
*/
function elementContains(parent, child, allowVirtualParents) {
if (allowVirtualParents === void 0) { allowVirtualParents = true; }
var isContained = false;
if (parent && child) {
if (allowVirtualParents) {
if (parent === child) {
isContained = true;
}
else {
isContained = false;
while (child) {
var nextParent = getParent_1.getParent(child);
if (nextParent === parent) {
isContained = true;
break;
}
child = nextParent;
}
}
}
else if (parent.contains) {
isContained = parent.contains(child);
}
}
return isContained;
}
exports.elementContains = elementContains;
//# sourceMappingURL=elementContains.js.map
/***/ }),
/***/ 44684:
"use strict";

exports.elementContainsAttribute = void 0;
var findElementRecursive_1 = __webpack_require__(49000);
/**
* Determines if an element, or any of its ancestors, contain the given attribute
* @param element - element to start searching at
* @param attribute - the attribute to search for
* @returns the value of the first instance found
*/
function elementContainsAttribute(element, attribute) {
var elementMatch = findElementRecursive_1.findElementRecursive(element,
function (testElement) { return testElement.hasAttribute(attribute); });
return elementMatch && elementMatch.getAttribute(attribute);
}
exports.elementContainsAttribute = elementContainsAttribute;
//# sourceMappingURL=elementContainsAttribute.js.map
/***/ }),
/***/ 49000:
"use strict";

exports.findElementRecursive = void 0;
/**
* Finds the first parent element where the matchFunction returns true
* @param matchFunction - the function that determines if the element is a match
* @returns the matched element or null no match was found
*/
function findElementRecursive(element, matchFunction) {
if (!element || element === document.body) {
return null;
}
return matchFunction(element) ? element :
findElementRecursive(getParent_1.getParent(element), matchFunction);
}
exports.findElementRecursive = findElementRecursive;
//# sourceMappingURL=findElementRecursive.js.map
/***/ }),
/***/ 38111:
"use strict";

exports.getChildren = void 0;
var isVirtualElement_1 = __webpack_require__(97165);
/**
* Gets the elements which are child elements of the given element.
* If àllowVirtualChildren` is `true`, this method enumerates virtual child
elements
* after the original children.
* @param parent - The element to get the children of.
* @param allowVirtualChildren - true if the method should enumerate virtual child
elements.
*/
function getChildren(parent, allowVirtualChildren) {
if (allowVirtualChildren === void 0) { allowVirtualChildren = true; }
var children = [];
if (parent) {
for (var i = 0; i < parent.children.length; i++) {
children.push(parent.children.item(i));
}
if (allowVirtualChildren && isVirtualElement_1.isVirtualElement(parent)) {
children.push.apply(children, parent._virtual.children);
}
}
return children;
}
exports.getChildren = getChildren;
//# sourceMappingURL=getChildren.js.map
/***/ }),
/***/ 58667:
"use strict";

exports.getParent = void 0;
var getVirtualParent_1 = __webpack_require__(30144);
/**
* Gets the element which is the parent of a given element.
* If àllowVirtuaParents` is `true`, this method prefers the virtual parent over
* real DOM parent when present.
*
* @public
*/
function getParent(child, allowVirtualParents) {
if (allowVirtualParents === void 0) { allowVirtualParents = true; }
return (child &&
((allowVirtualParents && getVirtualParent_1.getVirtualParent(child)) ||
(child.parentNode && child.parentNode)));
}
exports.getParent = getParent;
//# sourceMappingURL=getParent.js.map
/***/ }),
/***/ 30144:
"use strict";

exports.getVirtualParent = void 0;
/**
* Gets the virtual parent given the child element, if it exists.
*
* @public
*/
function getVirtualParent(child) {
var parent;
if (child && isVirtualElement_1.isVirtualElement(child)) {
parent = child._virtual.parent;
}
return parent;
}
exports.getVirtualParent = getVirtualParent;
//# sourceMappingURL=getVirtualParent.js.map
/***/ }),
/***/ 2970:
"use strict";

/***/ }),
/***/ 97165:
"use strict";

exports.isVirtualElement = void 0;
/**
* Determines whether or not an element has the virtual hierarchy extension.
*
* @public
*/
function isVirtualElement(element) {
return element && !!element._virtual;
}
exports.isVirtualElement = isVirtualElement;
//# sourceMappingURL=isVirtualElement.js.map
/***/ }),
/***/ 65309:
"use strict";

exports.portalContainsElement = void 0;
var setPortalAttribute_1 = __webpack_require__(22728);
/**
* Determine whether a target is within a portal from perspective of root or
optional parent.
* This function only works against portal components that use the
setPortalAttribute function.
* If both parent and child are within the same portal this function will return
false.
* @param target - Element to query portal containment status of.
* @param parent - Optional parent perspective. Search for containing portal stops
at parent
* (or root if parent is undefined or invalid.)
*/
function portalContainsElement(target, parent) {
var elementMatch = findElementRecursive_1.findElementRecursive(target, function
(testElement) { return parent === testElement ||
testElement.hasAttribute(setPortalAttribute_1.DATA_PORTAL_ATTRIBUTE); });
return elementMatch !== null &&
elementMatch.hasAttribute(setPortalAttribute_1.DATA_PORTAL_ATTRIBUTE);
}
exports.portalContainsElement = portalContainsElement;
//# sourceMappingURL=portalContainsElement.js.map
/***/ }),
/***/ 22728:
"use strict";

exports.setPortalAttribute = exports.DATA_PORTAL_ATTRIBUTE = void 0;
exports.DATA_PORTAL_ATTRIBUTE = 'data-portal-element';
/**
* Identify element as a portal by setting an attribute.
* @param element - Element to mark as a portal.
*/
function setPortalAttribute(element) {
element.setAttribute(exports.DATA_PORTAL_ATTRIBUTE, 'true');
}
exports.setPortalAttribute = setPortalAttribute;
//# sourceMappingURL=setPortalAttribute.js.map
/***/ }),
/***/ 35906:
"use strict";

exports.setVirtualParent = void 0;
/**
* Sets the virtual parent of an element.
* Pass ùndefined` as the `parent` to clear the virtual parent.
*
* @public
*/
function setVirtualParent(child, parent) {
var virtualChild = child;
var virtualParent = parent;
if (!virtualChild._virtual) {
virtualChild._virtual = {
children: [],
};
}
var oldParent = virtualChild._virtual.parent;
if (oldParent && oldParent !== parent) {
// Remove the child from its old parent.
var index = oldParent._virtual.children.indexOf(virtualChild);
if (index > -1) {
oldParent._virtual.children.splice(index, 1);
}
}
virtualChild._virtual.parent = virtualParent || undefined;
if (virtualParent) {
if (!virtualParent._virtual) {
virtualParent._virtual = {
children: [],
};
}
virtualParent._virtual.children.push(virtualChild);
}
}
exports.setVirtualParent = setVirtualParent;
//# sourceMappingURL=setVirtualParent.js.map
/***/ }),
/***/ 90494:
"use strict";

set_version_1.setVersion('@fluentui/dom-utilities', '2.2.1');
/***/ }),
/***/ 46202:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}
}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 1032:
"use strict";
// Your use of the content in the files referenced here is subject to the terms of
the license at https://aka.ms/fluentui-assets-license
exports.initializeIcons = void 0;
var style_utilities_1 = __webpack_require__(29840);
function initializeIcons(baseUrl, options) {
if (baseUrl === void 0) { baseUrl = ''; }
var subset = {
style: {
MozOsxFontSmoothing: 'grayscale',
WebkitFontSmoothing: 'antialiased',
fontStyle: 'normal',
fontWeight: 'normal',
speak: 'none'
},
fontFace: {
fontFamily: "\"FabricMDL2Icons-0\"",
src: "url('" + baseUrl + "fabric-icons-0-467ee27f.woff')
format('woff')"
},
icons: {
'PageLink': '\uE302',
'CommentSolid': '\uE30E',
'ChangeEntitlements': '\uE310',
'Installation': '\uE311',
'WebAppBuilderModule': '\uE313',
'WebAppBuilderFragment': '\uE314',
'WebAppBuilderSlot': '\uE315',
'BullseyeTargetEdit': '\uE319',
'WebAppBuilderFragmentCreate': '\uE31B',
'PageData': '\uE31C',
'PageHeaderEdit': '\uE31D',
'ProductList': '\uE31E',
'UnpublishContent': '\uE31F',
'DependencyAdd': '\uE344',
'DependencyRemove': '\uE345',
'EntitlementPolicy': '\uE346',
'EntitlementRedemption': '\uE347',
'SchoolDataSyncLogo': '\uE34C',
'PinSolid12': '\uE352',
'PinSolidOff12': '\uE353',
'AddLink': '\uE35E',
'SharepointAppIcon16': '\uE365',
'DataflowsLink': '\uE366',
'TimePicker': '\uE367',
'UserWarning': '\uE368',
'ComplianceAudit': '\uE369',
'InternetSharing': '\uE704',
'Brightness': '\uE706',
'MapPin': '\uE707',
'Airplane': '\uE709',
'Tablet': '\uE70A',
'QuickNote': '\uE70B',
'Video': '\uE714',
'People': '\uE716',
'Phone': '\uE717',
'Pin': '\uE718',
'Shop': '\uE719',
'Stop': '\uE71A',
'Link': '\uE71B',
'AllApps': '\uE71D',
'Zoom': '\uE71E',
'ZoomOut': '\uE71F',
'Microphone': '\uE720',
'Camera': '\uE722',
'Attach': '\uE723',
'Send': '\uE724',
'FavoriteList': '\uE728',
'PageSolid': '\uE729',
'Forward': '\uE72A',
'Back': '\uE72B',
'Refresh': '\uE72C',
'Lock': '\uE72E',
'ReportHacked': '\uE730',
'EMI': '\uE731',
'MiniLink': '\uE732',
'Blocked': '\uE733',
'ReadingMode': '\uE736',
'Favicon': '\uE737',
'Remove': '\uE738',
'Checkbox': '\uE739',
'CheckboxComposite': '\uE73A',
'CheckboxFill': '\uE73B',
'CheckboxIndeterminate': '\uE73C',
'CheckboxCompositeReversed': '\uE73D',
'BackToWindow': '\uE73F',
'FullScreen': '\uE740',
'Print': '\uE749',
'Up': '\uE74A',
'Down': '\uE74B',
'OEM': '\uE74C',
'Save': '\uE74E',
'ReturnKey': '\uE751',
'Cloud': '\uE753',
'Flashlight': '\uE754',
'CommandPrompt': '\uE756',
'Sad': '\uE757',
'RealEstate': '\uE758',
'SIPMove': '\uE759',
'EraseTool': '\uE75C',
'GripperTool': '\uE75E',
'Dialpad': '\uE75F',
'PageLeft': '\uE760',
'PageRight': '\uE761',
'MultiSelect': '\uE762',
'KeyboardClassic': '\uE765',
'Play': '\uE768',
'Pause': '\uE769',
'InkingTool': '\uE76D',
'Emoji2': '\uE76E',
'GripperBarHorizontal': '\uE76F',
'System': '\uE770',
'Personalize': '\uE771',
'SearchAndApps': '\uE773',
'Globe': '\uE774',
'EaseOfAccess': '\uE776',
'ContactInfo': '\uE779',
'Unpin': '\uE77A',
'Contact': '\uE77B',
'Memo': '\uE77C',
'IncomingCall': '\uE77E'
}
};
style_utilities_1.registerIcons(subset, options);
}
exports.initializeIcons = initializeIcons;
//# sourceMappingURL=fabric-icons-0.js.map
/***/ }),
/***/ 52488:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-1-4d521695.woff')
format('woff')"
},
icons: {
'Paste': '\uE77F',
'WindowsLogo': '\uE782',
'Error': '\uE783',
'GripperBarVertical': '\uE784',
'Unlock': '\uE785',
'Slideshow': '\uE786',
'Trim': '\uE78A',
'AutoEnhanceOn': '\uE78D',
'AutoEnhanceOff': '\uE78E',
'Color': '\uE790',
'SaveAs': '\uE792',
'Light': '\uE793',
'Filters': '\uE795',
'AspectRatio': '\uE799',
'Contrast': '\uE7A1',
'Redo': '\uE7A6',
'Crop': '\uE7A8',
'PhotoCollection': '\uE7AA',
'Album': '\uE7AB',
'Rotate': '\uE7AD',
'PanoIndicator': '\uE7B0',
'Translate': '\uE7B2',
'RedEye': '\uE7B3',
'ViewOriginal': '\uE7B4',
'ThumbnailView': '\uE7B6',
'Package': '\uE7B8',
'Telemarketer': '\uE7B9',
'Warning': '\uE7BA',
'Financial': '\uE7BB',
'Education': '\uE7BE',
'ShoppingCart': '\uE7BF',
'Train': '\uE7C0',
'Move': '\uE7C2',
'TouchPointer': '\uE7C9',
'Merge': '\uE7D5',
'TurnRight': '\uE7DB',
'Ferry': '\uE7E3',
'Highlight': '\uE7E6',
'PowerButton': '\uE7E8',
'Tab': '\uE7E9',
'Admin': '\uE7EF',
'TVMonitor': '\uE7F4',
'Speakers': '\uE7F5',
'Game': '\uE7FC',
'HorizontalTabKey': '\uE7FD',
'UnstackSelected': '\uE7FE',
'StackIndicator': '\uE7FF',
'Nav2DMapView': '\uE800',
'StreetsideSplitMinimize': '\uE802',
'Car': '\uE804',
'Bus': '\uE806',
'EatDrink': '\uE807',
'SeeDo': '\uE808',
'LocationCircle': '\uE80E',
'Home': '\uE80F',
'SwitcherStartEnd': '\uE810',
'ParkingLocation': '\uE811',
'IncidentTriangle': '\uE814',
'Touch': '\uE815',
'MapDirections': '\uE816',
'CaretHollow': '\uE817',
'CaretSolid': '\uE818',
'History': '\uE81C',
'Location': '\uE81D',
'MapLayers': '\uE81E',
'SearchNearby': '\uE820',
'Work': '\uE821',
'Recent': '\uE823',
'Hotel': '\uE824',
'Bank': '\uE825',
'LocationDot': '\uE827',
'Dictionary': '\uE82D',
'ChromeBack': '\uE830',
'FolderOpen': '\uE838',
'PinnedFill': '\uE842',
'RevToggleKey': '\uE845',
'USB': '\uE88E',
'Previous': '\uE892',
'Next': '\uE893',
'Sync': '\uE895',
'Help': '\uE897',
'Emoji': '\uE899',
'MailForward': '\uE89C',
'ClosePane': '\uE89F',
'OpenPane': '\uE8A0',
'PreviewLink': '\uE8A1',
'ZoomIn': '\uE8A3',
'Bookmarks': '\uE8A4',
'Document': '\uE8A5',
'ProtectedDocument': '\uE8A6',
'OpenInNewWindow': '\uE8A7',
'MailFill': '\uE8A8',
'ViewAll': '\uE8A9',
'Switch': '\uE8AB',
'Rename': '\uE8AC',
'Go': '\uE8AD',
'Remote': '\uE8AF',
'SelectAll': '\uE8B3',
'Orientation': '\uE8B4',
'Import': '\uE8B5'
}
};
}
/***/ }),
/***/ 8257:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-10-c4ded8e4.woff')
format('woff')"
},
icons: {
'ViewListGroup': '\uF248',
'ViewListTree': '\uF249',
'TriggerAuto': '\uF24A',
'TriggerUser': '\uF24B',
'PivotChart': '\uF24C',
'StackedBarChart': '\uF24D',
'StackedLineChart': '\uF24E',
'BuildQueue': '\uF24F',
'BuildQueueNew': '\uF250',
'UserFollowed': '\uF25C',
'ContactLink': '\uF25F',
'Stack': '\uF26F',
'Bullseye': '\uF272',
'VennDiagram': '\uF273',
'FiveTileGrid': '\uF274',
'FocalPoint': '\uF277',
'Insert': '\uF278',
'RingerRemove': '\uF279',
'TeamsLogoInverse': '\uF27A',
'TeamsLogo': '\uF27B',
'TeamsLogoFill': '\uF27C',
'SkypeForBusinessLogoFill': '\uF27D',
'SharepointLogo': '\uF27E',
'SharepointLogoFill': '\uF27F',
'DelveLogo': '\uF280',
'DelveLogoFill': '\uF281',
'OfficeVideoLogo': '\uF282',
'OfficeVideoLogoFill': '\uF283',
'ExchangeLogo': '\uF284',
'ExchangeLogoFill': '\uF285',
'Signin': '\uF286',
'DocumentApproval': '\uF28B',
'CloneToDesktop': '\uF28C',
'InstallToDrive': '\uF28D',
'Blur': '\uF28E',
'Build': '\uF28F',
'ProcessMetaTask': '\uF290',
'BranchFork2': '\uF291',
'BranchLocked': '\uF292',
'BranchCommit': '\uF293',
'BranchCompare': '\uF294',
'BranchMerge': '\uF295',
'BranchPullRequest': '\uF296',
'BranchSearch': '\uF297',
'BranchShelveset': '\uF298',
'RawSource': '\uF299',
'MergeDuplicate': '\uF29A',
'RowsGroup': '\uF29B',
'RowsChild': '\uF29C',
'Deploy': '\uF29D',
'Redeploy': '\uF29E',
'ServerEnviroment': '\uF29F',
'VisioDiagram': '\uF2A0',
'HighlightMappedShapes': '\uF2A1',
'TextCallout': '\uF2A2',
'IconSetsFlag': '\uF2A4',
'VisioLogo': '\uF2A7',
'VisioLogoFill': '\uF2A8',
'VisioDocument': '\uF2A9',
'TimelineProgress': '\uF2AA',
'TimelineDelivery': '\uF2AB',
'Backlog': '\uF2AC',
'TeamFavorite': '\uF2AD',
'TaskGroup': '\uF2AE',
'TaskGroupMirrored': '\uF2AF',
'ScopeTemplate': '\uF2B0',
'AssessmentGroupTemplate': '\uF2B1',
'NewTeamProject': '\uF2B2',
'CommentAdd': '\uF2B3',
'CommentNext': '\uF2B4',
'CommentPrevious': '\uF2B5',
'ShopServer': '\uF2B6',
'LocaleLanguage': '\uF2B7',
'QueryList': '\uF2B8',
'UserSync': '\uF2B9',
'UserPause': '\uF2BA',
'StreamingOff': '\uF2BB',
'ArrowTallUpLeft': '\uF2BD',
'ArrowTallUpRight': '\uF2BE',
'ArrowTallDownLeft': '\uF2BF',
'ArrowTallDownRight': '\uF2C0',
'FieldEmpty': '\uF2C1',
'FieldFilled': '\uF2C2',
'FieldChanged': '\uF2C3',
'FieldNotChanged': '\uF2C4',
'RingerOff': '\uF2C5',
'PlayResume': '\uF2C6',
'BulletedList2': '\uF2C7',
'BulletedList2Mirrored': '\uF2C8',
'ImageCrosshair': '\uF2C9',
'GitGraph': '\uF2CA',
'Repo': '\uF2CB',
'RepoSolid': '\uF2CC',
'FolderQuery': '\uF2CD',
'FolderList': '\uF2CE',
'FolderListMirrored': '\uF2CF',
'LocationOutline': '\uF2D0',
'POISolid': '\uF2D1',
'CalculatorNotEqualTo': '\uF2D2',
'BoxSubtractSolid': '\uF2D3'
}
};
}
/***/ }),
/***/ 19402:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-11-2a8393d6.woff')
format('woff')"
},
icons: {
'BoxAdditionSolid': '\uF2D4',
'BoxMultiplySolid': '\uF2D5',
'BoxPlaySolid': '\uF2D6',
'BoxCheckmarkSolid': '\uF2D7',
'CirclePauseSolid': '\uF2D8',
'CirclePause': '\uF2D9',
'MSNVideosSolid': '\uF2DA',
'CircleStopSolid': '\uF2DB',
'CircleStop': '\uF2DC',
'NavigateBack': '\uF2DD',
'NavigateBackMirrored': '\uF2DE',
'NavigateForward': '\uF2DF',
'NavigateForwardMirrored': '\uF2E0',
'UnknownSolid': '\uF2E1',
'UnknownMirroredSolid': '\uF2E2',
'CircleAddition': '\uF2E3',
'CircleAdditionSolid': '\uF2E4',
'FilePDB': '\uF2E5',
'FileTemplate': '\uF2E6',
'FileSQL': '\uF2E7',
'FileJAVA': '\uF2E8',
'FileASPX': '\uF2E9',
'FileCSS': '\uF2EA',
'FileSass': '\uF2EB',
'FileLess': '\uF2EC',
'FileHTML': '\uF2ED',
'JavaScriptLanguage': '\uF2EE',
'CSharpLanguage': '\uF2EF',
'CSharp': '\uF2F0',
'VisualBasicLanguage': '\uF2F1',
'VB': '\uF2F2',
'CPlusPlusLanguage': '\uF2F3',
'CPlusPlus': '\uF2F4',
'FSharpLanguage': '\uF2F5',
'FSharp': '\uF2F6',
'TypeScriptLanguage': '\uF2F7',
'PythonLanguage': '\uF2F8',
'PY': '\uF2F9',
'CoffeeScript': '\uF2FA',
'MarkDownLanguage': '\uF2FB',
'FullWidth': '\uF2FE',
'FullWidthEdit': '\uF2FF',
'Plug': '\uF300',
'PlugSolid': '\uF301',
'PlugConnected': '\uF302',
'PlugDisconnected': '\uF303',
'UnlockSolid': '\uF304',
'Variable': '\uF305',
'Parameter': '\uF306',
'CommentUrgent': '\uF307',
'Storyboard': '\uF308',
'DiffInline': '\uF309',
'DiffSideBySide': '\uF30A',
'ImageDiff': '\uF30B',
'ImagePixel': '\uF30C',
'FileBug': '\uF30D',
'FileCode': '\uF30E',
'FileComment': '\uF30F',
'BusinessHoursSign': '\uF310',
'FileImage': '\uF311',
'FileSymlink': '\uF312',
'AutoFillTemplate': '\uF313',
'WorkItem': '\uF314',
'WorkItemBug': '\uF315',
'LogRemove': '\uF316',
'ColumnOptions': '\uF317',
'Packages': '\uF318',
'BuildIssue': '\uF319',
'AssessmentGroup': '\uF31A',
'VariableGroup': '\uF31B',
'FullHistory': '\uF31C',
'Wheelchair': '\uF31F',
'SingleColumnEdit': '\uF321',
'DoubleColumnEdit': '\uF322',
'TripleColumnEdit': '\uF323',
'ColumnLeftTwoThirdsEdit': '\uF324',
'ColumnRightTwoThirdsEdit': '\uF325',
'StreamLogo': '\uF329',
'PassiveAuthentication': '\uF32A',
'AlertSolid': '\uF331',
'MegaphoneSolid': '\uF332',
'TaskSolid': '\uF333',
'ConfigurationSolid': '\uF334',
'BugSolid': '\uF335',
'CrownSolid': '\uF336',
'Trophy2Solid': '\uF337',
'QuickNoteSolid': '\uF338',
'ConstructionConeSolid': '\uF339',
'PageListSolid': '\uF33A',
'PageListMirroredSolid': '\uF33B',
'StarburstSolid': '\uF33C',
'ReadingModeSolid': '\uF33D',
'SadSolid': '\uF33E',
'HealthSolid': '\uF33F',
'ShieldSolid': '\uF340',
'GiftBoxSolid': '\uF341',
'ShoppingCartSolid': '\uF342',
'MailSolid': '\uF343',
'ChatSolid': '\uF344',
'RibbonSolid': '\uF345'
}
};
}
/***/ }),
/***/ 39216:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-12-7e945a1e.woff')
format('woff')"
},
icons: {
'FinancialSolid': '\uF346',
'FinancialMirroredSolid': '\uF347',
'HeadsetSolid': '\uF348',
'PermissionsSolid': '\uF349',
'ParkingSolid': '\uF34A',
'ParkingMirroredSolid': '\uF34B',
'DiamondSolid': '\uF34C',
'AsteriskSolid': '\uF34D',
'OfflineStorageSolid': '\uF34E',
'BankSolid': '\uF34F',
'DecisionSolid': '\uF350',
'Parachute': '\uF351',
'ParachuteSolid': '\uF352',
'FiltersSolid': '\uF353',
'ColorSolid': '\uF354',
'ReviewSolid': '\uF355',
'ReviewRequestSolid': '\uF356',
'ReviewRequestMirroredSolid': '\uF357',
'ReviewResponseSolid': '\uF358',
'FeedbackRequestSolid': '\uF359',
'FeedbackRequestMirroredSolid': '\uF35A',
'FeedbackResponseSolid': '\uF35B',
'WorkItemBar': '\uF35C',
'WorkItemBarSolid': '\uF35D',
'Separator': '\uF35E',
'NavigateExternalInline': '\uF35F',
'PlanView': '\uF360',
'TimelineMatrixView': '\uF361',
'EngineeringGroup': '\uF362',
'ProjectCollection': '\uF363',
'CaretBottomRightCenter8': '\uF364',
'CaretBottomLeftCenter8': '\uF365',
'CaretTopRightCenter8': '\uF366',
'CaretTopLeftCenter8': '\uF367',
'DonutChart': '\uF368',
'ChevronUnfold10': '\uF369',
'ChevronFold10': '\uF36A',
'DoubleChevronDown8': '\uF36B',
'DoubleChevronUp8': '\uF36C',
'DoubleChevronLeft8': '\uF36D',
'DoubleChevronRight8': '\uF36E',
'ChevronDownEnd6': '\uF36F',
'ChevronUpEnd6': '\uF370',
'ChevronLeftEnd6': '\uF371',
'ChevronRightEnd6': '\uF372',
'ContextMenu': '\uF37C',
'AzureAPIManagement': '\uF37F',
'AzureServiceEndpoint': '\uF380',
'VSTSLogo': '\uF381',
'VSTSAltLogo1': '\uF382',
'VSTSAltLogo2': '\uF383',
'FileTypeSolution': '\uF387',
'WordLogoInverse16': '\uF390',
'WordLogo16': '\uF391',
'WordLogoFill16': '\uF392',
'PowerPointLogoInverse16': '\uF393',
'PowerPointLogo16': '\uF394',
'PowerPointLogoFill16': '\uF395',
'ExcelLogoInverse16': '\uF396',
'ExcelLogo16': '\uF397',
'ExcelLogoFill16': '\uF398',
'OneNoteLogoInverse16': '\uF399',
'OneNoteLogo16': '\uF39A',
'OneNoteLogoFill16': '\uF39B',
'OutlookLogoInverse16': '\uF39C',
'OutlookLogo16': '\uF39D',
'OutlookLogoFill16': '\uF39E',
'PublisherLogoInverse16': '\uF39F',
'PublisherLogo16': '\uF3A0',
'PublisherLogoFill16': '\uF3A1',
'VisioLogoInverse16': '\uF3A2',
'VisioLogo16': '\uF3A3',
'VisioLogoFill16': '\uF3A4',
'TestBeaker': '\uF3A5',
'TestBeakerSolid': '\uF3A6',
'TestExploreSolid': '\uF3A7',
'TestAutoSolid': '\uF3A8',
'TestUserSolid': '\uF3A9',
'TestImpactSolid': '\uF3AA',
'TestPlan': '\uF3AB',
'TestStep': '\uF3AC',
'TestParameter': '\uF3AD',
'TestSuite': '\uF3AE',
'TestCase': '\uF3AF',
'Sprint': '\uF3B0',
'SignOut': '\uF3B1',
'TriggerApproval': '\uF3B2',
'Rocket': '\uF3B3',
'AzureKeyVault': '\uF3B4',
'Onboarding': '\uF3BA',
'Transition': '\uF3BC',
'LikeSolid': '\uF3BF',
'DislikeSolid': '\uF3C0',
'CRMCustomerInsightsApp': '\uF3C8',
'EditCreate': '\uF3C9',
'PlayReverseResume': '\uF3E4',
'PlayReverse': '\uF3E5',
'SearchData': '\uF3F1',
'UnSetColor': '\uF3F9',
'DeclineCall': '\uF405'
}
};
}
/***/ }),
/***/ 47786:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-13-c3989a02.woff')
format('woff')"
},
icons: {
'RectangularClipping': '\uF407',
'TeamsLogo16': '\uF40A',
'TeamsLogoFill16': '\uF40B',
'Spacer': '\uF40D',
'SkypeLogo16': '\uF40E',
'SkypeForBusinessLogo16': '\uF40F',
'SkypeForBusinessLogoFill16': '\uF410',
'FilterSolid': '\uF412',
'MailUndelivered': '\uF415',
'MailTentative': '\uF416',
'MailTentativeMirrored': '\uF417',
'MailReminder': '\uF418',
'ReceiptUndelivered': '\uF419',
'ReceiptTentative': '\uF41A',
'ReceiptTentativeMirrored': '\uF41B',
'Inbox': '\uF41C',
'IRMReply': '\uF41D',
'IRMReplyMirrored': '\uF41E',
'IRMForward': '\uF41F',
'IRMForwardMirrored': '\uF420',
'VoicemailIRM': '\uF421',
'EventAccepted': '\uF422',
'EventTentative': '\uF423',
'EventTentativeMirrored': '\uF424',
'EventDeclined': '\uF425',
'IDBadge': '\uF427',
'BackgroundColor': '\uF42B',
'OfficeFormsLogoInverse16': '\uF433',
'OfficeFormsLogo': '\uF434',
'OfficeFormsLogoFill': '\uF435',
'OfficeFormsLogo16': '\uF436',
'OfficeFormsLogoFill16': '\uF437',
'OfficeFormsLogoInverse24': '\uF43A',
'OfficeFormsLogo24': '\uF43B',
'OfficeFormsLogoFill24': '\uF43C',
'PageLock': '\uF43F',
'NotExecuted': '\uF440',
'NotImpactedSolid': '\uF441',
'FieldReadOnly': '\uF442',
'FieldRequired': '\uF443',
'BacklogBoard': '\uF444',
'ExternalBuild': '\uF445',
'ExternalTFVC': '\uF446',
'ExternalXAML': '\uF447',
'IssueSolid': '\uF448',
'DefectSolid': '\uF449',
'LadybugSolid': '\uF44A',
'NugetLogo': '\uF44C',
'TFVCLogo': '\uF44D',
'ProjectLogo32': '\uF47E',
'ProjectLogoFill32': '\uF47F',
'ProjectLogo16': '\uF480',
'ProjectLogoFill16': '\uF481',
'SwayLogo32': '\uF482',
'SwayLogoFill32': '\uF483',
'SwayLogo16': '\uF484',
'SwayLogoFill16': '\uF485',
'ClassNotebookLogo32': '\uF486',
'ClassNotebookLogoFill32': '\uF487',
'ClassNotebookLogo16': '\uF488',
'ClassNotebookLogoFill16': '\uF489',
'ClassNotebookLogoInverse32': '\uF48A',
'ClassNotebookLogoInverse16': '\uF48B',
'StaffNotebookLogo32': '\uF48C',
'StaffNotebookLogoFill32': '\uF48D',
'StaffNotebookLogo16': '\uF48E',
'StaffNotebookLogoFill16': '\uF48F',
'StaffNotebookLogoInverted32': '\uF490',
'StaffNotebookLogoInverted16': '\uF491',
'KaizalaLogo': '\uF492',
'TaskLogo': '\uF493',
'ProtectionCenterLogo32': '\uF494',
'GallatinLogo': '\uF496',
'Globe2': '\uF49A',
'Guitar': '\uF49B',
'Breakfast': '\uF49C',
'Brunch': '\uF49D',
'BeerMug': '\uF49E',
'Vacation': '\uF49F',
'Teeth': '\uF4A0',
'Taxi': '\uF4A1',
'Chopsticks': '\uF4A2',
'SyncOccurence': '\uF4A3',
'UnsyncOccurence': '\uF4A4',
'GIF': '\uF4A9',
'PrimaryCalendar': '\uF4AE',
'SearchCalendar': '\uF4AF',
'VideoOff': '\uF4B0',
'MicrosoftFlowLogo': '\uF4B1',
'BusinessCenterLogo': '\uF4B2',
'ToDoLogoBottom': '\uF4B3',
'ToDoLogoTop': '\uF4B4',
'EditSolid12': '\uF4B5',
'EditSolidMirrored12': '\uF4B6',
'UneditableSolid12': '\uF4B7',
'UneditableSolidMirrored12': '\uF4B8',
'UneditableMirrored': '\uF4B9',
'AdminALogo32': '\uF4BA',
'AdminALogoFill32': '\uF4BB',
'ToDoLogoInverse': '\uF4BC'
}
};
}
/***/ }),
/***/ 72205:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-14-5cf58db8.woff')
format('woff')"
},
icons: {
'Snooze': '\uF4BD',
'WaffleOffice365': '\uF4E0',
'ImageSearch': '\uF4E8',
'NewsSearch': '\uF4E9',
'VideoSearch': '\uF4EA',
'R': '\uF4EB',
'FontColorA': '\uF4EC',
'FontColorSwatch': '\uF4ED',
'LightWeight': '\uF4EE',
'NormalWeight': '\uF4EF',
'SemiboldWeight': '\uF4F0',
'GroupObject': '\uF4F1',
'UngroupObject': '\uF4F2',
'AlignHorizontalLeft': '\uF4F3',
'AlignHorizontalCenter': '\uF4F4',
'AlignHorizontalRight': '\uF4F5',
'AlignVerticalTop': '\uF4F6',
'AlignVerticalCenter': '\uF4F7',
'AlignVerticalBottom': '\uF4F8',
'HorizontalDistributeCenter': '\uF4F9',
'VerticalDistributeCenter': '\uF4FA',
'Ellipse': '\uF4FB',
'Line': '\uF4FC',
'Octagon': '\uF4FD',
'Hexagon': '\uF4FE',
'Pentagon': '\uF4FF',
'RightTriangle': '\uF500',
'HalfCircle': '\uF501',
'QuarterCircle': '\uF502',
'ThreeQuarterCircle': '\uF503',
'6PointStar': '\uF504',
'12PointStar': '\uF505',
'ArrangeBringToFront': '\uF506',
'ArrangeSendToBack': '\uF507',
'ArrangeSendBackward': '\uF508',
'ArrangeBringForward': '\uF509',
'BorderDash': '\uF50A',
'BorderDot': '\uF50B',
'LineStyle': '\uF50C',
'LineThickness': '\uF50D',
'WindowEdit': '\uF50E',
'HintText': '\uF50F',
'MediaAdd': '\uF510',
'AnchorLock': '\uF511',
'AutoHeight': '\uF512',
'ChartSeries': '\uF513',
'ChartXAngle': '\uF514',
'ChartYAngle': '\uF515',
'Combobox': '\uF516',
'LineSpacing': '\uF517',
'Padding': '\uF518',
'PaddingTop': '\uF519',
'PaddingBottom': '\uF51A',
'PaddingLeft': '\uF51B',
'PaddingRight': '\uF51C',
'NavigationFlipper': '\uF51D',
'AlignJustify': '\uF51E',
'TextOverflow': '\uF51F',
'VisualsFolder': '\uF520',
'VisualsStore': '\uF521',
'PictureCenter': '\uF522',
'PictureFill': '\uF523',
'PicturePosition': '\uF524',
'PictureStretch': '\uF525',
'PictureTile': '\uF526',
'Slider': '\uF527',
'SliderHandleSize': '\uF528',
'DefaultRatio': '\uF529',
'NumberSequence': '\uF52A',
'GUID': '\uF52B',
'ReportAdd': '\uF52C',
'DashboardAdd': '\uF52D',
'MapPinSolid': '\uF52E',
'WebPublish': '\uF52F',
'PieSingleSolid': '\uF530',
'BlockedSolid': '\uF531',
'DrillDown': '\uF532',
'DrillDownSolid': '\uF533',
'DrillExpand': '\uF534',
'DrillShow': '\uF535',
'SpecialEvent': '\uF536',
'OneDriveFolder16': '\uF53B',
'FunctionalManagerDashboard': '\uF542',
'BIDashboard': '\uF543',
'CodeEdit': '\uF544',
'RenewalCurrent': '\uF545',
'RenewalFuture': '\uF546',
'SplitObject': '\uF547',
'BulkUpload': '\uF548',
'DownloadDocument': '\uF549',
'GreetingCard': '\uF54B',
'Flower': '\uF54E',
'WaitlistConfirm': '\uF550',
'WaitlistConfirmMirrored': '\uF551',
'LaptopSecure': '\uF552',
'DragObject': '\uF553',
'EntryView': '\uF554',
'EntryDecline': '\uF555',
'ContactCardSettings': '\uF556',
'ContactCardSettingsMirrored': '\uF557'
}
};
}
/***/ }),
/***/ 84390:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-15-3807251b.woff')
format('woff')"
},
icons: {
'CalendarSettings': '\uF558',
'CalendarSettingsMirrored': '\uF559',
'HardDriveLock': '\uF55A',
'HardDriveUnlock': '\uF55B',
'AccountManagement': '\uF55C',
'ReportWarning': '\uF569',
'TransitionPop': '\uF5B2',
'TransitionPush': '\uF5B3',
'TransitionEffect': '\uF5B4',
'LookupEntities': '\uF5B5',
'ExploreData': '\uF5B6',
'AddBookmark': '\uF5B7',
'SearchBookmark': '\uF5B8',
'DrillThrough': '\uF5B9',
'MasterDatabase': '\uF5BA',
'CertifiedDatabase': '\uF5BB',
'MaximumValue': '\uF5BC',
'MinimumValue': '\uF5BD',
'VisualStudioIDELogo32': '\uF5D0',
'PasteAsText': '\uF5D5',
'PasteAsCode': '\uF5D6',
'BrowserTab': '\uF5D7',
'BrowserTabScreenshot': '\uF5D8',
'DesktopScreenshot': '\uF5D9',
'FileYML': '\uF5DA',
'ClipboardSolid': '\uF5DC',
'FabricUserFolder': '\uF5E5',
'FabricNetworkFolder': '\uF5E6',
'BullseyeTarget': '\uF5F0',
'AnalyticsView': '\uF5F1',
'Video360Generic': '\uF609',
'Untag': '\uF60B',
'Leave': '\uF627',
'Trending12': '\uF62D',
'Blocked12': '\uF62E',
'Warning12': '\uF62F',
'CheckedOutByOther12': '\uF630',
'CheckedOutByYou12': '\uF631',
'CircleShapeSolid': '\uF63C',
'SquareShapeSolid': '\uF63D',
'TriangleShapeSolid': '\uF63E',
'DropShapeSolid': '\uF63F',
'RectangleShapeSolid': '\uF640',
'ZoomToFit': '\uF649',
'InsertColumnsLeft': '\uF64A',
'InsertColumnsRight': '\uF64B',
'InsertRowsAbove': '\uF64C',
'InsertRowsBelow': '\uF64D',
'DeleteColumns': '\uF64E',
'DeleteRows': '\uF64F',
'DeleteRowsMirrored': '\uF650',
'DeleteTable': '\uF651',
'AccountBrowser': '\uF652',
'VersionControlPush': '\uF664',
'StackedColumnChart2': '\uF666',
'TripleColumnWide': '\uF66E',
'QuadColumn': '\uF66F',
'WhiteBoardApp16': '\uF673',
'WhiteBoardApp32': '\uF674',
'PinnedSolid': '\uF676',
'InsertSignatureLine': '\uF677',
'ArrangeByFrom': '\uF678',
'Phishing': '\uF679',
'CreateMailRule': '\uF67A',
'PublishCourse': '\uF699',
'DictionaryRemove': '\uF69A',
'UserRemove': '\uF69B',
'UserEvent': '\uF69C',
'Encryption': '\uF69D',
'PasswordField': '\uF6AA',
'OpenInNewTab': '\uF6AB',
'Hide3': '\uF6AC',
'VerifiedBrandSolid': '\uF6AD',
'MarkAsProtected': '\uF6AE',
'AuthenticatorApp': '\uF6B1',
'WebTemplate': '\uF6B2',
'DefenderTVM': '\uF6B3',
'MedalSolid': '\uF6B9',
'D365TalentLearn': '\uF6BB',
'D365TalentInsight': '\uF6BC',
'D365TalentHRCore': '\uF6BD',
'BacklogList': '\uF6BF',
'ButtonControl': '\uF6C0',
'TableGroup': '\uF6D9',
'MountainClimbing': '\uF6DB',
'TagUnknown': '\uF6DF',
'TagUnknownMirror': '\uF6E0',
'TagUnknown12': '\uF6E1',
'TagUnknown12Mirror': '\uF6E2',
'Link12': '\uF6E3',
'Presentation': '\uF6E4',
'Presentation12': '\uF6E5',
'Lock12': '\uF6E6',
'BuildDefinition': '\uF6E9',
'ReleaseDefinition': '\uF6EA',
'SaveTemplate': '\uF6EC',
'UserGauge': '\uF6ED',
'BlockedSiteSolid12': '\uF70A',
'TagSolid': '\uF70E',
'OfficeChat': '\uF70F'
}
};
}
/***/ }),
/***/ 7480:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-16-9cf93f3b.woff')
format('woff')"
},
icons: {
'OfficeChatSolid': '\uF710',
'MailSchedule': '\uF72E',
'WarningSolid': '\uF736',
'Blocked2Solid': '\uF737',
'SkypeCircleArrow': '\uF747',
'SkypeArrow': '\uF748',
'SyncStatus': '\uF751',
'SyncStatusSolid': '\uF752',
'ProjectDocument': '\uF759',
'ToDoLogoOutline': '\uF75B',
'VisioOnlineLogoFill32': '\uF75F',
'VisioOnlineLogo32': '\uF760',
'VisioOnlineLogoCloud32': '\uF761',
'VisioDiagramSync': '\uF762',
'Event12': '\uF763',
'EventDateMissed12': '\uF764',
'UserOptional': '\uF767',
'ResponsesMenu': '\uF768',
'DoubleDownArrow': '\uF769',
'DistributeDown': '\uF76A',
'BookmarkReport': '\uF76B',
'FilterSettings': '\uF76C',
'GripperDotsVertical': '\uF772',
'MailAttached': '\uF774',
'AddIn': '\uF775',
'LinkedDatabase': '\uF779',
'TableLink': '\uF77A',
'PromotedDatabase': '\uF77D',
'BarChartVerticalFilter': '\uF77E',
'BarChartVerticalFilterSolid': '\uF77F',
'MicOff2': '\uF781',
'MicrosoftTranslatorLogo': '\uF782',
'ShowTimeAs': '\uF787',
'FileRequest': '\uF789',
'WorkItemAlert': '\uF78F',
'PowerBILogo16': '\uF790',
'PowerBILogoBackplate16': '\uF791',
'BulletedListText': '\uF792',
'BulletedListBullet': '\uF793',
'BulletedListTextMirrored': '\uF794',
'BulletedListBulletMirrored': '\uF795',
'NumberedListText': '\uF796',
'NumberedListNumber': '\uF797',
'NumberedListTextMirrored': '\uF798',
'NumberedListNumberMirrored': '\uF799',
'RemoveLinkChain': '\uF79A',
'RemoveLinkX': '\uF79B',
'FabricTextHighlight': '\uF79C',
'ClearFormattingA': '\uF79D',
'ClearFormattingEraser': '\uF79E',
'Photo2Fill': '\uF79F',
'IncreaseIndentText': '\uF7A0',
'IncreaseIndentArrow': '\uF7A1',
'DecreaseIndentText': '\uF7A2',
'DecreaseIndentArrow': '\uF7A3',
'IncreaseIndentTextMirrored': '\uF7A4',
'IncreaseIndentArrowMirrored': '\uF7A5',
'DecreaseIndentTextMirrored': '\uF7A6',
'DecreaseIndentArrowMirrored': '\uF7A7',
'CheckListText': '\uF7A8',
'CheckListCheck': '\uF7A9',
'CheckListTextMirrored': '\uF7AA',
'CheckListCheckMirrored': '\uF7AB',
'NumberSymbol': '\uF7AC',
'Coupon': '\uF7BC',
'VerifiedBrand': '\uF7BD',
'ReleaseGate': '\uF7BE',
'ReleaseGateCheck': '\uF7BF',
'ReleaseGateError': '\uF7C0',
'M365InvoicingLogo': '\uF7C1',
'RemoveFromShoppingList': '\uF7D5',
'ShieldAlert': '\uF7D7',
'FabricTextHighlightComposite': '\uF7DA',
'Dataflows': '\uF7DD',
'GenericScanFilled': '\uF7DE',
'DiagnosticDataBarTooltip': '\uF7DF',
'SaveToMobile': '\uF7E0',
'Orientation2': '\uF7E1',
'ScreenCast': '\uF7E2',
'ShowGrid': '\uF7E3',
'SnapToGrid': '\uF7E4',
'ContactList': '\uF7E5',
'NewMail': '\uF7EA',
'EyeShadow': '\uF7EB',
'FabricFolderConfirm': '\uF7FF',
'InformationBarriers': '\uF803',
'CommentActive': '\uF804',
'ColumnVerticalSectionEdit': '\uF806',
'WavingHand': '\uF807',
'ShakeDevice': '\uF80A',
'SmartGlassRemote': '\uF80B',
'Rotate90Clockwise': '\uF80D',
'Rotate90CounterClockwise': '\uF80E',
'CampaignTemplate': '\uF811',
'ChartTemplate': '\uF812',
'PageListFilter': '\uF813',
'SecondaryNav': '\uF814',
'ColumnVerticalSection': '\uF81E',
'SkypeCircleSlash': '\uF825',
'SkypeSlash': '\uF826'
}
};
}
/***/ }),
/***/ 85882:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-17-0c4ed701.woff')
format('woff')"
},
icons: {
'CustomizeToolbar': '\uF828',
'DuplicateRow': '\uF82A',
'RemoveFromTrash': '\uF82B',
'MailOptions': '\uF82C',
'Childof': '\uF82D',
'Footer': '\uF82E',
'Header': '\uF82F',
'BarChartVerticalFill': '\uF830',
'StackedColumnChart2Fill': '\uF831',
'PlainText': '\uF834',
'AccessibiltyChecker': '\uF835',
'DatabaseSync': '\uF842',
'ReservationOrders': '\uF845',
'TabOneColumn': '\uF849',
'TabTwoColumn': '\uF84A',
'TabThreeColumn': '\uF84B',
'BulletedTreeList': '\uF84C',
'MicrosoftTranslatorLogoGreen': '\uF852',
'MicrosoftTranslatorLogoBlue': '\uF853',
'InternalInvestigation': '\uF854',
'AddReaction': '\uF85D',
'ContactHeart': '\uF862',
'VisuallyImpaired': '\uF866',
'EventToDoLogo': '\uF869',
'Variable2': '\uF86D',
'ModelingView': '\uF871',
'DisconnectVirtualMachine': '\uF873',
'ReportLock': '\uF875',
'Uneditable2': '\uF876',
'Uneditable2Mirrored': '\uF877',
'BarChartVerticalEdit': '\uF89D',
'GlobalNavButtonActive': '\uF89F',
'PollResults': '\uF8A0',
'Rerun': '\uF8A1',
'QandA': '\uF8A2',
'QandAMirror': '\uF8A3',
'BookAnswers': '\uF8A4',
'AlertSettings': '\uF8B6',
'TrimStart': '\uF8BB',
'TrimEnd': '\uF8BC',
'TableComputed': '\uF8F5',
'DecreaseIndentLegacy': '\uE290',
'IncreaseIndentLegacy': '\uE291',
'SizeLegacy': '\uE2B2'
}
};
}
/***/ }),
/***/ 18959:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-2-63c99abf.woff')
format('woff')"
},
icons: {
'Picture': '\uE8B9',
'ChromeClose': '\uE8BB',
'ShowResults': '\uE8BC',
'Message': '\uE8BD',
'CalendarDay': '\uE8BF',
'CalendarWeek': '\uE8C0',
'MailReplyAll': '\uE8C2',
'Read': '\uE8C3',
'Cut': '\uE8C6',
'PaymentCard': '\uE8C7',
'Copy': '\uE8C8',
'Important': '\uE8C9',
'MailReply': '\uE8CA',
'GotoToday': '\uE8D1',
'Font': '\uE8D2',
'FontColor': '\uE8D3',
'FolderFill': '\uE8D5',
'Permissions': '\uE8D7',
'DisableUpdates': '\uE8D8',
'Unfavorite': '\uE8D9',
'Italic': '\uE8DB',
'Underline': '\uE8DC',
'Bold': '\uE8DD',
'MoveToFolder': '\uE8DE',
'Dislike': '\uE8E0',
'Like': '\uE8E1',
'AlignCenter': '\uE8E3',
'OpenFile': '\uE8E5',
'ClearSelection': '\uE8E6',
'FontDecrease': '\uE8E7',
'FontIncrease': '\uE8E8',
'FontSize': '\uE8E9',
'CellPhone': '\uE8EA',
'RepeatOne': '\uE8ED',
'RepeatAll': '\uE8EE',
'Calculator': '\uE8EF',
'Library': '\uE8F1',
'PostUpdate': '\uE8F3',
'NewFolder': '\uE8F4',
'CalendarReply': '\uE8F5',
'UnsyncFolder': '\uE8F6',
'SyncFolder': '\uE8F7',
'BlockContact': '\uE8F8',
'Accept': '\uE8FB',
'BulletedList': '\uE8FD',
'Preview': '\uE8FF',
'News': '\uE900',
'Chat': '\uE901',
'Group': '\uE902',
'World': '\uE909',
'Comment': '\uE90A',
'DockLeft': '\uE90C',
'DockRight': '\uE90D',
'Repair': '\uE90F',
'Accounts': '\uE910',
'Street': '\uE913',
'RadioBullet': '\uE915',
'Stopwatch': '\uE916',
'Clock': '\uE917',
'WorldClock': '\uE918',
'AlarmClock': '\uE919',
'Photo': '\uE91B',
'ActionCenter': '\uE91C',
'Hospital': '\uE91D',
'Timer': '\uE91E',
'FullCircleMask': '\uE91F',
'LocationFill': '\uE920',
'ChromeMinimize': '\uE921',
'ChromeRestore': '\uE923',
'Annotation': '\uE924',
'Fingerprint': '\uE928',
'Handwriting': '\uE929',
'ChromeFullScreen': '\uE92D',
'Completed': '\uE930',
'Label': '\uE932',
'FlickDown': '\uE935',
'FlickUp': '\uE936',
'FlickLeft': '\uE937',
'FlickRight': '\uE938',
'MiniExpand': '\uE93A',
'MiniContract': '\uE93B',
'Streaming': '\uE93E',
'MusicInCollection': '\uE940',
'OneDriveLogo': '\uE941',
'CompassNW': '\uE942',
'Code': '\uE943',
'LightningBolt': '\uE945',
'CalculatorMultiply': '\uE947',
'CalculatorAddition': '\uE948',
'CalculatorSubtract': '\uE949',
'CalculatorPercentage': '\uE94C',
'CalculatorEqualTo': '\uE94E',
'PrintfaxPrinterFile': '\uE956',
'StorageOptical': '\uE958',
'Communications': '\uE95A',
'Headset': '\uE95B',
'Health': '\uE95E',
'Webcam2': '\uE960',
'FrontCamera': '\uE96B',
'ChevronUpSmall': '\uE96D'
}
};
}
/***/ }),
/***/ 62690:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-3-089e217a.woff')
format('woff')"
},
icons: {
'ChevronDownSmall': '\uE96E',
'ChevronLeftSmall': '\uE96F',
'ChevronRightSmall': '\uE970',
'ChevronUpMed': '\uE971',
'ChevronDownMed': '\uE972',
'ChevronLeftMed': '\uE973',
'ChevronRightMed': '\uE974',
'Devices2': '\uE975',
'PC1': '\uE977',
'PresenceChickletVideo': '\uE979',
'Reply': '\uE97A',
'HalfAlpha': '\uE97E',
'ConstructionCone': '\uE98F',
'DoubleChevronLeftMed': '\uE991',
'Volume0': '\uE992',
'Chart': '\uE999',
'Robot': '\uE99A',
'Manufacturing': '\uE99C',
'LockSolid': '\uE9A2',
'FitPage': '\uE9A6',
'FitWidth': '\uE9A7',
'BidiLtr': '\uE9AA',
'BidiRtl': '\uE9AB',
'RightDoubleQuote': '\uE9B1',
'Sunny': '\uE9BD',
'CloudWeather': '\uE9BE',
'Cloudy': '\uE9BF',
'PartlyCloudyDay': '\uE9C0',
'PartlyCloudyNight': '\uE9C1',
'ClearNight': '\uE9C2',
'RainShowersDay': '\uE9C3',
'Rain': '\uE9C4',
'Thunderstorms': '\uE9C6',
'RainSnow': '\uE9C7',
'Snow': '\uE9C8',
'BlowingSnow': '\uE9C9',
'Frigid': '\uE9CA',
'Fog': '\uE9CB',
'Squalls': '\uE9CC',
'Duststorm': '\uE9CD',
'Unknown': '\uE9CE',
'Precipitation': '\uE9CF',
'Ribbon': '\uE9D1',
'AreaChart': '\uE9D2',
'Assign': '\uE9D3',
'FlowChart': '\uE9D4',
'CheckList': '\uE9D5',
'Diagnostic': '\uE9D9',
'Generate': '\uE9DA',
'LineChart': '\uE9E6',
'Equalizer': '\uE9E9',
'BarChartHorizontal': '\uE9EB',
'BarChartVertical': '\uE9EC',
'Freezing': '\uE9EF',
'FunnelChart': '\uE9F1',
'Processing': '\uE9F5',
'Quantity': '\uE9F8',
'ReportDocument': '\uE9F9',
'StackColumnChart': '\uE9FC',
'SnowShowerDay': '\uE9FD',
'HailDay': '\uEA00',
'WorkFlow': '\uEA01',
'HourGlass': '\uEA03',
'StoreLogoMed20': '\uEA04',
'TimeSheet': '\uEA05',
'TriangleSolid': '\uEA08',
'UpgradeAnalysis': '\uEA0B',
'VideoSolid': '\uEA0C',
'RainShowersNight': '\uEA0F',
'SnowShowerNight': '\uEA11',
'Teamwork': '\uEA12',
'HailNight': '\uEA13',
'PeopleAdd': '\uEA15',
'Glasses': '\uEA16',
'DateTime2': '\uEA17',
'Shield': '\uEA18',
'Header1': '\uEA19',
'PageAdd': '\uEA1A',
'NumberedList': '\uEA1C',
'PowerBILogo': '\uEA1E',
'Info2': '\uEA1F',
'MusicInCollectionFill': '\uEA36',
'Asterisk': '\uEA38',
'ErrorBadge': '\uEA39',
'CircleFill': '\uEA3B',
'Record2': '\uEA3F',
'AllAppsMirrored': '\uEA40',
'BookmarksMirrored': '\uEA41',
'BulletedListMirrored': '\uEA42',
'CaretHollowMirrored': '\uEA45',
'CaretSolidMirrored': '\uEA46',
'ChromeBackMirrored': '\uEA47',
'ClearSelectionMirrored': '\uEA48',
'ClosePaneMirrored': '\uEA49',
'DockLeftMirrored': '\uEA4C',
'DoubleChevronLeftMedMirrored': '\uEA4D',
'GoMirrored': '\uEA4F'
}
};
}
/***/ }),
/***/ 52993:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-4-a656cc0a.woff')
format('woff')"
},
icons: {
'HelpMirrored': '\uEA51',
'ImportMirrored': '\uEA52',
'ImportAllMirrored': '\uEA53',
'ListMirrored': '\uEA55',
'MailForwardMirrored': '\uEA56',
'MailReplyMirrored': '\uEA57',
'MailReplyAllMirrored': '\uEA58',
'MiniContractMirrored': '\uEA59',
'MiniExpandMirrored': '\uEA5A',
'OpenPaneMirrored': '\uEA5B',
'ParkingLocationMirrored': '\uEA5E',
'SendMirrored': '\uEA63',
'ShowResultsMirrored': '\uEA65',
'ThumbnailViewMirrored': '\uEA67',
'Media': '\uEA69',
'Devices3': '\uEA6C',
'Focus': '\uEA6F',
'VideoLightOff': '\uEA74',
'Lightbulb': '\uEA80',
'StatusTriangle': '\uEA82',
'VolumeDisabled': '\uEA85',
'Puzzle': '\uEA86',
'EmojiNeutral': '\uEA87',
'EmojiDisappointed': '\uEA88',
'HomeSolid': '\uEA8A',
'Ringer': '\uEA8F',
'PDF': '\uEA90',
'HeartBroken': '\uEA92',
'StoreLogo16': '\uEA96',
'MultiSelectMirrored': '\uEA98',
'Broom': '\uEA99',
'AddToShoppingList': '\uEA9A',
'Cocktails': '\uEA9D',
'Wines': '\uEABF',
'Articles': '\uEAC1',
'Cycling': '\uEAC7',
'DietPlanNotebook': '\uEAC8',
'Pill': '\uEACB',
'ExerciseTracker': '\uEACC',
'HandsFree': '\uEAD0',
'Medical': '\uEAD4',
'Running': '\uEADA',
'Weights': '\uEADB',
'Trackers': '\uEADF',
'AddNotes': '\uEAE3',
'AllCurrency': '\uEAE4',
'BarChart4': '\uEAE7',
'CirclePlus': '\uEAEE',
'Coffee': '\uEAEF',
'Cotton': '\uEAF3',
'Market': '\uEAFC',
'Money': '\uEAFD',
'PieDouble': '\uEB04',
'PieSingle': '\uEB05',
'RemoveFilter': '\uEB08',
'Savings': '\uEB0B',
'Sell': '\uEB0C',
'StockDown': '\uEB0F',
'StockUp': '\uEB11',
'Lamp': '\uEB19',
'Source': '\uEB1B',
'MSNVideos': '\uEB1C',
'Cricket': '\uEB1E',
'Golf': '\uEB1F',
'Baseball': '\uEB20',
'Soccer': '\uEB21',
'MoreSports': '\uEB22',
'AutoRacing': '\uEB24',
'CollegeHoops': '\uEB25',
'CollegeFootball': '\uEB26',
'ProFootball': '\uEB27',
'ProHockey': '\uEB28',
'Rugby': '\uEB2D',
'SubstitutionsIn': '\uEB31',
'Tennis': '\uEB33',
'Arrivals': '\uEB34',
'Design': '\uEB3C',
'Website': '\uEB41',
'Drop': '\uEB42',
'HistoricalWeather': '\uEB43',
'SkiResorts': '\uEB45',
'Snowflake': '\uEB46',
'BusSolid': '\uEB47',
'FerrySolid': '\uEB48',
'AirplaneSolid': '\uEB4C',
'TrainSolid': '\uEB4D',
'Ticket': '\uEB54',
'WifiWarning4': '\uEB63',
'Devices4': '\uEB66',
'AzureLogo': '\uEB6A',
'BingLogo': '\uEB6B',
'MSNLogo': '\uEB6C',
'OutlookLogoInverse': '\uEB6D',
'OfficeLogo': '\uEB6E',
'SkypeLogo': '\uEB6F',
'Door': '\uEB75',
'EditMirrored': '\uEB7E',
'GiftCard': '\uEB8E',
'DoubleBookmark': '\uEB8F',
'StatusErrorFull': '\uEB90'
}
};
}
/***/ }),
/***/ 22682:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-5-f95ba260.woff')
format('woff')"
},
icons: {
'Certificate': '\uEB95',
'FastForward': '\uEB9D',
'Rewind': '\uEB9E',
'Photo2': '\uEB9F',
'OpenSource': '\uEBC2',
'Movers': '\uEBCD',
'CloudDownload': '\uEBD3',
'Family': '\uEBDA',
'WindDirection': '\uEBE6',
'Bug': '\uEBE8',
'SiteScan': '\uEBEC',
'BrowserScreenShot': '\uEBED',
'F12DevTools': '\uEBEE',
'CSS': '\uEBEF',
'JS': '\uEBF0',
'DeliveryTruck': '\uEBF4',
'ReminderPerson': '\uEBF7',
'ReminderGroup': '\uEBF8',
'ReminderTime': '\uEBF9',
'TabletMode': '\uEBFC',
'Umbrella': '\uEC04',
'NetworkTower': '\uEC05',
'CityNext': '\uEC06',
'CityNext2': '\uEC07',
'Section': '\uEC0C',
'OneNoteLogoInverse': '\uEC0D',
'ToggleFilled': '\uEC11',
'ToggleBorder': '\uEC12',
'SliderThumb': '\uEC13',
'ToggleThumb': '\uEC14',
'Documentation': '\uEC17',
'Badge': '\uEC1B',
'Giftbox': '\uEC1F',
'VisualStudioLogo': '\uEC22',
'HomeGroup': '\uEC26',
'ExcelLogoInverse': '\uEC28',
'WordLogoInverse': '\uEC29',
'PowerPointLogoInverse': '\uEC2A',
'Cafe': '\uEC32',
'SpeedHigh': '\uEC4A',
'Commitments': '\uEC4D',
'ThisPC': '\uEC4E',
'MusicNote': '\uEC4F',
'MicOff': '\uEC54',
'PlaybackRate1x': '\uEC57',
'EdgeLogo': '\uEC60',
'CompletedSolid': '\uEC61',
'AlbumRemove': '\uEC62',
'MessageFill': '\uEC70',
'TabletSelected': '\uEC74',
'MobileSelected': '\uEC75',
'LaptopSelected': '\uEC76',
'TVMonitorSelected': '\uEC77',
'DeveloperTools': '\uEC7A',
'Shapes': '\uEC7C',
'InsertTextBox': '\uEC7D',
'LowerBrightness': '\uEC8A',
'WebComponents': '\uEC8B',
'OfflineStorage': '\uEC8C',
'DOM': '\uEC8D',
'CloudUpload': '\uEC8E',
'ScrollUpDown': '\uEC8F',
'DateTime': '\uEC92',
'Event': '\uECA3',
'Cake': '\uECA4',
'Org': '\uECA6',
'PartyLeader': '\uECA7',
'DRM': '\uECA8',
'CloudAdd': '\uECA9',
'AppIconDefault': '\uECAA',
'Photo2Add': '\uECAB',
'Photo2Remove': '\uECAC',
'Calories': '\uECAD',
'POI': '\uECAF',
'AddTo': '\uECC8',
'RadioBtnOff': '\uECCA',
'RadioBtnOn': '\uECCB',
'ExploreContent': '\uECCD',
'Product': '\uECDC',
'ProgressLoopInner': '\uECDE',
'ProgressLoopOuter': '\uECDF',
'Blocked2': '\uECE4',
'FangBody': '\uECEB',
'Toolbox': '\uECED',
'PageHeader': '\uECEE',
'ChatInviteFriend': '\uECFE',
'Brush': '\uECFF',
'Shirt': '\uED00',
'Crown': '\uED01',
'Diamond': '\uED02',
'ScaleUp': '\uED09',
'QRCode': '\uED14',
'Feedback': '\uED15',
'SharepointLogoInverse': '\uED18',
'YammerLogo': '\uED19',
'Hide': '\uED1A',
'Uneditable': '\uED1D',
'ReturnToSession': '\uED24',
'OpenFolderHorizontal': '\uED25',
'CalendarMirrored': '\uED28'
}
};
}
/***/ }),
/***/ 81328:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-6-ef6fd590.woff')
format('woff')"
},
icons: {
'SwayLogoInverse': '\uED29',
'OutOfOffice': '\uED34',
'Trophy': '\uED3F',
'ReopenPages': '\uED50',
'EmojiTabSymbols': '\uED58',
'AADLogo': '\uED68',
'AccessLogo': '\uED69',
'AdminALogoInverse32': '\uED6A',
'AdminCLogoInverse32': '\uED6B',
'AdminDLogoInverse32': '\uED6C',
'AdminELogoInverse32': '\uED6D',
'AdminLLogoInverse32': '\uED6E',
'AdminMLogoInverse32': '\uED6F',
'AdminOLogoInverse32': '\uED70',
'AdminPLogoInverse32': '\uED71',
'AdminSLogoInverse32': '\uED72',
'AdminYLogoInverse32': '\uED73',
'DelveLogoInverse': '\uED76',
'ExchangeLogoInverse': '\uED78',
'LyncLogo': '\uED79',
'OfficeVideoLogoInverse': '\uED7A',
'SocialListeningLogo': '\uED7C',
'VisioLogoInverse': '\uED7D',
'Balloons': '\uED7E',
'Cat': '\uED7F',
'MailAlert': '\uED80',
'MailCheck': '\uED81',
'MailLowImportance': '\uED82',
'MailPause': '\uED83',
'MailRepeat': '\uED84',
'SecurityGroup': '\uED85',
'Table': '\uED86',
'VoicemailForward': '\uED87',
'VoicemailReply': '\uED88',
'Waffle': '\uED89',
'RemoveEvent': '\uED8A',
'EventInfo': '\uED8B',
'ForwardEvent': '\uED8C',
'WipePhone': '\uED8D',
'AddOnlineMeeting': '\uED8E',
'JoinOnlineMeeting': '\uED8F',
'RemoveLink': '\uED90',
'PeopleBlock': '\uED91',
'PeopleRepeat': '\uED92',
'PeopleAlert': '\uED93',
'PeoplePause': '\uED94',
'TransferCall': '\uED95',
'AddPhone': '\uED96',
'UnknownCall': '\uED97',
'NoteReply': '\uED98',
'NoteForward': '\uED99',
'NotePinned': '\uED9A',
'RemoveOccurrence': '\uED9B',
'Timeline': '\uED9C',
'EditNote': '\uED9D',
'CircleHalfFull': '\uED9E',
'Room': '\uED9F',
'Unsubscribe': '\uEDA0',
'Subscribe': '\uEDA1',
'HardDrive': '\uEDA2',
'RecurringTask': '\uEDB2',
'TaskManager': '\uEDB7',
'TaskManagerMirrored': '\uEDB8',
'Combine': '\uEDBB',
'Split': '\uEDBC',
'DoubleChevronUp': '\uEDBD',
'DoubleChevronLeft': '\uEDBE',
'DoubleChevronRight': '\uEDBF',
'TextBox': '\uEDC2',
'TextField': '\uEDC3',
'NumberField': '\uEDC4',
'Dropdown': '\uEDC5',
'PenWorkspace': '\uEDC6',
'BookingsLogo': '\uEDC7',
'ClassNotebookLogoInverse': '\uEDC8',
'DelveAnalyticsLogo': '\uEDCA',
'DocsLogoInverse': '\uEDCB',
'Dynamics365Logo': '\uEDCC',
'DynamicSMBLogo': '\uEDCD',
'OfficeAssistantLogo': '\uEDCE',
'OfficeStoreLogo': '\uEDCF',
'OneNoteEduLogoInverse': '\uEDD0',
'PlannerLogo': '\uEDD1',
'PowerApps': '\uEDD2',
'Suitcase': '\uEDD3',
'ProjectLogoInverse': '\uEDD4',
'CaretLeft8': '\uEDD5',
'CaretRight8': '\uEDD6',
'CaretUp8': '\uEDD7',
'CaretDown8': '\uEDD8',
'CaretLeftSolid8': '\uEDD9',
'CaretRightSolid8': '\uEDDA',
'CaretUpSolid8': '\uEDDB',
'CaretDownSolid8': '\uEDDC',
'ClearFormatting': '\uEDDD',
'Superscript': '\uEDDE',
'Subscript': '\uEDDF',
'Strikethrough': '\uEDE0',
'Export': '\uEDE1',
'ExportMirrored': '\uEDE2'
}
};
}
/***/ }),
/***/ 11824:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-7-2b97bb99.woff')
format('woff')"
},
icons: {
'SingleBookmark': '\uEDFF',
'SingleBookmarkSolid': '\uEE00',
'DoubleChevronDown': '\uEE04',
'FollowUser': '\uEE05',
'ReplyAll': '\uEE0A',
'WorkforceManagement': '\uEE0F',
'RecruitmentManagement': '\uEE12',
'Questionnaire': '\uEE19',
'ManagerSelfService': '\uEE23',
'ProductionFloorManagement': '\uEE29',
'ProductRelease': '\uEE2E',
'ProductVariant': '\uEE30',
'ReplyMirrored': '\uEE35',
'ReplyAllMirrored': '\uEE36',
'Medal': '\uEE38',
'AddGroup': '\uEE3D',
'QuestionnaireMirrored': '\uEE4B',
'CloudImportExport': '\uEE55',
'TemporaryUser': '\uEE58',
'CaretSolid16': '\uEE62',
'GroupedDescending': '\uEE66',
'GroupedAscending': '\uEE67',
'AwayStatus': '\uEE6A',
'MyMoviesTV': '\uEE6C',
'GenericScan': '\uEE6F',
'AustralianRules': '\uEE70',
'WifiEthernet': '\uEE77',
'TrackersMirrored': '\uEE92',
'DateTimeMirrored': '\uEE93',
'StopSolid': '\uEE95',
'DoubleChevronUp12': '\uEE96',
'DoubleChevronDown12': '\uEE97',
'DoubleChevronLeft12': '\uEE98',
'DoubleChevronRight12': '\uEE99',
'CalendarAgenda': '\uEE9A',
'ConnectVirtualMachine': '\uEE9D',
'AddEvent': '\uEEB5',
'AssetLibrary': '\uEEB6',
'DataConnectionLibrary': '\uEEB7',
'DocLibrary': '\uEEB8',
'FormLibrary': '\uEEB9',
'FormLibraryMirrored': '\uEEBA',
'ReportLibrary': '\uEEBB',
'ReportLibraryMirrored': '\uEEBC',
'ContactCard': '\uEEBD',
'CustomList': '\uEEBE',
'CustomListMirrored': '\uEEBF',
'IssueTracking': '\uEEC0',
'IssueTrackingMirrored': '\uEEC1',
'PictureLibrary': '\uEEC2',
'OfficeAddinsLogo': '\uEEC7',
'OfflineOneDriveParachute': '\uEEC8',
'OfflineOneDriveParachuteDisabled': '\uEEC9',
'TriangleSolidUp12': '\uEECC',
'TriangleSolidDown12': '\uEECD',
'TriangleSolidLeft12': '\uEECE',
'TriangleSolidRight12': '\uEECF',
'TriangleUp12': '\uEED0',
'TriangleDown12': '\uEED1',
'TriangleLeft12': '\uEED2',
'TriangleRight12': '\uEED3',
'ArrowUpRight8': '\uEED4',
'ArrowDownRight8': '\uEED5',
'DocumentSet': '\uEED6',
'GoToDashboard': '\uEEED',
'DelveAnalytics': '\uEEEE',
'ArrowUpRightMirrored8': '\uEEEF',
'ArrowDownRightMirrored8': '\uEEF0',
'CompanyDirectory': '\uEF0D',
'OpenEnrollment': '\uEF1C',
'CompanyDirectoryMirrored': '\uEF2B',
'OneDriveAdd': '\uEF32',
'ProfileSearch': '\uEF35',
'Header2': '\uEF36',
'RingerSolid': '\uEF3A',
'Eyedropper': '\uEF3C',
'MarketDown': '\uEF42',
'CalendarWorkWeek': '\uEF51',
'SidePanel': '\uEF52',
'GlobeFavorite': '\uEF53',
'CaretTopLeftSolid8': '\uEF54',
'CaretTopRightSolid8': '\uEF55',
'ViewAll2': '\uEF56',
'DocumentReply': '\uEF57',
'PlayerSettings': '\uEF58',
'ReceiptForward': '\uEF59',
'ReceiptReply': '\uEF5A',
'ReceiptCheck': '\uEF5B',
'Fax': '\uEF5C',
'RecurringEvent': '\uEF5D',
'ReplyAlt': '\uEF5E',
'ReplyAllAlt': '\uEF5F',
'EditStyle': '\uEF60',
'EditMail': '\uEF61',
'Lifesaver': '\uEF62',
'LifesaverLock': '\uEF63',
'InboxCheck': '\uEF64',
'FolderSearch': '\uEF65'
}
};
}
/***/ }),
/***/ 4270:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-8-6fdf1528.woff')
format('woff')"
},
icons: {
'CollapseMenu': '\uEF66',
'ExpandMenu': '\uEF67',
'Boards': '\uEF68',
'SunAdd': '\uEF69',
'SunQuestionMark': '\uEF6A',
'LandscapeOrientation': '\uEF6B',
'DocumentSearch': '\uEF6C',
'PublicCalendar': '\uEF6D',
'PublicContactCard': '\uEF6E',
'PublicEmail': '\uEF6F',
'PublicFolder': '\uEF70',
'WordDocument': '\uEF71',
'PowerPointDocument': '\uEF72',
'ExcelDocument': '\uEF73',
'GroupedList': '\uEF74',
'ClassroomLogo': '\uEF75',
'Sections': '\uEF76',
'EditPhoto': '\uEF77',
'Starburst': '\uEF78',
'ShareiOS': '\uEF79',
'AirTickets': '\uEF7A',
'PencilReply': '\uEF7B',
'Tiles2': '\uEF7C',
'SkypeCircleCheck': '\uEF7D',
'SkypeCircleClock': '\uEF7E',
'SkypeCircleMinus': '\uEF7F',
'SkypeMessage': '\uEF83',
'ClosedCaption': '\uEF84',
'ATPLogo': '\uEF85',
'OfficeFormsLogoInverse': '\uEF86',
'RecycleBin': '\uEF87',
'EmptyRecycleBin': '\uEF88',
'Hide2': '\uEF89',
'Breadcrumb': '\uEF8C',
'BirthdayCake': '\uEF8D',
'TimeEntry': '\uEF95',
'CRMProcesses': '\uEFB1',
'PageEdit': '\uEFB6',
'PageArrowRight': '\uEFB8',
'PageRemove': '\uEFBA',
'Database': '\uEFC7',
'DataManagementSettings': '\uEFC8',
'CRMServices': '\uEFD2',
'EditContact': '\uEFD3',
'ConnectContacts': '\uEFD4',
'AppIconDefaultAdd': '\uEFDA',
'AppIconDefaultList': '\uEFDE',
'ActivateOrders': '\uEFE0',
'DeactivateOrders': '\uEFE1',
'ProductCatalog': '\uEFE8',
'ScatterChart': '\uEFEB',
'AccountActivity': '\uEFF4',
'DocumentManagement': '\uEFFC',
'CRMReport': '\uEFFE',
'KnowledgeArticle': '\uF000',
'Relationship': '\uF003',
'HomeVerify': '\uF00E',
'ZipFolder': '\uF012',
'SurveyQuestions': '\uF01B',
'TextDocument': '\uF029',
'TextDocumentShared': '\uF02B',
'PageCheckedOut': '\uF02C',
'PageShared': '\uF02D',
'SaveAndClose': '\uF038',
'Script': '\uF03A',
'Archive': '\uF03F',
'ActivityFeed': '\uF056',
'Compare': '\uF057',
'EventDate': '\uF059',
'ArrowUpRight': '\uF069',
'CaretRight': '\uF06B',
'SetAction': '\uF071',
'ChatBot': '\uF08B',
'CaretSolidLeft': '\uF08D',
'CaretSolidDown': '\uF08E',
'CaretSolidRight': '\uF08F',
'CaretSolidUp': '\uF090',
'PowerAppsLogo': '\uF091',
'PowerApps2Logo': '\uF092',
'SearchIssue': '\uF09A',
'SearchIssueMirrored': '\uF09B',
'FabricAssetLibrary': '\uF09C',
'FabricDataConnectionLibrary': '\uF09D',
'FabricDocLibrary': '\uF09E',
'FabricFormLibrary': '\uF09F',
'FabricFormLibraryMirrored': '\uF0A0',
'FabricReportLibrary': '\uF0A1',
'FabricReportLibraryMirrored': '\uF0A2',
'FabricPublicFolder': '\uF0A3',
'FabricFolderSearch': '\uF0A4',
'FabricMovetoFolder': '\uF0A5',
'FabricUnsyncFolder': '\uF0A6',
'FabricSyncFolder': '\uF0A7',
'FabricOpenFolderHorizontal': '\uF0A8',
'FabricFolder': '\uF0A9',
'FabricFolderFill': '\uF0AA',
'FabricNewFolder': '\uF0AB',
'FabricPictureLibrary': '\uF0AC',
'PhotoVideoMedia': '\uF0B1',
'AddFavorite': '\uF0C8'
}
};
}
/***/ }),
/***/ 22770:
"use strict";
var subset = {
style: {
speak: 'none'
},
fontFace: {
src: "url('" + baseUrl + "fabric-icons-9-c6162b42.woff')
format('woff')"
},
icons: {
'AddFavoriteFill': '\uF0C9',
'BufferTimeBefore': '\uF0CF',
'BufferTimeAfter': '\uF0D0',
'BufferTimeBoth': '\uF0D1',
'PublishContent': '\uF0D4',
'ClipboardList': '\uF0E3',
'ClipboardListMirrored': '\uF0E4',
'CannedChat': '\uF0F2',
'SkypeForBusinessLogo': '\uF0FC',
'TabCenter': '\uF100',
'PageCheckedin': '\uF104',
'PageList': '\uF106',
'ReadOutLoud': '\uF112',
'CaretBottomLeftSolid8': '\uF121',
'CaretBottomRightSolid8': '\uF122',
'FolderHorizontal': '\uF12B',
'MicrosoftStaffhubLogo': '\uF130',
'GiftboxOpen': '\uF133',
'StatusCircleOuter': '\uF136',
'StatusCircleInner': '\uF137',
'StatusCircleRing': '\uF138',
'StatusTriangleOuter': '\uF139',
'StatusTriangleInner': '\uF13A',
'StatusTriangleExclamation': '\uF13B',
'StatusCircleExclamation': '\uF13C',
'StatusCircleErrorX': '\uF13D',
'StatusCircleInfo': '\uF13F',
'StatusCircleBlock': '\uF140',
'StatusCircleBlock2': '\uF141',
'StatusCircleQuestionMark': '\uF142',
'StatusCircleSync': '\uF143',
'Toll': '\uF160',
'ExploreContentSingle': '\uF164',
'CollapseContent': '\uF165',
'CollapseContentSingle': '\uF166',
'InfoSolid': '\uF167',
'GroupList': '\uF168',
'ProgressRingDots': '\uF16A',
'CaloriesAdd': '\uF172',
'BranchFork': '\uF173',
'MuteChat': '\uF17A',
'AddHome': '\uF17B',
'AddWork': '\uF17C',
'MobileReport': '\uF18A',
'ScaleVolume': '\uF18C',
'HardDriveGroup': '\uF18F',
'FastMode': '\uF19A',
'ToggleLeft': '\uF19E',
'ToggleRight': '\uF19F',
'TriangleShape': '\uF1A7',
'RectangleShape': '\uF1A9',
'CubeShape': '\uF1AA',
'Trophy2': '\uF1AE',
'BucketColor': '\uF1B6',
'BucketColorFill': '\uF1B7',
'Taskboard': '\uF1C2',
'SingleColumn': '\uF1D3',
'DoubleColumn': '\uF1D4',
'TripleColumn': '\uF1D5',
'ColumnLeftTwoThirds': '\uF1D6',
'ColumnRightTwoThirds': '\uF1D7',
'AccessLogoFill': '\uF1DB',
'AnalyticsLogo': '\uF1DE',
'AnalyticsQuery': '\uF1DF',
'NewAnalyticsQuery': '\uF1E0',
'AnalyticsReport': '\uF1E1',
'WordLogo': '\uF1E3',
'WordLogoFill': '\uF1E4',
'ExcelLogo': '\uF1E5',
'ExcelLogoFill': '\uF1E6',
'OneNoteLogo': '\uF1E7',
'OneNoteLogoFill': '\uF1E8',
'OutlookLogo': '\uF1E9',
'OutlookLogoFill': '\uF1EA',
'PowerPointLogo': '\uF1EB',
'PowerPointLogoFill': '\uF1EC',
'PublisherLogo': '\uF1ED',
'PublisherLogoFill': '\uF1EE',
'ScheduleEventAction': '\uF1EF',
'FlameSolid': '\uF1F3',
'ServerProcesses': '\uF1FE',
'Server': '\uF201',
'SaveAll': '\uF203',
'LinkedInLogo': '\uF20A',
'Decimals': '\uF218',
'SidePanelMirrored': '\uF221',
'ProtectRestrict': '\uF22A',
'Blog': '\uF22B',
'UnknownMirrored': '\uF22E',
'PublicContactCardMirrored': '\uF230',
'GridViewSmall': '\uF232',
'GridViewMedium': '\uF233',
'GridViewLarge': '\uF234',
'Step': '\uF241',
'StepInsert': '\uF242',
'StepShared': '\uF243',
'StepSharedAdd': '\uF244',
'StepSharedInsert': '\uF245',
'ViewDashboard': '\uF246',
'ViewList': '\uF247'
}
};
}
/***/ }),
/***/ 11336:
"use strict";
var subset = {
style: {
speak: 'none',
},
fontFace: {
fontFamily: "\"FabricMDL2Icons\"",
src: "url('" + baseUrl + "fabric-icons-a13498cf.woff') format('woff')",
},
icons: {
GlobalNavButton: '\uE700',
ChevronDown: '\uE70D',
ChevronUp: '\uE70E',
Edit: '\uE70F',
Add: '\uE710',
Cancel: '\uE711',
More: '\uE712',
Settings: '\uE713',
Mail: '\uE715',
Filter: '\uE71C',
Search: '\uE721',
Share: '\uE72D',
BlockedSite: '\uE72F',
FavoriteStar: '\uE734',
FavoriteStarFill: '\uE735',
CheckMark: '\uE73E',
Delete: '\uE74D',
ChevronLeft: '\uE76B',
ChevronRight: '\uE76C',
Calendar: '\uE787',
Megaphone: '\uE789',
Undo: '\uE7A7',
Flag: '\uE7C1',
Page: '\uE7C3',
Pinned: '\uE840',
View: '\uE890',
Clear: '\uE894',
Download: '\uE896',
Upload: '\uE898',
Folder: '\uE8B7',
Sort: '\uE8CB',
AlignRight: '\uE8E2',
AlignLeft: '\uE8E4',
Tag: '\uE8EC',
AddFriend: '\uE8FA',
Info: '\uE946',
SortLines: '\uE9D0',
List: '\uEA37',
CircleRing: '\uEA3A',
Heart: '\uEB51',
HeartFill: '\uEB52',
Tiles: '\uECA5',
Embed: '\uECCE',
Glimmer: '\uECF4',
Ascending: '\uEDC0',
Descending: '\uEDC1',
SortUp: '\uEE68',
SortDown: '\uEE69',
SyncToPC: '\uEE6E',
LargeGrid: '\uEECB',
SkypeCheck: '\uEF80',
SkypeClock: '\uEF81',
SkypeMinus: '\uEF82',
ClearFilter: '\uEF8F',
Flow: '\uEF90',
StatusCircleCheckmark: '\uF13E',
MoreVertical: '\uF2BC',
},
};
}
//# sourceMappingURL=fabric-icons.js.map
/***/ }),
/***/ 70205:
"use strict";
exports.registerIconAliases = void 0;
var registerIconAliases = function () {
style_utilities_1.registerIconAlias('trash', 'delete');
style_utilities_1.registerIconAlias('onedrive', 'onedrivelogo');
style_utilities_1.registerIconAlias('alertsolid12', 'eventdatemissed12');
style_utilities_1.registerIconAlias('sixpointstar', '6pointstar');
style_utilities_1.registerIconAlias('twelvepointstar', '12pointstar');
style_utilities_1.registerIconAlias('toggleon', 'toggleleft');
style_utilities_1.registerIconAlias('toggleoff', 'toggleright');
};
exports.registerIconAliases = registerIconAliases;
exports["default"] = exports.registerIconAliases;
//# sourceMappingURL=iconAliases.js.map
/***/ }),
/***/ 10106:
"use strict";

var fabric_icons_1 = __webpack_require__(11336);
var fabric_icons_0_1 = __webpack_require__(1032);
var iconAliases_1 = __webpack_require__(70205);
var utilities_1 = __webpack_require__(10254);
var DEFAULT_BASE_URL = 'https://spoppe-b.azureedge.net/files/fabric-cdn-
prod_20210407.001/assets/icons/';
var win = utilities_1.getWindow();
var _a, _b;
if (baseUrl === void 0) { baseUrl = ((_a = win === null || win === void 0 ?
void 0 : win.FabricConfig) === null || _a === void 0 ? void 0 : _a.iconBaseUrl) ||
((_b = win === null || win === void 0 ? void 0 : win.FabricConfig) === null || _b
=== void 0 ? void 0 : _b.fontBaseUrl) || DEFAULT_BASE_URL; }
[
fabric_icons_1.initializeIcons,
fabric_icons_0_1.initializeIcons,
].forEach(function (initialize) { return initialize(baseUrl, options); });
iconAliases_1.registerIconAliases();
}
/***/ }),
/***/ 79314:
"use strict";

set_version_1.setVersion('@fluentui/font-icons-mdl2', '8.4.1');
/***/ }),
/***/ 38772:
"use strict";

//# sourceMappingURL=IComponent.js.map
/***/ }),
/***/ 42841:
"use strict";

//# sourceMappingURL=IHTMLSlots.js.map
/***/ }),
/***/ 68400:
"use strict";

//# sourceMappingURL=ISlots.js.map
/***/ }),
/***/ 14689:
"use strict";

exports.ThemeProvider = void 0;
var React = __webpack_require__(67294);
/**
* Theme provider is a simplified version of Customizer that activates the
appropriate theme data
* for a given scheme name.
*
* @param providers - Injected providers for accessing theme data and providing it
via a Customizer component.
* @deprecated This is an old ThemeProvider implementation. New code should use the
ThemeProvider exported from
* `@fluentui/react` (or `@fluentui/react/lib/Theme`) instead.
*/
var ThemeProvider = function (props) {
var scheme = props.scheme, theme = props.theme, rest = tslib_1.__rest(props,
["scheme", "theme"]);
// TODO: consider merging implementation with theme-proto, which only stores a
reference / scheme name to theme
// in context and uses quick global store accessor to trigger change by
passing in theme object as child and
// triggering re-render. (perf benefits need verification)
var contextTransform = function (context) {
return style_utilities_1.getThemedContext(context, scheme, theme);
};
// eslint-disable-next-line react/jsx-no-bind, deprecation/deprecation
return React.createElement(utilities_1.Customizer, tslib_1.__assign({}, rest, {
contextTransform: contextTransform }));
};
exports.ThemeProvider = ThemeProvider;
//# sourceMappingURL=ThemeProvider.js.map
/***/ }),
/***/ 93496:
"use strict";

exports.createComponent = void 0;
var slots_1 = __webpack_require__(44548);
/**
* Assembles a higher order component based on the following: styles, theme, view,
and state.
* Imposes a separation of concern and centralizes styling processing to increase
ease of use and robustness
* in how components use and apply styling and theming.
*
* Automatically merges and applies themes and styles with theme / styleprops
having the highest priority.
* State component, if provided, is passed in props for processing. Props from
state / user are automatically processed
* and styled before finally being passed to view.
*
* State components should contain all stateful behavior and should not generate
any JSX, but rather simply call
* the view prop.
*
* Views should simply be stateless pure functions that receive all props needed
for rendering their output.
*
* State component is optional. If state is not provided, created component is
essentially a functional
* stateless component.
*
* @param options - component Component options. See IComponentOptions for more
detail.
*/
function createComponent(view, options) {
if (options === void 0) { options = {}; }
var _a = options.factoryOptions, factoryOptions = _a === void 0 ? {} : _a;
var defaultProp = factoryOptions.defaultProp;
var ResultComponent = function (componentProps) {
var settings = _getCustomizations(options.displayName,
React.useContext(utilities_1.CustomizerContext), options.fields);
var stateReducer = options.state;
if (stateReducer) {
// Don't assume state will return all props, so spread useState result
over component props.
componentProps = tslib_1.__assign(tslib_1.__assign({}, componentProps),
stateReducer(componentProps));
}
var theme = componentProps.theme || settings.theme;
var tokens = _resolveTokens(componentProps, theme, options.tokens,
settings.tokens, componentProps.tokens);
var styles = _resolveStyles(componentProps, theme, tokens, options.styles,
settings.styles, componentProps.styles);
var viewProps = tslib_1.__assign(tslib_1.__assign({}, componentProps),
{ styles: styles, tokens: tokens, _defaultStyles: styles, theme: theme });
return view(viewProps);
};
ResultComponent.displayName = options.displayName || view.name;
// If a shorthand prop is defined, create a factory for the component.
// TODO: This shouldn't be a concern of createComponent.. factoryOptions should
just be forwarded.
// Need to weigh creating default factories on component creation vs.
memoizing them on use in slots.tsx.
if (defaultProp) {
ResultComponent.create = slots_1.createFactory(ResultComponent,
{ defaultProp: defaultProp });
}
utilities_2.assign(ResultComponent, options.statics);
// Later versions of TypeSript should allow us to merge objects in a type safe
way and avoid this cast.
return ResultComponent;
}
exports.createComponent = createComponent;
/**
* Resolve all styles functions with both props and tokens and flatten results
along with all styles objects.
*/
function _resolveStyles(props, theme, tokens) {
var allStyles = [];
for (var _i = 3; _i < arguments.length; _i++) {
allStyles[_i - 3] = arguments[_i];
}
return style_utilities_1.concatStyleSets.apply(void 0, allStyles.map(function
(styles) {
return typeof styles === 'function' ? styles(props, theme, tokens) :
styles;
}));
}
/**
* Resolve all tokens functions with props flatten results along with all tokens
objects.
*/
function _resolveTokens(props, theme) {
var allTokens = [];
allTokens[_i - 2] = arguments[_i];
}
var tokens = {};
for (var _a = 0, allTokens_1 = allTokens; _a < allTokens_1.length; _a++) {
var currentTokens = allTokens_1[_a];
if (currentTokens) {
// TODO: why is this cast needed? TS seems to think there is a (TToken
| Function) union from somewhere.
currentTokens =
typeof currentTokens === 'function'
? currentTokens(props, theme)
: currentTokens;
if (Array.isArray(currentTokens)) {
currentTokens = _resolveTokens.apply(void 0,
tslib_1.__spreadArray([props, theme], currentTokens));
}
utilities_2.assign(tokens, currentTokens);
}
}
return tokens;
}
/**
* Helper function for calling Customizations.getSettings falling back to default
fields.
*
* @param displayName Displayable name for component.
* @param context React context passed to component containing contextual settings.
* @param fields Optional list of properties to grab from global store and context.
*/
function _getCustomizations(displayName, context, fields) {
// TODO: do we want field props? should fields be part of IComponent and used
here?
// TODO: should we centrally define DefaultFields? (not exported from styling)
// TODO: tie this array to ICustomizationProps, such that each array element is
keyof ICustomizationProps
var DefaultFields = ['theme', 'styles', 'tokens'];
return utilities_1.Customizations.getSettings(fields || DefaultFields,
displayName, context.customizations);
}
//# sourceMappingURL=createComponent.js.map
/***/ }),
/***/ 65422:
"use strict";

exports.getControlledDerivedProps = exports.useControlledState = void 0;
/**
* Controlled state helper that gives priority to props value. Useful for
components that have props with both
* controlled and uncontrolled modes. Any props values will override state, but
will not update internal state.
* If prop is defined and then later undefined, state will revert to its previous
value.
*
* @param props - The props object containing controlled prop values.
* @param propName - The controlled prop name.
* @param options - Options. defaultPropValue is only used if defaultPropName (or
its value) is undefined.
*/
function useControlledState(props, propName, options) {
var defaultValue;
if (options) {
if (options.defaultPropName && props[options.defaultPropName] !==
undefined) {
// No easy way to coerce TProps[TDefaultProp] to match TProps[TProp] in
generic typings, so cast it here.
defaultValue = props[options.defaultPropName];
}
else {
defaultValue = options && options.defaultPropValue;
}
}
var _a = React.useState(defaultValue), state = _a[0], setState = _a[1];
if (props[propName] !== undefined) {
return [props[propName], setState];
}
else {
return [state, setState];
}
}
exports.useControlledState = useControlledState;
/**
* Simple controlled helper that gives priority to props value and falls back to
derived value.
*
* @param props - The props object containing controlled prop values.
* @param propName - The controlled prop name.
* @param derivedValue - Derived value. Returned when controlled value is not
present.
*/
function getControlledDerivedProps(props, propName, derivedValue) {
if (props[propName] !== undefined) {
return props[propName];
}
else {
return derivedValue;
}
}
exports.getControlledDerivedProps = getControlledDerivedProps;
//# sourceMappingURL=controlled.js.map
/***/ }),
/***/ 76882:
"use strict";

/***/ }),
/***/ 3188:
"use strict";

exports.legacyStyled = void 0;
Object.defineProperty(exports, "legacyStyled", ({ enumerable: true, get: function
() { return utilities_1.styled; } }));
/***/ }),
/***/ 44548:
"use strict";

exports.getSlots = exports.createFactory = exports.withSlots = void 0;
var merge_styles_1 = __webpack_require__(28376);
/**
* This function is required for any module that uses slots.
*
* This function is a slot resolver that automatically evaluates slot functions to
generate React elements.
* A byproduct of this resolver is that it removes slots from the React hierarchy
by bypassing React.createElement.
*
* To use this function on a per-file basis, use the jsx directive targeting
withSlots.
* This directive must be the FIRST LINE in the file to work correctly.
* Usage of this pragma also requires withSlots import statement.
*
* See React.createElement
*/
// Can't use typeof on React.createElement since it's overloaded. Approximate
createElement's signature for now
// and widen as needed.
function withSlots(type, props) {
var children = [];
children[_i - 2] = arguments[_i];
}
var slotType = type;
if (slotType.isSlot) {
// Since we are bypassing createElement, use React.Children.toArray to make
sure children are
// properly assigned keys.
// TODO: should this be mutating? does React mutate children subprop with
createElement?
// TODO: will toArray clobber existing keys?
// TODO: React generates warnings because it doesn't detect hidden member
_store that is set in createElement.
// Even children passed to createElement without keys don't generate
this warning.
// Is there a better way to prevent slots from appearing in
hierarchy? toArray doesn't address root issue.
children = React.Children.toArray(children);
// TODO: There is something weird going on here with children embedded in
props vs. rest args.
// Comment out these lines to see. Make sure this function is doing the
right things.
if (children.length === 0) {
return slotType(props);
}
return slotType(tslib_1.__assign(tslib_1.__assign({}, props), { children:
children }));
}
else {
// TODO: Are there some cases where children should NOT be spread? Also,
spreading reraises perf question.
// Children had to be spread to avoid breaking KeytipData in
Toggle.view:
// react-dom.development.js:18931 Uncaught TypeError: children is
not a function
// Without spread, function child is a child array of one element
// TODO: is there a reason this can't be:
// return React.createElement.apply(this, arguments);
return React.createElement.apply(React, tslib_1.__spreadArray([type,
props], children));
}
}
exports.withSlots = withSlots;
/**
* This function creates factories that render ouput depending on the user
ISlotProp props passed in.
* @param DefaultComponent - Base component to render when not overridden by user
props.
* @param options - Factory options, including defaultProp value for shorthand prop
mapping.
* @returns ISlotFactory function used for rendering slots.
*/
function createFactory(DefaultComponent, options) {
var _a = options.defaultProp, defaultProp = _a === void 0 ? 'children' : _a;
var result = function (componentProps, userProps, userSlotOptions,
defaultStyles, theme) {
// If they passed in raw JSX, just return that.
if (React.isValidElement(userProps)) {
return userProps;
}
var flattenedUserProps = _translateShorthand(defaultProp, userProps);
var finalProps = _constructFinalProps(defaultStyles, theme, componentProps,
flattenedUserProps);
if (userSlotOptions) {
if (userSlotOptions.component) {
// TODO: Remove cast if possible. This cast is needed because TS
errors on the intrinsic portion of ReactType.
// return <userSlotOptions.component {...finalProps} />;
var UserComponent = userSlotOptions.component;
return React.createElement(UserComponent, tslib_1.__assign({},
finalProps));
}
if (userSlotOptions.render) {
return userSlotOptions.render(finalProps, DefaultComponent);
}
}
return React.createElement(DefaultComponent, tslib_1.__assign({},
finalProps));
};
return result;
}
exports.createFactory = createFactory;
/**
* Default factory for components without explicit factories.
*/
var defaultFactory = utilities_1.memoizeFunction(function (type) { return
createFactory(type); });
/**
* This function generates slots that can be used in JSX given a definition of
slots and their corresponding types.
* @param userProps - Props as pass to component.
* @param slots - Slot definition object defining the default slot component for
each slot.
* @returns A set of created slots that components can render in JSX.
*/
function getSlots(userProps, slots) {
var result = {};
// userProps already has default props mixed in by createComponent. Recast here
to gain typing for this function.
var mixedProps = userProps;
var _loop_1 = function (name_1) {
if (slots.hasOwnProperty(name_1)) {
// This closure method requires the use of withSlots to prevent
unnecessary rerenders. This is because React
// detects each closure as a different component (since it is a new
instance) from the previous one and then
// forces a rerender of the entire slot subtree. For now, the only way
to avoid this is to use withSlots, which
// bypasses the call to React.createElement.
var slot = function (componentProps) {
var args = [];
args[_i - 1] = arguments[_i];
}
if (args.length > 0) {
// If React.createElement is being incorrectly used with slots,
there will be additional arguments.
// We can detect these additional arguments and error on their
presence.
throw new Error('Any module using getSlots must use withSlots.
Please see withSlots javadoc for more info.');
}
// TODO: having TS infer types here seems to cause infinite loop.
// use explicit types or casting to preserve typing if possible.
// TODO: this should be a lookup on TProps property instead of
being TProps directly, which is probably
// causing the infinite loop
return _renderSlot(slots[name_1],
// TODO: this cast to any is hiding a relationship issue between
the first two args
componentProps, mixedProps[name_1], mixedProps.slots &&
mixedProps.slots[name_1],
// _defaultStyles should always be present, but a check for
existence is added to make view tests
// easier to use.
mixedProps._defaultStyles && mixedProps._defaultStyles[name_1],
mixedProps.theme);
};
slot.isSlot = true;
result[name_1] = slot;
}
};
for (var name_1 in slots) {
_loop_1(name_1);
}
return result;
}
exports.getSlots = getSlots;
/**
* Helper function that translates shorthand as needed.
* @param defaultProp
* @param slotProps
*/
function _translateShorthand(defaultProp, slotProps) {
var _a;
var transformedProps;
if (typeof slotProps === 'string' || typeof slotProps === 'number' || typeof
slotProps === 'boolean') {
transformedProps = (_a = {},
_a[defaultProp] = slotProps,
_a);
}
else {
transformedProps = slotProps;
}
return transformedProps;
}
/**
* Helper function that constructs final styles and props given a series of props
ordered by increasing priority.
*/
function _constructFinalProps(defaultStyles, theme) {
var allProps = [];
allProps[_i - 2] = arguments[_i];
}
var finalProps = {};
var classNames = [];
for (var _a = 0, allProps_1 = allProps; _a < allProps_1.length; _a++) {
var props = allProps_1[_a];
classNames.push(props && props.className);
utilities_2.assign(finalProps, props);
}
finalProps.className = merge_styles_1.mergeCss([defaultStyles, classNames],
{ rtl: utilities_1.getRTL(theme) });
return finalProps;
}
/**
* Render a slot given component and user props. Uses component factory if
available, otherwise falls back
* to default factory.
* @param ComponentType Factory component type.
* @param componentProps The properties passed into slot from within the component.
* @param userProps The user properties passed in from outside of the component.
*/
function _renderSlot(ComponentType, componentProps, userProps, slotOptions,
defaultStyles, theme) {
if (ComponentType.create !== undefined) {
return ComponentType.create(componentProps, userProps, slotOptions,
defaultStyles);
}
else {
// TODO: need to resolve typing / generic issues passing through
memoizeFunction. for now, cast to 'unknown'
return defaultFactory(ComponentType)(componentProps, userProps,
slotOptions, defaultStyles, theme);
}
}
//# sourceMappingURL=slots.js.map
/***/ }),
/***/ 27134:
"use strict";

exports.assign = void 0;
exports.assign = tslib_1.__assign;
//# sourceMappingURL=utilities.js.map
/***/ }),
/***/ 24207:
"use strict";

set_version_1.setVersion('@fluentui/foundation-legacy', '8.2.8');
/***/ }),
/***/ 49402:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 45675:
"use strict";

exports.getStyleOptions = exports.getRTL = exports.setRTL = void 0;
/**
* Sets the current RTL value.
*/
function setRTL(isRTL) {
if (_rtl !== isRTL) {
_rtl = isRTL;
}
}
exports.setRTL = setRTL;
/**
* Gets the current RTL value.
*/
function getRTL() {
if (_rtl === undefined) {
_rtl =
typeof document !== 'undefined' &&
!!document.documentElement &&
document.documentElement.getAttribute('dir') === 'rtl';
}
return _rtl;
}
exports.getRTL = getRTL;
// This has been split into 2 lines because it was working in Fabric due to the
code being transpiled to es5, so this
// was converted to var while not working in Fluent that uses babel to transpile
the code to be es6-like. Splitting the
// logic into two lines, however, allows it to work in both scenarios.
var _rtl;
_rtl = getRTL();
function getStyleOptions() {
return {
rtl: getRTL(),
};
}
exports.getStyleOptions = getStyleOptions;
//# sourceMappingURL=StyleOptionsState.js.map
/***/ }),
/***/ 60203:
"use strict";

exports.Stylesheet = exports.InjectionMode = void 0;
exports.InjectionMode = {
/**
* Avoids style injection, use getRules() to read the styles.
*/
none: 0,
/**
* Inserts rules using the insertRule api.
*/
insertNode: 1,
/**
* Appends rules using appendChild.
*/
appendChild: 2,
};
var STYLESHEET_SETTING = '__stylesheet__';
/**
* MSIE 11 doesn't cascade styles based on DOM ordering, but rather on the order
that each style node
* is created. As such, to maintain consistent priority, IE11 should reuse a single
style node.
*/
var REUSE_STYLE_NODE = typeof navigator !== 'undefined' &&
/rv:11.0/.test(navigator.userAgent);
var _global = {};
// Grab window.
try {
_global = window || {};
}
catch (_a) {
/* leave as blank object */
}
var _stylesheet;
/**
* Represents the state of styles registered in the page. Abstracts
* the surface for adding styles to the stylesheet, exposes helpers
* for reading the styles registered in server rendered scenarios.
*
* @public
*/
var Stylesheet = /** @class */ (function () {
function Stylesheet(config, serializedStylesheet) {
var _a, _b, _c, _d, _e, _f;
this._rules = [];
this._preservedRules = [];
this._counter = 0;
this._keyToClassName = {};
this._onInsertRuleCallbacks = [];
this._onResetCallbacks = [];
this._classNameToArgs = {};
this._config = tslib_1.__assign({
// If there is no document we won't have an element to inject into.
injectionMode: typeof document === 'undefined' ?
exports.InjectionMode.none : exports.InjectionMode.insertNode, defaultPrefix:
'css', namespace: undefined, cspSettings: undefined }, config);
this._classNameToArgs = (_a = serializedStylesheet === null ||
serializedStylesheet === void 0 ? void 0 : serializedStylesheet.classNameToArgs) !
== null && _a !== void 0 ? _a : this._classNameToArgs;
this._counter = (_b = serializedStylesheet === null || serializedStylesheet
=== void 0 ? void 0 : serializedStylesheet.counter) !== null && _b !== void 0 ?
_b : this._counter;
this._keyToClassName = (_d = (_c = this._config.classNameCache) !== null &&
_c !== void 0 ? _c : serializedStylesheet === null || serializedStylesheet === void
0 ? void 0 : serializedStylesheet.keyToClassName) !== null && _d !== void 0 ? _d :
this._keyToClassName;
this._preservedRules = (_e = serializedStylesheet === null ||
serializedStylesheet === void 0 ? void 0 : serializedStylesheet.preservedRules) !==
null && _e !== void 0 ? _e : this._preservedRules;
this._rules = (_f = serializedStylesheet === null || serializedStylesheet
=== void 0 ? void 0 : serializedStylesheet.rules) !== null && _f !== void 0 ? _f :
this._rules;
}
/**
* Gets the singleton instance.
*/
Stylesheet.getInstance = function () {
_stylesheet = _global[STYLESHEET_SETTING];
if (!_stylesheet || (_stylesheet._lastStyleElement &&
_stylesheet._lastStyleElement.ownerDocument !== document)) {
var fabricConfig = (_global === null || _global === void 0 ? void 0 :
_global.FabricConfig) || {};
var stylesheet = new Stylesheet(fabricConfig.mergeStyles,
fabricConfig.serializedStylesheet);
_stylesheet = stylesheet;
_global[STYLESHEET_SETTING] = stylesheet;
}
return _stylesheet;
};
/**
* Serializes the Stylesheet instance into a format which allows rehydration on
creation.
* @returns string representation of ÌSerializedStylesheet` interface.
*/
Stylesheet.prototype.serialize = function () {
return JSON.stringify({
classNameToArgs: this._classNameToArgs,
counter: this._counter,
keyToClassName: this._keyToClassName,
preservedRules: this._preservedRules,
rules: this._rules,
});
};
/**
* Configures the stylesheet.
*/
Stylesheet.prototype.setConfig = function (config) {
this._config = tslib_1.__assign(tslib_1.__assign({}, this._config),
config);
};
/**
* Configures a reset callback.
*
* @param callback - A callback which will be called when the Stylesheet is
reset.
* @returns function which when called un-registers provided callback.
*/
Stylesheet.prototype.onReset = function (callback) {
var _this = this;
this._onResetCallbacks.push(callback);
return function () {
_this._onResetCallbacks = _this._onResetCallbacks.filter(function (cb)
{ return cb !== callback; });
};
};
/**
* Configures an insert rule callback.
*
* @param callback - A callback which will be called when a rule is inserted.
* @returns function which when called un-registers provided callback.
*/
Stylesheet.prototype.onInsertRule = function (callback) {
var _this = this;
this._onInsertRuleCallbacks.push(callback);
_this._onInsertRuleCallbacks =
_this._onInsertRuleCallbacks.filter(function (cb) { return cb !== callback; });
};
};
/**
* Generates a unique classname.
*
* @param displayName - Optional value to use as a prefix.
*/
Stylesheet.prototype.getClassName = function (displayName) {
var namespace = this._config.namespace;
var prefix = displayName || this._config.defaultPrefix;
return "" + (namespace ? namespace + '-' : '') + prefix + "-" +
this._counter++;
};
/**
* Used internally to cache information about a class which was
* registered with the stylesheet.
*/
Stylesheet.prototype.cacheClassName = function (className, key, args, rules) {
this._keyToClassName[key] = className;
this._classNameToArgs[className] = {
args: args,
rules: rules,
};
};
/**
* Gets the appropriate classname given a key which was previously
* registered using cacheClassName.
*/
Stylesheet.prototype.classNameFromKey = function (key) {
return this._keyToClassName[key];
};
/**
* Gets all classnames cache with the stylesheet.
*/
Stylesheet.prototype.getClassNameCache = function () {
return this._keyToClassName;
};
/**
* Gets the arguments associated with a given classname which was
* previously registered using cacheClassName.
*/
Stylesheet.prototype.argsFromClassName = function (className) {
var entry = this._classNameToArgs[className];
return entry && entry.args;
};
/**
* Gets the rules associated with a given classname which was
* previously registered using cacheClassName.
*/
Stylesheet.prototype.insertedRulesFromClassName = function (className) {
var entry = this._classNameToArgs[className];
return entry && entry.rules;
};
/**
* Inserts a css rule into the stylesheet.
* @param preserve - Preserves the rule beyond a reset boundary.
*/
Stylesheet.prototype.insertRule = function (rule, preserve) {
var injectionMode = this._config.injectionMode;
var element = injectionMode !== exports.InjectionMode.none ?
this._getStyleElement() : undefined;
if (preserve) {
this._preservedRules.push(rule);
}
if (element) {
switch (injectionMode) {
case exports.InjectionMode.insertNode:
var sheet = element.sheet;
try {
sheet.insertRule(rule, sheet.cssRules.length);
}
catch (e) {
// The browser will throw exceptions on unsupported rules
(such as a moz prefix in webkit.)
// We need to swallow the exceptions for this scenario,
otherwise we'd need to filter
// which could be slower and bulkier.
}
break;
case exports.InjectionMode.appendChild:
element.appendChild(document.createTextNode(rule));
break;
}
}
else {
this._rules.push(rule);
}
// eslint-disable-next-line deprecation/deprecation
if (this._config.onInsertRule) {
this._config.onInsertRule(rule);
}
this._onInsertRuleCallbacks.forEach(function (callback) { return
callback(); });
};
/**
* Gets all rules registered with the stylesheet; only valid when
* using InsertionMode.none.
*/
Stylesheet.prototype.getRules = function (includePreservedRules) {
return (includePreservedRules ? this._preservedRules.join('') : '') +
this._rules.join('');
};
/**
* Resets the internal state of the stylesheet. Only used in server
* rendered scenarios where we're using InsertionMode.none.
*/
Stylesheet.prototype.reset = function () {
this._rules = [];
this._counter = 0;
this._classNameToArgs = {};
this._onResetCallbacks.forEach(function (callback) { return callback(); });
};
// Forces the regeneration of incoming styles without totally resetting the
stylesheet.
Stylesheet.prototype.resetKeys = function () {
};
Stylesheet.prototype._getStyleElement = function () {
var _this = this;
if (!this._styleElement && typeof document !== 'undefined') {
this._styleElement = this._createStyleElement();
if (!REUSE_STYLE_NODE) {
// Reset the style element on the next frame.
window.requestAnimationFrame(function () {
_this._styleElement = undefined;
});
}
}
return this._styleElement;
};
Stylesheet.prototype._createStyleElement = function () {
var head = document.head;
var styleElement = document.createElement('style');
var nodeToInsertBefore = null;
styleElement.setAttribute('data-merge-styles', 'true');
var cspSettings = this._config.cspSettings;
if (cspSettings) {
if (cspSettings.nonce) {
styleElement.setAttribute('nonce', cspSettings.nonce);
}
}
if (this._lastStyleElement) {
// If the `nextElementSibling` is null, then the insertBefore will act
as a regular append.
//
https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore#Syntax
nodeToInsertBefore = this._lastStyleElement.nextElementSibling;
}
else {
var placeholderStyleTag = this._findPlaceholderStyleTag();
if (placeholderStyleTag) {
nodeToInsertBefore = placeholderStyleTag.nextElementSibling;
}
else {
nodeToInsertBefore = head.childNodes[0];
}
}
head.insertBefore(styleElement, head.contains(nodeToInsertBefore) ?
nodeToInsertBefore : null);
this._lastStyleElement = styleElement;
return styleElement;
};
Stylesheet.prototype._findPlaceholderStyleTag = function () {
var head = document.head;
if (head) {
return head.querySelector('style[data-merge-styles]');
}
return null;
};
return Stylesheet;
}());
exports.Stylesheet = Stylesheet;
//# sourceMappingURL=Stylesheet.js.map
/***/ }),
/***/ 84444:
"use strict";

exports.concatStyleSets = void 0;
/**
* Combine a set of styles together (but does not register css classes).
* @param styleSets - One or more stylesets to be merged (each param can also be
falsy).
*/
function concatStyleSets() {
var styleSets = [];
styleSets[_i] = arguments[_i];
}
if (styleSets && styleSets.length === 1 && styleSets[0] && !
styleSets[0].subComponentStyles) {
return styleSets[0];
}
var mergedSet = {};
// We process sub component styles in two phases. First we collect them, then
we combine them into 1 style function.
var workingSubcomponentStyles = {};
for (var _a = 0, styleSets_1 = styleSets; _a < styleSets_1.length; _a++) {
var currentSet = styleSets_1[_a];
if (currentSet) {
for (var prop in currentSet) {
if (currentSet.hasOwnProperty(prop)) {
if (prop === 'subComponentStyles' &&
currentSet.subComponentStyles !== undefined) {
// subcomponent styles - style functions or objects
var currentComponentStyles = currentSet.subComponentStyles;
for (var subCompProp in currentComponentStyles) {
if (currentComponentStyles.hasOwnProperty(subCompProp))
{
if
(workingSubcomponentStyles.hasOwnProperty(subCompProp)) {
workingSubcomponentStyles[subCompProp].push(currentComponentStyles[subCompProp]);
}
else {
workingSubcomponentStyles[subCompProp] =
[currentComponentStyles[subCompProp]];
}
}
}
continue;
}
// the as any casts below is a workaround for ts 2.8.
// todo: remove cast to any in ts 2.9.
var mergedValue = mergedSet[prop];
var currentValue = currentSet[prop];
if (mergedValue === undefined) {
mergedSet[prop] = currentValue;
}
else {
mergedSet[prop] =
tslib_1.__spreadArray(tslib_1.__spreadArray([], (Array.isArray(mergedValue) ?
mergedValue : [mergedValue])), (Array.isArray(currentValue) ? currentValue :
[currentValue]));
}
}
}
}
}
if (Object.keys(workingSubcomponentStyles).length > 0) {
mergedSet.subComponentStyles = {};
var mergedSubStyles = mergedSet.subComponentStyles;
var _loop_1 = function (subCompProp) {
if (workingSubcomponentStyles.hasOwnProperty(subCompProp)) {
var workingSet_1 = workingSubcomponentStyles[subCompProp];
mergedSubStyles[subCompProp] = function (styleProps) {
return concatStyleSets.apply(void 0, workingSet_1.map(function
(styleFunctionOrObject) {
return typeof styleFunctionOrObject === 'function' ?
styleFunctionOrObject(styleProps) : styleFunctionOrObject;
}));
};
}
};
// now we process the subcomponent styles if there are any
for (var subCompProp in workingSubcomponentStyles) {
_loop_1(subCompProp);
}
}
return mergedSet;
}
exports.concatStyleSets = concatStyleSets;
//# sourceMappingURL=concatStyleSets.js.map
/***/ }),
/***/ 36900:
"use strict";

exports.concatStyleSetsWithProps = void 0;
var concatStyleSets_1 = __webpack_require__(84444);
/**
* Concatenates style sets into one, but resolves functional sets using the given
props.
* @param styleProps - Props used to resolve functional sets.
* @param allStyles - Style sets, which can be functions or objects.
*/
function concatStyleSetsWithProps(styleProps) {
var allStyles = [];
allStyles[_i - 1] = arguments[_i];
}
var result = [];
for (var _a = 0, allStyles_1 = allStyles; _a < allStyles_1.length; _a++) {
var styles = allStyles_1[_a];
if (styles) {
result.push(typeof styles === 'function' ? styles(styleProps) :
styles);
}
}
if (result.length === 1) {
return result[0];
}
else if (result.length) {
// cliffkoh: I cannot figure out how to avoid the cast to any here.
// It is something to do with the use of Omit in IStyleSet.
// It might not be necessary once Omit becomes part of lib.d.ts (when we
remove our own Omit and rely on
// the official version).
return concatStyleSets_1.concatStyleSets.apply(void 0, result);
}
return {};
}
exports.concatStyleSetsWithProps = concatStyleSetsWithProps;
//# sourceMappingURL=concatStyleSetsWithProps.js.map
/***/ }),
/***/ 79734:
"use strict";

exports.extractStyleParts = void 0;
var Stylesheet_1 = __webpack_require__(60203);
/**
* Separates the classes and style objects. Any classes that are pre-registered
* args are auto expanded into objects.
*/
function extractStyleParts() {
var args = [];
args[_i] = arguments[_i];
}
var classes = [];
var objects = [];
var stylesheet = Stylesheet_1.Stylesheet.getInstance();
function _processArgs(argsList) {
for (var _i = 0, argsList_1 = argsList; _i < argsList_1.length; _i++) {
var arg = argsList_1[_i];
if (arg) {
if (typeof arg === 'string') {
if (arg.indexOf(' ') >= 0) {
_processArgs(arg.split(' '));
}
else {
var translatedArgs = stylesheet.argsFromClassName(arg);
if (translatedArgs) {
_processArgs(translatedArgs);
}
else {
// Avoid adding the same class twice.
if (classes.indexOf(arg) === -1) {
classes.push(arg);
}
}
}
}
else if (Array.isArray(arg)) {
_processArgs(arg);
}
else if (typeof arg === 'object') {
objects.push(arg);
}
}
}
}
_processArgs(args);
return {
classes: classes,
objects: objects,
};
}
exports.extractStyleParts = extractStyleParts;
//# sourceMappingURL=extractStyleParts.js.map
/***/ }),
/***/ 61976:
"use strict";

exports.fontFace = void 0;
var StyleOptionsState_1 = __webpack_require__(45675);
var styleToClassName_1 = __webpack_require__(4748);
/**
* Registers a font face.
* @public
*/
function fontFace(font) {
var rule =
styleToClassName_1.serializeRuleEntries(StyleOptionsState_1.getStyleOptions(),
font);
var className = stylesheet.classNameFromKey(rule);
if (className) {
return;
}
var name = stylesheet.getClassName();
stylesheet.insertRule("@font-face{" + rule + "}", true);
stylesheet.cacheClassName(name, rule, [], ['font-face', rule]);
}
exports.fontFace = fontFace;
//# sourceMappingURL=fontFace.js.map
/***/ }),
/***/ 75591:
"use strict";

exports.setVendorSettings = exports.getVendorSettings = void 0;
var _vendorSettings;
function getVendorSettings() {
var _a;
if (!_vendorSettings) {
var doc = typeof document !== 'undefined' ? document : undefined;
var nav = typeof navigator !== 'undefined' ? navigator : undefined;
var userAgent = (_a = nav === null || nav === void 0 ? void 0 :
nav.userAgent) === null || _a === void 0 ? void 0 : _a.toLowerCase();
if (!doc) {
_vendorSettings = {
isWebkit: true,
isMoz: true,
isOpera: true,
isMs: true,
};
}
else {
_vendorSettings = {
isWebkit: !!(doc && 'WebkitAppearance' in
doc.documentElement.style),
isMoz: !!(userAgent && userAgent.indexOf('firefox') > -1),
isOpera: !!(userAgent && userAgent.indexOf('opera') > -1),
isMs: !!(nav && (/rv:11.0/i.test(nav.userAgent) ||
/Edge\/\d./i.test(navigator.userAgent))),
};
}
}
return _vendorSettings;
}
exports.getVendorSettings = getVendorSettings;
/**
* Sets the vendor settings for prefixing and vendor specific operations.
*/
function setVendorSettings(vendorSettings) {
_vendorSettings = vendorSettings;
}
exports.setVendorSettings = setVendorSettings;
//# sourceMappingURL=getVendorSettings.js.map
/***/ }),
/***/ 28376:
"use strict";

exports.setRTL = exports.keyframes = exports.fontFace =
exports.concatStyleSetsWithProps = exports.concatStyleSets = exports.mergeCssSets =
exports.mergeStyleSets = exports.mergeCss = exports.mergeStyles = void 0;
var mergeStyles_1 = __webpack_require__(66459);
Object.defineProperty(exports, "mergeStyles", ({ enumerable: true, get: function ()
{ return mergeStyles_1.mergeStyles; } }));
Object.defineProperty(exports, "mergeCss", ({ enumerable: true, get: function ()
{ return mergeStyles_1.mergeCss; } }));
var mergeStyleSets_1 = __webpack_require__(96528);
Object.defineProperty(exports, "mergeStyleSets", ({ enumerable: true, get: function
() { return mergeStyleSets_1.mergeStyleSets; } }));
Object.defineProperty(exports, "mergeCssSets", ({ enumerable: true, get: function
() { return mergeStyleSets_1.mergeCssSets; } }));
Object.defineProperty(exports, "concatStyleSets", ({ enumerable: true, get:
function () { return concatStyleSets_1.concatStyleSets; } }));
var concatStyleSetsWithProps_1 = __webpack_require__(36900);
Object.defineProperty(exports, "concatStyleSetsWithProps", ({ enumerable: true,
get: function () { return
concatStyleSetsWithProps_1.concatStyleSetsWithProps; } }));
var fontFace_1 = __webpack_require__(61976);
Object.defineProperty(exports, "fontFace", ({ enumerable: true, get: function ()
{ return fontFace_1.fontFace; } }));
var keyframes_1 = __webpack_require__(64249);
Object.defineProperty(exports, "keyframes", ({ enumerable: true, get: function () {
return keyframes_1.keyframes; } }));
Object.defineProperty(exports, "setRTL", ({ enumerable: true, get: function ()
{ return StyleOptionsState_1.setRTL; } }));
/***/ }),
/***/ 64249:
"use strict";

exports.keyframes = void 0;
/**
* Registers keyframe definitions.
*
* @public
*/
function keyframes(timeline) {
var rulesArray = [];
for (var prop in timeline) {
if (timeline.hasOwnProperty(prop)) {
rulesArray.push(prop, '{',
styleToClassName_1.serializeRuleEntries(StyleOptionsState_1.getStyleOptions(),
timeline[prop]), '}');
}
}
var rules = rulesArray.join('');
var className = stylesheet.classNameFromKey(rules);
if (className) {
return className;
}
var name = stylesheet.getClassName();
stylesheet.insertRule("@keyframes " + name + "{" + rules + "}", true);
stylesheet.cacheClassName(name, rules, [], ['keyframes', rules]);
return name;
}
exports.keyframes = keyframes;
//# sourceMappingURL=keyframes.js.map
/***/ }),
/***/ 96528:
"use strict";

exports.mergeCssSets = exports.mergeStyleSets = void 0;
var extractStyleParts_1 = __webpack_require__(79734);
/**
* Takes in one or more style set objects, each consisting of a set of areas,
* each which will produce a class name. Using this is analogous to calling
* `mergeStyles` for each property in the object, but ensures we maintain the
* set ordering when multiple style sets are merged.
*
* @param styleSets - One or more style sets to be merged.
*/
function mergeStyleSets() {
var styleSets = [];
styleSets[_i] = arguments[_i];
}
return mergeCssSets(styleSets, StyleOptionsState_1.getStyleOptions());
}
exports.mergeStyleSets = mergeStyleSets;
/**
* Takes in one or more style set objects, each1consisting of a set of areas,
* each which will produce a class name. Using this is analogous to calling
* `mergeCss` for each property in the object, but ensures the
* set ordering when multiple style sets are merged.
*
* @param styleSets - One or more style sets to be merged.
* @param options - (optional) Options to use when creating rules.
*/
function mergeCssSets(styleSets, options) {
var classNameSet = { subComponentStyles: {} };
var styleSet = styleSets[0];
if (!styleSet && styleSets.length <= 1) {
return { subComponentStyles: {} };
}
var concatenatedStyleSet = concatStyleSets_1.concatStyleSets.apply(void 0,
styleSets);
var registrations = [];
for (var styleSetArea in concatenatedStyleSet) {
if (concatenatedStyleSet.hasOwnProperty(styleSetArea)) {
if (styleSetArea === 'subComponentStyles') {
classNameSet.subComponentStyles =
concatenatedStyleSet.subComponentStyles || {};
continue;
}
var styles = concatenatedStyleSet[styleSetArea];
var _a = extractStyleParts_1.extractStyleParts(styles), classes =
_a.classes, objects = _a.objects;
if (objects === null || objects === void 0 ? void 0 : objects.length) {
var registration = styleToClassName_1.styleToRegistration(options
|| {}, { displayName: styleSetArea }, objects);
if (registration) {
registrations.push(registration);
classNameSet[styleSetArea] =
classes.concat([registration.className]).join(' ');
}
}
else {
classNameSet[styleSetArea] = classes.join(' ');
}
}
}
for (var _i = 0, registrations_1 = registrations; _i < registrations_1.length;
_i++) {
var registration = registrations_1[_i];
if (registration) {
styleToClassName_1.applyRegistration(registration, options === null ||
options === void 0 ? void 0 : options.specificityMultiplier);
}
}
return classNameSet;
}
exports.mergeCssSets = mergeCssSets;
//# sourceMappingURL=mergeStyleSets.js.map
/***/ }),
/***/ 66459:
"use strict";

exports.mergeCss = exports.mergeStyles = void 0;
var extractStyleParts_1 = __webpack_require__(79734);
/**
* Concatenation helper, which can merge class names together. Skips over falsey
values.
*
* @public
*/
function mergeStyles() {
var args = [];
}
return mergeCss(args, StyleOptionsState_1.getStyleOptions());
}
exports.mergeStyles = mergeStyles;
/**
* Concatenation helper, which can merge class names together. Skips over falsey
values.
* Accepts a set of options that will be used when calculating styles.
*
* @public
*/
function mergeCss(args, options) {
var styleArgs = args instanceof Array ? args : [args];
var _a = extractStyleParts_1.extractStyleParts(styleArgs), classes =
_a.classes, objects = _a.objects;
if (objects.length) {
classes.push(styleToClassName_1.styleToClassName(options || {}, objects));
}
return classes.join(' ');
}
exports.mergeCss = mergeCss;
//# sourceMappingURL=mergeStyles.js.map
/***/ }),
/***/ 4748:
"use strict";

exports.styleToClassName = exports.applyRegistration = exports.styleToRegistration
= exports.serializeRuleEntries = void 0;
var kebabRules_1 = __webpack_require__(50299);
var prefixRules_1 = __webpack_require__(28077);
var provideUnits_1 = __webpack_require__(76906);
var rtlifyRules_1 = __webpack_require__(26908);
var tokenizeWithParentheses_1 = __webpack_require__(54853);
var DISPLAY_NAME = 'displayName';
function getDisplayName(rules) {
var rootStyle = rules && rules['&'];
return rootStyle ? rootStyle.displayName : undefined;
}
var globalSelectorRegExp = /\:global$(.+?)$/g;
/**
* Finds comma separated selectors in a :global() e.g.
":global(.class1, .class2, .class3)"
* and wraps them each in their own global
":global(.class1), :global(.class2), :global(.class3)"
*
* @param selectorWithGlobals The selector to process
* @returns The updated selector
*/
function expandCommaSeparatedGlobals(selectorWithGlobals) {
// We the selector does not have a :global() we can shortcut
if (!globalSelectorRegExp.test(selectorWithGlobals)) {
return selectorWithGlobals;
}
var replacementInfo = [];
var findGlobal = /\:global$(.+?)$/g;
var match = null;
// Create a result list for global selectors so we can replace them.
while ((match = findGlobal.exec(selectorWithGlobals))) {
// Only if the found selector is a comma separated list we'll process it.
if (match[1].indexOf(',') > -1) {
replacementInfo.push([
match.index,
match.index + match[0].length,
// Wrap each of the found selectors in :global()
match[1]
.split(',')
.map(function (v) { return ":global(" + v.trim() + ")"; })
.join(', '),
]);
}
}
// Replace the found selectors with their wrapped variants in reverse order
return replacementInfo
.reverse()
.reduce(function (selector, _a) {
var matchIndex = _a[0], matchEndIndex = _a[1], replacement = _a[2];
var prefix = selector.slice(0, matchIndex);
var suffix = selector.slice(matchEndIndex);
return prefix + replacement + suffix;
}, selectorWithGlobals);
}
function expandSelector(newSelector, currentSelector) {
if (newSelector.indexOf(':global(') >= 0) {
return newSelector.replace(globalSelectorRegExp, '$1');
}
else if (newSelector.indexOf(':') === 0) {
return currentSelector + newSelector;
}
else if (newSelector.indexOf('&') < 0) {
return currentSelector + ' ' + newSelector;
}
return newSelector;
}
function extractSelector(currentSelector, rules, selector, value) {
if (rules === void 0) { rules = { __order: [] }; }
if (selector.indexOf('@') === 0) {
selector = selector + '{' + currentSelector;
extractRules([value], rules, selector);
}
else if (selector.indexOf(',') > -1) {
expandCommaSeparatedGlobals(selector)
.split(',')
.map(function (s) { return s.trim(); })
.forEach(function (separatedSelector) {
return extractRules([value], rules, expandSelector(separatedSelector,
currentSelector));
});
}
else {
extractRules([value], rules, expandSelector(selector, currentSelector));
}
}
function extractRules(args, rules, currentSelector) {
if (rules === void 0) { rules = { __order: [] }; }
if (currentSelector === void 0) { currentSelector = '&'; }
var currentRules = rules[currentSelector];
if (!currentRules) {
currentRules = {};
rules[currentSelector] = currentRules;
rules.__order.push(currentSelector);
}
for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
var arg = args_1[_i];
// If the arg is a string, we need to look up the class map and merge.
var expandedRules = stylesheet.argsFromClassName(arg);
if (expandedRules) {
extractRules(expandedRules, rules, currentSelector);
}
// Else if the arg is an array, we need to recurse in.
}
else if (Array.isArray(arg)) {
extractRules(arg, rules, currentSelector);
}
else {
for (var prop in arg) {
if (arg.hasOwnProperty(prop)) {
var propValue = arg[prop];
if (prop === 'selectors') {
// every child is a selector.
var selectors = arg.selectors;
for (var newSelector in selectors) {
if (selectors.hasOwnProperty(newSelector)) {
extractSelector(currentSelector, rules,
newSelector, selectors[newSelector]);
}
}
}
else if (typeof propValue === 'object') {
// prop is a selector.
if (propValue !== null) {
extractSelector(currentSelector, rules, prop,
propValue);
}
}
else {
if (propValue !== undefined) {
// Else, add the rule to the currentSelector.
if (prop === 'margin' || prop === 'padding') {
expandQuads(currentRules, prop, propValue);
}
else {
currentRules[prop] = propValue;
}
}
}
}
}
}
}
return rules;
}
function expandQuads(currentRules, name, value) {
var parts = typeof value === 'string' ?
tokenizeWithParentheses_1.tokenizeWithParentheses(value) : [value];
if (parts.length === 0) {
parts.push(value);
}
if (parts[parts.length - 1] === '!important') {
// Remove !important from parts, and append it to each part individually
parts = parts.slice(0, -1).map(function (p) { return p + ' !important'; });
}
currentRules[name + 'Top'] = parts[0];
currentRules[name + 'Right'] = parts[1] || parts[0];
currentRules[name + 'Bottom'] = parts[2] || parts[0];
currentRules[name + 'Left'] = parts[3] || parts[1] || parts[0];
}
function getKeyForRules(options, rules) {
var serialized = [options.rtl ? 'rtl' : 'ltr'];
var hasProps = false;
for (var _i = 0, _a = rules.__order; _i < _a.length; _i++) {
var selector = _a[_i];
serialized.push(selector);
var rulesForSelector = rules[selector];
for (var propName in rulesForSelector) {
if (rulesForSelector.hasOwnProperty(propName) &&
rulesForSelector[propName] !== undefined) {
hasProps = true;
serialized.push(propName, rulesForSelector[propName]);
}
}
}
return hasProps ? serialized.join('') : undefined;
}
function repeatString(target, count) {
if (count <= 0) {
return '';
}
if (count === 1) {
return target;
}
return target + repeatString(target, count - 1);
}
function serializeRuleEntries(options, ruleEntries) {
if (!ruleEntries) {
return '';
}
var allEntries = [];
for (var entry in ruleEntries) {
if (ruleEntries.hasOwnProperty(entry) && entry !== DISPLAY_NAME &&
ruleEntries[entry] !== undefined) {
allEntries.push(entry, ruleEntries[entry]);
}
}
// Apply transforms.
for (var i = 0; i < allEntries.length; i += 2) {
kebabRules_1.kebabRules(allEntries, i);
provideUnits_1.provideUnits(allEntries, i);
rtlifyRules_1.rtlifyRules(options, allEntries, i);
prefixRules_1.prefixRules(allEntries, i);
}
// Apply punctuation.
for (var i = 1; i < allEntries.length; i += 4) {
allEntries.splice(i, 1, ':', allEntries[i], ';');
}
return allEntries.join('');
}
exports.serializeRuleEntries = serializeRuleEntries;
function styleToRegistration(options) {
var args = [];
}
var rules = extractRules(args);
var key = getKeyForRules(options, rules);
if (key) {
var registration = {
className: stylesheet.classNameFromKey(key),
key: key,
args: args,
};
if (!registration.className) {
registration.className =
stylesheet.getClassName(getDisplayName(rules));
var rulesToInsert = [];
for (var _a = 0, _b = rules.__order; _a < _b.length; _a++) {
var selector = _b[_a];
rulesToInsert.push(selector, serializeRuleEntries(options,
rules[selector]));
}
registration.rulesToInsert = rulesToInsert;
}
return registration;
}
return undefined;
}
exports.styleToRegistration = styleToRegistration;
/**
* Insert style to stylesheet.
* @param registration Style registration.
* @param specificityMultiplier Number of times classname selector is repeated in
the css rule.
* This is to increase css specificity in case it's needed. Default to 1.
*/
function applyRegistration(registration, specificityMultiplier) {
if (specificityMultiplier === void 0) { specificityMultiplier = 1; }
var className = registration.className, key = registration.key, args =
registration.args, rulesToInsert = registration.rulesToInsert;
if (rulesToInsert) {
// rulesToInsert is an ordered array of selector/rule pairs.
for (var i = 0; i < rulesToInsert.length; i += 2) {
var rules = rulesToInsert[i + 1];
if (rules) {
var selector = rulesToInsert[i];
selector = selector.replace(/&/g, repeatString("." +
registration.className, specificityMultiplier));
// Insert. Note if a media query, we must close the query with a
final bracket.
var processedRule = selector + "{" + rules + "}" +
(selector.indexOf('@') === 0 ? '}' : '');
stylesheet.insertRule(processedRule);
}
}
stylesheet.cacheClassName(className, key, args, rulesToInsert);
}
}
exports.applyRegistration = applyRegistration;
function styleToClassName(options) {
var args = [];
}
var registration = styleToRegistration.apply(void 0,
tslib_1.__spreadArray([options], args));
if (registration) {
applyRegistration(registration, options.specificityMultiplier);
return registration.className;
}
return '';
}
exports.styleToClassName = styleToClassName;
//# sourceMappingURL=styleToClassName.js.map
/***/ }),
/***/ 54853:
"use strict";

exports.tokenizeWithParentheses = void 0;
/**
* Split a string into tokens separated by whitespace, except all text within
parentheses
* is treated as a single token (whitespace is ignored within parentheses).
*
* Unlike String.split(' '), multiple consecutive space characters are collapsed
and
* removed from the returned array (including leading and trailing spaces).
*
* For example:
* `tokenizeWithParentheses("3px calc(var(--x) / 2) 9px 0 ")`
* => `["3px", "calc(var(--x) / 2)", "9px", "0"]`
*
* @returns The array of tokens. Returns an empty array if the string was empty or
contained only whitespace.
*/
function tokenizeWithParentheses(value) {
var parts = [];
var partStart = 0;
var parens = 0;
for (var i = 0; i < value.length; i++) {
switch (value[i]) {
case '(':
parens++;
break;
case ')':
if (parens) {
parens--;
}
break;
case '\t':
case ' ':
if (!parens) {
// Add the new part if it's not an empty string
if (i > partStart) {
parts.push(value.substring(partStart, i));
}
partStart = i + 1;
}
break;
}
}
// Add the last part
if (partStart < value.length) {
parts.push(value.substring(partStart));
}
return parts;
}
exports.tokenizeWithParentheses = tokenizeWithParentheses;
//# sourceMappingURL=tokenizeWithParentheses.js.map
/***/ }),
/***/ 50299:
"use strict";

exports.kebabRules = void 0;
var rules = {};
function kebabRules(rulePairs, index) {
var rule = rulePairs[index];
if (rule.charAt(0) !== '-') {
rulePairs[index] = rules[rule] = rules[rule] || rule.replace(/([A-Z])/g, '-
$1').toLowerCase();
}
}
exports.kebabRules = kebabRules;
//# sourceMappingURL=kebabRules.js.map
/***/ }),
/***/ 28077:
"use strict";

exports.prefixRules = void 0;
var getVendorSettings_1 = __webpack_require__(75591);
var autoPrefixNames = {
'user-select': 1,
};
function prefixRules(rulePairs, index) {
var vendorSettings = getVendorSettings_1.getVendorSettings();
var name = rulePairs[index];
if (autoPrefixNames[name]) {
var value = rulePairs[index + 1];
if (autoPrefixNames[name]) {
if (vendorSettings.isWebkit) {
rulePairs.push('-webkit-' + name, value);
}
if (vendorSettings.isMoz) {
rulePairs.push('-moz-' + name, value);
}
if (vendorSettings.isMs) {
rulePairs.push('-ms-' + name, value);
}
if (vendorSettings.isOpera) {
rulePairs.push('-o-' + name, value);
}
}
}
}
exports.prefixRules = prefixRules;
//# sourceMappingURL=prefixRules.js.map
/***/ }),
/***/ 76906:
"use strict";

exports.provideUnits = void 0;
var NON_PIXEL_NUMBER_PROPS = [
'column-count',
'font-weight',
'flex',
'flex-grow',
'flex-shrink',
'fill-opacity',
'opacity',
'order',
'z-index',
'zoom',
];
function provideUnits(rulePairs, index) {
var name = rulePairs[index];
if (typeof value === 'number') {
var isNonPixelProp = NON_PIXEL_NUMBER_PROPS.indexOf(name) > -1;
var isVariableOrPrefixed = name.indexOf('--') > -1;
var unit = isNonPixelProp || isVariableOrPrefixed ? '' : 'px';
rulePairs[index + 1] = "" + value + unit;
}
}
exports.provideUnits = provideUnits;
//# sourceMappingURL=provideUnits.js.map
/***/ }),
/***/ 26908:
"use strict";
var _a;
exports.rtlifyRules = void 0;
var LEFT = 'left';
var RIGHT = 'right';
var NO_FLIP = '@noflip';
var NAME_REPLACEMENTS = (_a = {},
_a[LEFT] = RIGHT,
_a[RIGHT] = LEFT,
_a);
var VALUE_REPLACEMENTS = {
'w-resize': 'e-resize',
'sw-resize': 'se-resize',
'nw-resize': 'ne-resize',
};
/**
* RTLifies the rulePair in the array at the current index. This mutates the array
for performance
* reasons.
*/
function rtlifyRules(options, rulePairs, index) {
if (options.rtl) {
var name_1 = rulePairs[index];
if (!name_1) {
return;
}
if (typeof value === 'string' && value.indexOf(NO_FLIP) >= 0) {
rulePairs[index + 1] = value.replace(/\s*(?:\/\*\s*)?\@noflip\b(?:\s*\
*\/)?\s*?/g, '');
}
else if (name_1.indexOf(LEFT) >= 0) {
rulePairs[index] = name_1.replace(LEFT, RIGHT);
}
else if (name_1.indexOf(RIGHT) >= 0) {
rulePairs[index] = name_1.replace(RIGHT, LEFT);
}
else if (String(value).indexOf(LEFT) >= 0) {
rulePairs[index + 1] = value.replace(LEFT, RIGHT);
}
else if (String(value).indexOf(RIGHT) >= 0) {
rulePairs[index + 1] = value.replace(RIGHT, LEFT);
}
else if (NAME_REPLACEMENTS[name_1]) {
rulePairs[index] = NAME_REPLACEMENTS[name_1];
}
else if (VALUE_REPLACEMENTS[value]) {
rulePairs[index + 1] = VALUE_REPLACEMENTS[value];
}
else {
switch (name_1) {
case 'margin':
case 'padding':
rulePairs[index + 1] = flipQuad(value);
break;
case 'box-shadow':
rulePairs[index + 1] = negateNum(value, 0);
break;
}
}
}
}
exports.rtlifyRules = rtlifyRules;
/**
* Given a string value in a space delimited format (e.g. "1 2 3 4"), negates a
particular value.
*/
function negateNum(value, partIndex) {
var parts = value.split(' ');
var numberVal = parseInt(parts[partIndex], 10);
parts[0] = parts[0].replace(String(numberVal), String(numberVal * -1));
return parts.join(' ');
}
/**
* Given a string quad, flips the left and right values.
*/
function flipQuad(value) {
if (typeof value === 'string') {
var parts = value.split(' ');
if (parts.length === 4) {
return parts[0] + " " + parts[3] + " " + parts[2] + " " + parts[1];
}
}
return value;
}
//# sourceMappingURL=rtlifyRules.js.map
/***/ }),
/***/ 93890:
"use strict";

set_version_1.setVersion('@fluentui/merge-styles', '8.5.2');
/***/ }),
/***/ 89749:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 8904:
"use strict";

exports.FocusZone = void 0;
var FocusZone_types_1 = __webpack_require__(8883);
var IS_FOCUSABLE_ATTRIBUTE = 'data-is-focusable';
var IS_ENTER_DISABLED_ATTRIBUTE = 'data-disable-click-on-enter';
var FOCUSZONE_ID_ATTRIBUTE = 'data-focuszone-id';
var TABINDEX = 'tabindex';
var NO_VERTICAL_WRAP = 'data-no-vertical-wrap';
var NO_HORIZONTAL_WRAP = 'data-no-horizontal-wrap';
var LARGE_DISTANCE_FROM_CENTER = 999999999;
var LARGE_NEGATIVE_DISTANCE_FROM_CENTER = -999999999;
var focusZoneStyles;
var focusZoneClass = 'ms-FocusZone';
/**
* Raises a click on a target element based on a keyboard event.
*/
function raiseClickFromKeyboardEvent(target, ev) {
var event;
if (typeof MouseEvent === 'function') {
event = new MouseEvent('click', {
ctrlKey: ev === null || ev === void 0 ? void 0 : ev.ctrlKey,
metaKey: ev === null || ev === void 0 ? void 0 : ev.metaKey,
shiftKey: ev === null || ev === void 0 ? void 0 : ev.shiftKey,
altKey: ev === null || ev === void 0 ? void 0 : ev.altKey,
bubbles: ev === null || ev === void 0 ? void 0 : ev.bubbles,
cancelable: ev === null || ev === void 0 ? void 0 : ev.cancelable,
});
}
else {
event = document.createEvent('MouseEvents');
event.initMouseEvent('click', ev ? ev.bubbles : false, ev ? ev.cancelable :
false, window, // not using getWindow() since this can only be run client side
0, // detail
0, // screen x
0, // screen y
0, // client x
0, // client y
ev ? ev.ctrlKey : false, ev ? ev.altKey : false, ev ? ev.shiftKey : false,
ev ? ev.metaKey : false, 0, // button
null);
}
target.dispatchEvent(event);
}
// Helper function that will return a class for when the root is focused
function getRootClass() {
if (!focusZoneStyles) {
focusZoneStyles = merge_styles_1.mergeStyles({
selectors: {
':focus': {
outline: 'none',
},
},
}, focusZoneClass);
}
return focusZoneStyles;
}
var _allInstances = {};
var _outerZones = new Set();
var ALLOWED_INPUT_TYPES = ['text', 'number', 'password', 'email', 'tel', 'url',
'search', 'textarea'];
var ALLOW_VIRTUAL_ELEMENTS = false;
var FocusZone = /** @class */ (function (_super) {
tslib_1.__extends(FocusZone, _super);
function FocusZone(props) {
var _a, _b, _c, _d;
var _this = _super.call(this, props) || this;
_this._root = React.createRef();
_this._mergedRef = utilities_1.createMergedRef();
_this._onFocus = function (ev) {
if (_this._portalContainsElement(ev.target)) {
// If the event target is inside a portal do not process the event.
return;
}
var _a = _this.props, onActiveElementChanged =
_a.onActiveElementChanged,
doNotAllowFocusEventToPropagate = _a.doNotAllowFocusEventToPropagate,
stopFocusPropagation = _a.stopFocusPropagation,
onFocusNotification = _a.onFocusNotification, onFocus = _a.onFocus,
shouldFocusInnerElementWhenReceivedFocus =
_a.shouldFocusInnerElementWhenReceivedFocus, defaultTabbableElement =
_a.defaultTabbableElement;
var isImmediateDescendant =
_this._isImmediateDescendantOfZone(ev.target);
var newActiveElement;
if (isImmediateDescendant) {
newActiveElement = ev.target;
}
else {
var parentElement = ev.target;
while (parentElement && parentElement !== _this._root.current) {
if (utilities_1.isElementTabbable(parentElement) &&
_this._isImmediateDescendantOfZone(parentElement)) {
newActiveElement = parentElement;
break;
}
parentElement = utilities_1.getParent(parentElement,
ALLOW_VIRTUAL_ELEMENTS);
}
}
// If an inner focusable element should be focused when FocusZone
container receives focus
if (shouldFocusInnerElementWhenReceivedFocus && ev.target ===
_this._root.current) {
var maybeElementToFocus = defaultTabbableElement &&
typeof defaultTabbableElement === 'function' &&
_this._root.current &&
defaultTabbableElement(_this._root.current);
// try to focus defaultTabbable element
if (maybeElementToFocus &&
utilities_1.isElementTabbable(maybeElementToFocus)) {
newActiveElement = maybeElementToFocus;
maybeElementToFocus.focus();
}
else {
// force focus on first focusable element
_this.focus(true);
if (_this._activeElement) {
// set to null as new active element was handled in method
above
newActiveElement = null;
}
}
}
var initialElementFocused = !_this._activeElement;
// If the new active element is a child of this zone and received
focus,
// update alignment an immediate descendant
if (newActiveElement && newActiveElement !== _this._activeElement) {
if (isImmediateDescendant || initialElementFocused) {
_this._setFocusAlignment(newActiveElement, true, true);
}
_this._activeElement = newActiveElement;
if (initialElementFocused) {
_this._updateTabIndexes();
}
}
if (onActiveElementChanged) {
onActiveElementChanged(_this._activeElement, ev);
}
if (stopFocusPropagation || doNotAllowFocusEventToPropagate) {
ev.stopPropagation();
}
if (onFocus) {
onFocus(ev);
}
else if (onFocusNotification) {
onFocusNotification();
}
};
_this._onBlur = function () {
_this._setParkedFocus(false);
};
_this._onMouseDown = function (ev) {
return;
}
var disabled = _this.props.disabled;
if (disabled) {
return;
}
var target = ev.target;
var path = [];
while (target && target !== _this._root.current) {
path.push(target);
target = utilities_1.getParent(target, ALLOW_VIRTUAL_ELEMENTS);
}
while (path.length) {
target = path.pop();
if (target && utilities_1.isElementTabbable(target)) {
_this._setActiveElement(target, true);
}
if (utilities_1.isElementFocusZone(target)) {
// Stop here since the focus zone will take care of its own
children.
break;
}
}
};
/**
* Handle the keystrokes.
*/
_this._onKeyDown = function (ev, theme) {
return;
}
var _a = _this.props, direction = _a.direction, disabled = _a.disabled,
isInnerZoneKeystroke = _a.isInnerZoneKeystroke, pagingSupportDisabled =
_a.pagingSupportDisabled, shouldEnterInnerZone = _a.shouldEnterInnerZone;
if (disabled) {
return;
}
if (_this.props.onKeyDown) {
_this.props.onKeyDown(ev);
}
// If the default has been prevented, do not process keyboard events.
if (ev.isDefaultPrevented()) {
return;
}
if (_this._getDocument().activeElement === _this._root.current &&
_this._isInnerZone) {
// If this element has focus, it is being controlled by a parent.
// Ignore the keystroke.
return;
}
if (((shouldEnterInnerZone && shouldEnterInnerZone(ev)) ||
(isInnerZoneKeystroke && isInnerZoneKeystroke(ev))) &&
_this._isImmediateDescendantOfZone(ev.target)) {
// Try to focus
var innerZone = _this._getFirstInnerZone();
if (innerZone) {
if (!innerZone.focus(true)) {
return;
}
}
else if (utilities_1.isElementFocusSubZone(ev.target)) {
if (!_this.focusElement(utilities_1.getNextElement(ev.target,
ev.target.firstChild, true))) {
return;
}
}
else {
return;
}
}
else if (ev.altKey) {
return;
}
else {
// eslint-disable-next-line @fluentui/deprecated-keyboard-event-
props, deprecation/deprecation
switch (ev.which) {
case utilities_1.KeyCodes.space:
if (_this._shouldRaiseClicksOnSpace &&
_this._tryInvokeClickForFocusable(ev.target, ev)) {
break;
}
return;
case utilities_1.KeyCodes.left:
if (direction !==
FocusZone_types_1.FocusZoneDirection.vertical) {
_this._preventDefaultWhenHandled(ev);
if (_this._moveFocusLeft(theme)) {
break;
}
}
return;
case utilities_1.KeyCodes.right:
if (direction !==
if (_this._moveFocusRight(theme)) {
break;
}
}
return;
case utilities_1.KeyCodes.up:
if (direction !==
FocusZone_types_1.FocusZoneDirection.horizontal) {
if (_this._moveFocusUp()) {
break;
}
}
return;
case utilities_1.KeyCodes.down:
if (direction !==
FocusZone_types_1.FocusZoneDirection.horizontal) {
if (_this._moveFocusDown()) {
break;
}
}
return;
case utilities_1.KeyCodes.pageDown:
if (!pagingSupportDisabled && _this._moveFocusPaging(true))
{
break;
}
return;
case utilities_1.KeyCodes.pageUp:
if (!pagingSupportDisabled &&
_this._moveFocusPaging(false)) {
break;
}
return;
case utilities_1.KeyCodes.tab:
if (
_this.props.allowTabKey ||
_this.props.handleTabKey ===
FocusZone_types_1.FocusZoneTabbableElements.all ||
(_this.props.handleTabKey ===
FocusZone_types_1.FocusZoneTabbableElements.inputOnly &&
_this._isElementInput(ev.target))) {
var focusChanged = false;
_this._processingTabKey = true;
if (direction ===
FocusZone_types_1.FocusZoneDirection.vertical ||
!_this._shouldWrapFocus(_this._activeElement,
NO_HORIZONTAL_WRAP)) {
focusChanged = ev.shiftKey ? _this._moveFocusUp() :
_this._moveFocusDown();
}
else {
var tabWithDirection =
utilities_1.getRTL(theme) ? !ev.shiftKey : ev.shiftKey;
focusChanged = tabWithDirection ?
_this._moveFocusLeft(theme) : _this._moveFocusRight(theme);
}
_this._processingTabKey = false;
if (focusChanged) {
break;
}
else if
(_this.props.shouldResetActiveElementWhenTabFromZone) {
_this._activeElement = null;
}
}
return;
case utilities_1.KeyCodes.home:
if (_this._isContentEditableElement(ev.target) ||
(_this._isElementInput(ev.target) &&
!_this._shouldInputLoseFocus(ev.target, false))) {
return false;
}
var firstChild = _this._root.current &&
_this._root.current.firstChild;
if (_this._root.current &&
firstChild &&
_this.focusElement(utilities_1.getNextElement(_this._root.current, firstChild,
true))) {
break;
}
return;
case utilities_1.KeyCodes.end:
if (_this._isContentEditableElement(ev.target) ||
(_this._isElementInput(ev.target) &&
!_this._shouldInputLoseFocus(ev.target, true))) {
return false;
}
var lastChild = _this._root.current &&
_this._root.current.lastChild;
if (_this._root.current &&
_this.focusElement(utilities_1.getPreviousElement(_this._root.current, lastChild,
true, true, true))) {
break;
}
return;
case utilities_1.KeyCodes.enter:
if (_this._shouldRaiseClicksOnEnter &&
_this._tryInvokeClickForFocusable(ev.target, ev)) {
break;
}
return;
default:
return;
}
}
ev.preventDefault();
};
_this._getHorizontalDistanceFromCenter = function (isForward, activeRect,
targetRect) {
var leftAlignment = _this._focusAlignment.left ||
_this._focusAlignment.x || 0;
// ClientRect values can be floats that differ by very small fractions
of a decimal.
// If the difference between top and bottom are within a pixel then we
should treat
// them as equivalent by using Math.floor. For instance 5.2222 and
5.222221 should be equivalent,
// but without Math.Floor they will be handled incorrectly.
var targetRectTop = Math.floor(targetRect.top);
var activeRectBottom = Math.floor(activeRect.bottom);
var targetRectBottom = Math.floor(targetRect.bottom);
var activeRectTop = Math.floor(activeRect.top);
var isValidCandidateOnpagingDown = isForward && targetRectTop >
activeRectBottom;
var isValidCandidateOnpagingUp = !isForward && targetRectBottom <
activeRectTop;
if (isValidCandidateOnpagingDown || isValidCandidateOnpagingUp) {
if (leftAlignment >= targetRect.left && leftAlignment <=
targetRect.left + targetRect.width) {
return 0;
}
return Math.abs(targetRect.left + targetRect.width / 2 -
leftAlignment);
}
if (!_this._shouldWrapFocus(_this._activeElement, NO_VERTICAL_WRAP)) {
return LARGE_NEGATIVE_DISTANCE_FROM_CENTER;
}
return LARGE_DISTANCE_FROM_CENTER;
};
// Manage componentRef resolution.
utilities_1.initializeComponentRef(_this);
if (false) {}
_this._id = utilities_1.getId('FocusZone');
_this._focusAlignment = {
left: 0,
top: 0,
};
_this._processingTabKey = false;
var shouldRaiseClicksFallback = (_b = (_a = props.shouldRaiseClicks) !==
null && _a !== void 0 ? _a : FocusZone.defaultProps.shouldRaiseClicks) !== null &&
_b !== void 0 ? _b : true;
_this._shouldRaiseClicksOnEnter = (_c = props.shouldRaiseClicksOnEnter) !==
null && _c !== void 0 ? _c : shouldRaiseClicksFallback;
_this._shouldRaiseClicksOnSpace = (_d = props.shouldRaiseClicksOnSpace) !==
null && _d !== void 0 ? _d : shouldRaiseClicksFallback;
return _this;
}
/** Used for testing purposes only. */
FocusZone.getOuterZones = function () {
return _outerZones.size;
};
/**
* Handle global tab presses so that we can patch tabindexes on the fly.
* HEADS UP: This must not be an arrow function in order to be referentially
equal among instances
* for ref counting to work correctly!
*/
FocusZone._onKeyDownCapture = function (ev) {
// eslint-disable-next-line deprecation/deprecation, @fluentui/deprecated-
keyboard-event-props
if (ev.which === utilities_1.KeyCodes.tab) {
_outerZones.forEach(function (zone) { return
zone._updateTabIndexes(); });
}
};
FocusZone.prototype.componentDidMount = function () {
var root = this._root.current;
_allInstances[this._id] = this;
if (root) {
this._windowElement = utilities_1.getWindow(root);
var parentElement = utilities_1.getParent(root,
while (parentElement && parentElement !== this._getDocument().body &&
parentElement.nodeType === 1) {
if (utilities_1.isElementFocusZone(parentElement)) {
this._isInnerZone = true;
break;
}
}
if (!this._isInnerZone) {
_outerZones.add(this);
if (this._windowElement && _outerZones.size === 1) {
this._windowElement.addEventListener('keydown',
FocusZone._onKeyDownCapture, true);
}
}
this._root.current && this._root.current.addEventListener('blur',
this._onBlur, true);
// Assign initial tab indexes so that we can set initial focus as
appropriate.
this._updateTabIndexes();
if (this.props.defaultTabbableElement && typeof
this.props.defaultTabbableElement === 'string') {
this._activeElement =
this._getDocument().querySelector(this.props.defaultTabbableElement);
}
else if (this.props.defaultActiveElement) {
this._getDocument().querySelector(this.props.defaultActiveElement);
}
if (this.props.shouldFocusOnMount) {
this.focus();
}
}
};
FocusZone.prototype.componentDidUpdate = function () {
var doc = this._getDocument();
// If either _activeElement or _defaultFocusElement are no longer contained
by _root,
// reset those variables (and update tab indexes) to avoid memory leaks
if ((this._activeElement && !
utilities_1.elementContains(this._root.current, this._activeElement,
ALLOW_VIRTUAL_ELEMENTS)) ||
(this._defaultFocusElement &&
!utilities_1.elementContains(this._root.current,
this._defaultFocusElement, ALLOW_VIRTUAL_ELEMENTS))) {
this._activeElement = null;
this._defaultFocusElement = null;
this._updateTabIndexes();
}
if (!this.props.preventFocusRestoration &&
doc &&
this._lastIndexPath &&
(doc.activeElement === doc.body || doc.activeElement === null ||
doc.activeElement === root)) {
// The element has been removed after the render, attempt to restore
focus.
var elementToFocus = utilities_1.getFocusableByIndexPath(root,
this._lastIndexPath);
if (elementToFocus) {
this._setActiveElement(elementToFocus, true);
elementToFocus.focus();
this._setParkedFocus(false);
}
else {
// We had a focus path to restore, but now that path is
unresolvable. Park focus
// on the container until we can try again.
this._setParkedFocus(true);
}
}
};
FocusZone.prototype.componentWillUnmount = function () {
delete _allInstances[this._id];
if (!this._isInnerZone) {
_outerZones.delete(this);
// If this is the last outer zone, remove the keydown listener.
if (this._windowElement && _outerZones.size === 0) {
this._windowElement.removeEventListener('keydown',
FocusZone._onKeyDownCapture, true);
}
}
if (this._root.current) {
this._root.current.removeEventListener('blur', this._onBlur, true);
}
};
FocusZone.prototype.render = function () {
var _this = this;
var _a = this.props, tag = _a.as, elementType = _a.elementType, rootProps =
_a.rootProps, ariaDescribedBy = _a.ariaDescribedBy, ariaLabelledBy =
_a.ariaLabelledBy, className = _a.className;
var divProps = utilities_1.getNativeProps(this.props,
utilities_1.htmlElementProperties);
var Tag = tag || elementType || 'div';
// Note, right before rendering/reconciling proceeds, we need to record if
focus
// was in the zone before the update. This helper will track this and, if
focus
// was actually in the zone, what the index path to the element is at this
time.
// Then, later in componentDidUpdate, we can evaluate if we need to restore
it in
// the case the element was removed.
this._evaluateFocusBeforeRender();
// Only support RTL defined in global theme, not contextual theme/RTL.
var theme = style_utilities_1.getTheme();
return (React.createElement(Tag, tslib_1.__assign({ "aria-labelledby":
ariaLabelledBy, "aria-describedby": ariaDescribedBy }, divProps, rootProps, {
// Once the getClassName correctly memoizes inputs this should
// be replaced so that className is passed to getRootClass and is
included there so
// the class names will always be in the same order.
className: utilities_1.css(getRootClass(), className),
ref: this._mergedRef(this.props.elementRef, this._root), "data-
focuszone-id": this._id,
// eslint-disable-next-line react/jsx-no-bind
onKeyDown: function (ev) { return _this._onKeyDown(ev, theme); },
onFocus: this._onFocus, onMouseDownCapture: this._onMouseDown }),
this.props.children));
};
/**
* Sets focus to the first tabbable item in the zone.
* @param forceIntoFirstElement - If true, focus will be forced into the first
element, even
* if focus is already in the focus zone.
* @returns True if focus could be set to an active element, false if no
operation was taken.
*/
FocusZone.prototype.focus = function (forceIntoFirstElement) {
if (forceIntoFirstElement === void 0) { forceIntoFirstElement = false; }
if (!forceIntoFirstElement &&
this._root.current.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true'
&&
this._isInnerZone) {
var ownerZoneElement = this._getOwnerZone(this._root.current);
if (ownerZoneElement !== this._root.current) {
var ownerZone =
_allInstances[ownerZoneElement.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];
return !!ownerZone &&
ownerZone.focusElement(this._root.current);
}
return false;
}
else if (!forceIntoFirstElement &&
this._activeElement &&
utilities_1.elementContains(this._root.current,
this._activeElement) &&
utilities_1.isElementTabbable(this._activeElement)) {
this._activeElement.focus();
return true;
}
else {
var firstChild = this._root.current.firstChild;
return
this.focusElement(utilities_1.getNextElement(this._root.current, firstChild,
true));
}
}
return false;
};
/**
* Sets focus to the last tabbable item in the zone.
*/
FocusZone.prototype.focusLast = function () {
var lastChild = this._root.current && this._root.current.lastChild;
return
this.focusElement(utilities_1.getPreviousElement(this._root.current, lastChild,
true, true, true));
}
return false;
};
/**
* Sets focus to a specific child element within the zone. This can be used in
conjunction with
* shouldReceiveFocus to create delayed focus scenarios (like animate the
scroll position to the correct
* location and then focus.)
* @param element - The child element within the zone to focus.
* @param forceAlignment - If true, focus alignment will be set according to
the element provided.
*/
FocusZone.prototype.focusElement = function (element, forceAlignment) {
var _a = this.props, onBeforeFocus = _a.onBeforeFocus, shouldReceiveFocus =
_a.shouldReceiveFocus;
if ((shouldReceiveFocus && !shouldReceiveFocus(element)) || (onBeforeFocus
&& !onBeforeFocus(element))) {
return false;
}
if (element) {
// when we set focus to a specific child, we should recalculate the
alignment depending on its position.
this._setActiveElement(element, forceAlignment);
if (this._activeElement) {
}
return true;
}
return false;
};
/**
* Forces horizontal alignment in the context of vertical arrowing to use
specific point as the reference,
* rather than a center based on the last horizontal motion.
* @param point - the new reference point.
*/
FocusZone.prototype.setFocusAlignment = function (point) {
this._focusAlignment = point;
};
Object.defineProperty(FocusZone.prototype, "defaultFocusElement", {
get: function () {
return this._defaultFocusElement;
},
enumerable: false,
configurable: true
});
Object.defineProperty(FocusZone.prototype, "activeElement", {
get: function () {
return this._activeElement;
},
enumerable: false,
configurable: true
});
FocusZone.prototype._evaluateFocusBeforeRender = function () {
var doc = this._getDocument();
if (doc) {
var focusedElement = doc.activeElement;
// Only update the index path if we are not parked on the root.
if (focusedElement !== root) {
var shouldRestoreFocus = utilities_1.elementContains(root,
focusedElement, false);
this._lastIndexPath = shouldRestoreFocus ?
utilities_1.getElementIndexPath(root, focusedElement) : undefined;
}
}
};
/**
* When focus is in the zone at render time but then all focusable elements are
removed,
* we "park" focus temporarily on the root. Once we update with focusable
children, we restore
* focus to the closest path from previous. If the user tabs away from the
parked container,
* we restore focusability to the pre-parked state.
*/
FocusZone.prototype._setParkedFocus = function (isParked) {
if (root && this._isParked !== isParked) {
this._isParked = isParked;
if (isParked) {
if (!this.props.allowFocusRoot) {
this._parkedTabIndex = root.getAttribute('tabindex');
root.setAttribute('tabindex', '-1');
}
root.focus();
}
else if (!this.props.allowFocusRoot) {
if (this._parkedTabIndex) {
root.setAttribute('tabindex', this._parkedTabIndex);
this._parkedTabIndex = undefined;
}
else {
root.removeAttribute('tabindex');
}
}
}
};
FocusZone.prototype._setActiveElement = function (element, forceAlignment) {
var previousActiveElement = this._activeElement;
this._activeElement = element;
if (previousActiveElement) {
if (utilities_1.isElementFocusZone(previousActiveElement)) {
this._updateTabIndexes(previousActiveElement);
}
previousActiveElement.tabIndex = -1;
}
if (!this._focusAlignment || forceAlignment) {
this._setFocusAlignment(element, true, true);
}
this._activeElement.tabIndex = 0;
}
};
FocusZone.prototype._preventDefaultWhenHandled = function (ev) {
this.props.preventDefaultWhenHandled && ev.preventDefault();
};
/**
* Walk up the dom try to find a focusable element.
*/
FocusZone.prototype._tryInvokeClickForFocusable = function (targetElement, ev)
{
var target = targetElement;
if (target === this._root.current) {
return false;
}
do {
if (target.tagName === 'BUTTON' ||
target.tagName === 'A' ||
target.tagName === 'INPUT' ||
target.tagName === 'TEXTAREA') {
return false;
}
if (this._isImmediateDescendantOfZone(target) &&
target.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true' &&
target.getAttribute(IS_ENTER_DISABLED_ATTRIBUTE) !== 'true') {
raiseClickFromKeyboardEvent(target, ev);
return true;
}
target = utilities_1.getParent(target, ALLOW_VIRTUAL_ELEMENTS);
} while (target !== this._root.current);
return false;
};
/**
* Traverse to find first child zone.
*/
FocusZone.prototype._getFirstInnerZone = function (rootElement) {
rootElement = rootElement || this._activeElement || this._root.current;
if (!rootElement) {
return null;
}
if (utilities_1.isElementFocusZone(rootElement)) {
return _allInstances[rootElement.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];
}
var child = rootElement.firstElementChild;
while (child) {
if (utilities_1.isElementFocusZone(child)) {
return _allInstances[child.getAttribute(FOCUSZONE_ID_ATTRIBUTE)];
}
var match = this._getFirstInnerZone(child);
if (match) {
return match;
}
child = child.nextElementSibling;
}
return null;
};
FocusZone.prototype._moveFocus = function (isForward, getDistanceFromCenter,
ev, useDefaultWrap) {
if (useDefaultWrap === void 0) { useDefaultWrap = true; }
var element = this._activeElement;
var candidateDistance = -1;
var candidateElement = undefined;
var changedFocus = false;
var isBidirectional = this.props.direction ===
FocusZone_types_1.FocusZoneDirection.bidirectional;
if (!element || !this._root.current) {
return false;
}
if (this._isElementInput(element)) {
if (!this._shouldInputLoseFocus(element, isForward)) {
return false;
}
}
var activeRect = isBidirectional ? element.getBoundingClientRect() : null;
do {
element = (isForward
? utilities_1.getNextElement(this._root.current, element)
: utilities_1.getPreviousElement(this._root.current, element));
if (isBidirectional) {
if (element) {
var targetRect = element.getBoundingClientRect();
var elementDistance = getDistanceFromCenter(activeRect,
targetRect);
if (elementDistance === -1 && candidateDistance === -1) {
candidateElement = element;
break;
}
if (elementDistance > -1 && (candidateDistance === -1 ||
elementDistance < candidateDistance)) {
candidateDistance = elementDistance;
}
if (candidateDistance >= 0 && elementDistance < 0) {
break;
}
}
}
else {
break;
}
} while (element);
// Focus the closest candidate
if (candidateElement && candidateElement !== this._activeElement) {
changedFocus = true;
this.focusElement(candidateElement);
}
else if (this.props.isCircularNavigation && useDefaultWrap) {
if (isForward) {
return
this.focusElement(utilities_1.getNextElement(this._root.current,
this._root.current.firstElementChild, true));
}
else {
return
this.focusElement(utilities_1.getPreviousElement(this._root.current,
this._root.current.lastElementChild, true, true, true));
}
}
return changedFocus;
};
FocusZone.prototype._moveFocusDown = function () {
var _this = this;
var targetTop = -1;
var leftAlignment = this._focusAlignment.left || this._focusAlignment.x ||
0;
if (this._moveFocus(true, function (activeRect, targetRect) {
var distance = -1;
of a decimal.
should treat
if (targetRectTop < activeRectBottom) {
if (!_this._shouldWrapFocus(_this._activeElement,
NO_VERTICAL_WRAP)) {
}
}
if ((targetTop === -1 && targetRectTop >= activeRectBottom) ||
targetRectTop === targetTop) {
targetTop = targetRectTop;
distance = 0;
}
else {
distance = Math.abs(targetRect.left + targetRect.width / 2 -
leftAlignment);
}
}
return distance;
})) {
this._setFocusAlignment(this._activeElement, false, true);
return true;
}
return false;
};
FocusZone.prototype._moveFocusUp = function () {
var _this = this;
var targetTop = -1;
var leftAlignment = this._focusAlignment.left || this._focusAlignment.x ||
0;
if (this._moveFocus(false, function (activeRect, targetRect) {
var distance = -1;
of a decimal.
should treat
if (targetRectBottom > activeRectTop) {
if (!_this._shouldWrapFocus(_this._activeElement,
NO_VERTICAL_WRAP)) {
}
}
if ((targetTop === -1 && targetRectBottom <= activeRectTop) ||
targetRectTop === targetTop) {
distance = 0;
}
else {
distance = Math.abs(targetRect.left + targetRect.width / 2 -
leftAlignment);
}
}
return distance;
})) {
this._setFocusAlignment(this._activeElement, false, true);
return true;
}
return false;
};
FocusZone.prototype._moveFocusLeft = function (theme) {
var _this = this;
var shouldWrap = this._shouldWrapFocus(this._activeElement,
NO_HORIZONTAL_WRAP);
if (this._moveFocus(utilities_1.getRTL(theme), function (activeRect,
targetRect) {
var distance = -1;
var topBottomComparison;
if (utilities_1.getRTL(theme)) {
// When in RTL, this comparison should be the same as the one in
_moveFocusRight for LTR.
// Going left at a leftmost rectangle will go down a line instead
of up a line like in LTR.
// This is important, because we want to be comparing the top of
the target rect
// with the bottom of the active rect.
topBottomComparison = parseFloat(targetRect.top.toFixed(3)) <
parseFloat(activeRect.bottom.toFixed(3));
}
else {
topBottomComparison = parseFloat(targetRect.bottom.toFixed(3)) >
parseFloat(activeRect.top.toFixed(3));
}
if (topBottomComparison &&
targetRect.right <= activeRect.right &&
_this.props.direction !==
distance = activeRect.right - targetRect.right;
}
else if (!shouldWrap) {
distance = LARGE_NEGATIVE_DISTANCE_FROM_CENTER;
}
return distance;
}, undefined /*ev*/, shouldWrap)) {
this._setFocusAlignment(this._activeElement, true, false);
return true;
}
return false;
};
FocusZone.prototype._moveFocusRight = function (theme) {
var _this = this;
var shouldWrap = this._shouldWrapFocus(this._activeElement,
NO_HORIZONTAL_WRAP);
if (this._moveFocus(!utilities_1.getRTL(theme), function (activeRect,
targetRect) {
var distance = -1;
var topBottomComparison;
if (utilities_1.getRTL(theme)) {
// When in RTL, this comparison should be the same as the one in
_moveFocusLeft for LTR.
// Going right at a rightmost rectangle will go up a line instead
of down a line like in LTR.
// This is important, because we want to be comparing the bottom of
the target rect
// with the top of the active rect.
topBottomComparison = parseFloat(targetRect.bottom.toFixed(3)) >
parseFloat(activeRect.top.toFixed(3));
}
else {
topBottomComparison = parseFloat(targetRect.top.toFixed(3)) <
parseFloat(activeRect.bottom.toFixed(3));
}
if (topBottomComparison &&
targetRect.left >= activeRect.left &&
_this.props.direction !==
distance = targetRect.left - activeRect.left;
}
else if (!shouldWrap) {
distance = LARGE_NEGATIVE_DISTANCE_FROM_CENTER;
}
return distance;
}, undefined /*ev*/, shouldWrap)) {
this._setFocusAlignment(this._activeElement, true, false);
return true;
}
return false;
};
FocusZone.prototype._moveFocusPaging = function (isForward, useDefaultWrap) {
if (useDefaultWrap === void 0) { useDefaultWrap = true; }
var element = this._activeElement;
if (!element || !this._root.current) {
return false;
}
if (this._isElementInput(element)) {
if (!this._shouldInputLoseFocus(element, isForward)) {
return false;
}
}
var scrollableParent = utilities_1.findScrollableParent(element);
if (!scrollableParent) {
return false;
}
var candidateDistance = -1;
var candidateElement = undefined;
var targetTop = -1;
var targetBottom = -1;
var pagesize = scrollableParent.clientHeight;
var activeRect = element.getBoundingClientRect();
do {
element = isForward
? utilities_1.getNextElement(this._root.current, element)
: utilities_1.getPreviousElement(this._root.current, element);
if (element) {
var targetRect = element.getBoundingClientRect();
var elementDistance =
this._getHorizontalDistanceFromCenter(isForward, activeRect, targetRect);
var isElementPassedPageSizeOnPagingDown = isForward &&
targetRectTop > activeRectBottom + pagesize;
var isElementPassedPageSizeOnPagingUp = !isForward &&
targetRectBottom < activeRectTop - pagesize;
if (isElementPassedPageSizeOnPagingDown ||
isElementPassedPageSizeOnPagingUp) {
break;
}
if (elementDistance > -1) {
// for paging down
if (isForward && targetRectTop > targetTop) {
}
else if (!isForward && targetRectBottom < targetBottom) {
// for paging up
targetBottom = targetRectBottom;
}
else if (candidateDistance === -1 || elementDistance <=
candidateDistance) {
}
}
}
} while (element);
var changedFocus = false;
// Focus the closest candidate
if (candidateElement && candidateElement !== this._activeElement) {
changedFocus = true;
this.focusElement(candidateElement);
this._setFocusAlignment(candidateElement, false, true);
}
else if (this.props.isCircularNavigation && useDefaultWrap) {
if (isForward) {
return
this.focusElement(utilities_1.getNextElement(this._root.current,
this._root.current.firstElementChild, true));
}
return
this.focusElement(utilities_1.getPreviousElement(this._root.current,
this._root.current.lastElementChild, true, true, true));
}
return changedFocus;
};
FocusZone.prototype._setFocusAlignment = function (element, isHorizontal,
isVertical) {
if (this.props.direction ===
FocusZone_types_1.FocusZoneDirection.bidirectional &&
(!this._focusAlignment || isHorizontal || isVertical)) {
var rect = element.getBoundingClientRect();
var left = rect.left + rect.width / 2;
var top_1 = rect.top + rect.height / 2;
if (!this._focusAlignment) {
this._focusAlignment = { left: left, top: top_1 };
}
if (isHorizontal) {
this._focusAlignment.left = left;
}
if (isVertical) {
this._focusAlignment.top = top_1;
}
}
};
FocusZone.prototype._isImmediateDescendantOfZone = function (element) {
return this._getOwnerZone(element) === this._root.current;
};
FocusZone.prototype._getOwnerZone = function (element) {
var parentElement = utilities_1.getParent(element, ALLOW_VIRTUAL_ELEMENTS);
while (parentElement && parentElement !== this._root.current &&
parentElement !== this._getDocument().body) {
if (utilities_1.isElementFocusZone(parentElement)) {
return parentElement;
}
}
return parentElement;
};
FocusZone.prototype._updateTabIndexes = function (element) {
if (!this._activeElement &&
this.props.defaultTabbableElement &&
typeof this.props.defaultTabbableElement === 'function') {
this.props.defaultTabbableElement(this._root.current);
}
if (!element && this._root.current) {
element = this._root.current;
if (this._activeElement && !utilities_1.elementContains(element,
this._activeElement)) {
}
}
// If active element changes state to disabled, set it to null.
// Otherwise, we lose keyboard accessibility to other elements in focus
zone.
if (this._activeElement && !
utilities_1.isElementTabbable(this._activeElement)) {
}
var childNodes = element && element.children;
for (var childIndex = 0; childNodes && childIndex < childNodes.length;
childIndex++) {
var child = childNodes[childIndex];
if (!utilities_1.isElementFocusZone(child)) {
// If the item is explicitly set to not be focusable then TABINDEX
needs to be set to -1.
if (child.getAttribute &&
child.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'false') {
child.setAttribute(TABINDEX, '-1');
}
if (utilities_1.isElementTabbable(child)) {
if (this.props.disabled) {
}
else if (!this._isInnerZone &&
((!this._activeElement && !this._defaultFocusElement) ||
this._activeElement === child)) {
this._defaultFocusElement = child;
if (child.getAttribute(TABINDEX) !== '0') {
child.setAttribute(TABINDEX, '0');
}
}
else if (child.getAttribute(TABINDEX) !== '-1') {
}
}
else if (child.tagName === 'svg' && child.getAttribute('focusable')
!== 'false') {
// Disgusting IE hack. Sad face.
child.setAttribute('focusable', 'false');
}
}
else if (child.getAttribute(IS_FOCUSABLE_ATTRIBUTE) === 'true') {
if (!this._isInnerZone &&
((!this._activeElement && !this._defaultFocusElement) ||
this._activeElement === child)) {
this._defaultFocusElement = child;
if (child.getAttribute(TABINDEX) !== '0') {
child.setAttribute(TABINDEX, '0');
}
}
else if (child.getAttribute(TABINDEX) !== '-1') {
}
}
this._updateTabIndexes(child);
}
};
FocusZone.prototype._isContentEditableElement = function (element) {
return element && element.getAttribute('contenteditable') === 'true';
};
FocusZone.prototype._isElementInput = function (element) {
if (element &&
element.tagName &&
(element.tagName.toLowerCase() === 'input' ||
element.tagName.toLowerCase() === 'textarea')) {
return true;
}
return false;
};
FocusZone.prototype._shouldInputLoseFocus = function (element, isForward) {
// If a tab was used, we want to focus on the next element.
if (!this._processingTabKey &&
element &&
element.type &&
ALLOWED_INPUT_TYPES.indexOf(element.type.toLowerCase()) > -1) {
var selectionStart = element.selectionStart;
var selectionEnd = element.selectionEnd;
var isRangeSelected = selectionStart !== selectionEnd;
var inputValue = element.value;
var isReadonly = element.readOnly;
// We shouldn't lose focus in the following cases:
// 1. There is range selected.
// 2. When selection start is larger than 0 and it is backward and not
readOnly.
// 3. when selection start is not the end of length, it is forward and
not readOnly.
// 4. We press any of the arrow keys when our handleTabKey isn't none
or undefined (only losing focus if we hit
// tab) and if shouldInputLoseFocusOnArrowKey is defined, if scenario
prefers to not loose the focus which is
// determined by calling the callback shouldInputLoseFocusOnArrowKey
if (isRangeSelected ||
(selectionStart > 0 && !isForward && !isReadonly) ||
(selectionStart !== inputValue.length && isForward && !isReadonly)
||
(!!this.props.handleTabKey &&
!(this.props.shouldInputLoseFocusOnArrowKey &&
this.props.shouldInputLoseFocusOnArrowKey(element)))) {
return false;
}
}
return true;
};
FocusZone.prototype._shouldWrapFocus = function (element, noWrapDataAttribute)
{
return this.props.checkForNoWrap ? utilities_1.shouldWrapFocus(element,
noWrapDataAttribute) : true;
};
/**
* Returns true if the element is a descendant of the FocusZone through a React
portal.
*/
FocusZone.prototype._portalContainsElement = function (element) {
return element && !!this._root.current &&
utilities_1.portalContainsElement(element, this._root.current);
};
FocusZone.prototype._getDocument = function () {
return utilities_1.getDocument(this._root.current);
};
FocusZone.defaultProps = {
isCircularNavigation: false,
direction: FocusZone_types_1.FocusZoneDirection.bidirectional,
shouldRaiseClicks: true,
};
return FocusZone;
}(React.Component));
exports.FocusZone = FocusZone;
//# sourceMappingURL=FocusZone.js.map
/***/ }),
/***/ 8883:
"use strict";

exports.FocusZoneDirection = exports.FocusZoneTabbableElements = void 0;
/**
* {@docCategory FocusZone}
*/
exports.FocusZoneTabbableElements = {
/** Tabbing is not allowed */
none: 0,
/** All tabbing action is allowed */
all: 1,
/** Tabbing is allowed only on input elements */
inputOnly: 2,
};
/**
* {@docCategory FocusZone}
*/
var FocusZoneDirection;
(function (FocusZoneDirection) {
/** Only react to up/down arrows. */
FocusZoneDirection[FocusZoneDirection["vertical"] = 0] = "vertical";
/** Only react to left/right arrows. */
FocusZoneDirection[FocusZoneDirection["horizontal"] = 1] = "horizontal";
/** React to all arrows. */
FocusZoneDirection[FocusZoneDirection["bidirectional"] = 2] = "bidirectional";
/**
* React to all arrows. Navigate next item in DOM on right/down arrow keys and
previous - left/up arrow keys.
* Right and Left arrow keys are swapped in RTL mode.
*/
FocusZoneDirection[FocusZoneDirection["domOrder"] = 3] = "domOrder";
})(FocusZoneDirection = exports.FocusZoneDirection || (exports.FocusZoneDirection =
{}));
//# sourceMappingURL=FocusZone.types.js.map
/***/ }),
/***/ 78192:
"use strict";

/***/ }),
/***/ 39552:
"use strict";

/***/ }),
/***/ 10120:
"use strict";

set_version_1.setVersion('@fluentui/react-focus', '8.7.0');
/***/ }),
/***/ 46783:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 84682:
"use strict";

exports.useIsomorphicLayoutEffect = void 0;
// re-export since this is a hook, which people would reasonably expect to import
from react-hooks
Object.defineProperty(exports, "useIsomorphicLayoutEffect", ({ enumerable: true,
get: function () { return utilities_1.useIsomorphicLayoutEffect; } }));
/***/ }),
/***/ 25251:
"use strict";
exports.useAsync = void 0;
var useConst_1 = __webpack_require__(74798);
/**
* Hook to provide an Async instance that is automatically cleaned up on dismount.
*/
function useAsync() {
var async = useConst_1.useConst(function () { return new
utilities_1.Async(); });
// Function that returns a function in order to dispose the async instance on
unmount
React.useEffect(function () { return function () { return
async.dispose(); }; }, [async]);
return async;
}
exports.useAsync = useAsync;
//# sourceMappingURL=useAsync.js.map
/***/ }),
/***/ 63524:
"use strict";

exports.useBoolean = void 0;
/**
* Hook to store a value and generate callbacks for setting the value to true or
false.
* The identity of the callbacks will always stay the same.
*
* @param initialState - Initial value
* @returns Array with the current value and an object containing the updater
callbacks.
*/
function useBoolean(initialState) {
var _a = React.useState(initialState), value = _a[0], setValue = _a[1];
var setTrue = useConst_1.useConst(function () { return function () {
setValue(true);
}; });
var setFalse = useConst_1.useConst(function () { return function () {
setValue(false);
}; });
var toggle = useConst_1.useConst(function () { return function () {
setValue(function (currentValue) { return !currentValue; });
}; });
return [value, { setTrue: setTrue, setFalse: setFalse, toggle: toggle }];
}
exports.useBoolean = useBoolean;
//# sourceMappingURL=useBoolean.js.map
/***/ }),
/***/ 74798:
"use strict";

exports.useConst = void 0;
/**
* Hook to initialize and return a constant value. Unlike `React.useMemo`, this is
guaranteed to
* always return the same value (and if the initializer is a function, only call it
once).
* This is similar to setting a private member in a class constructor.
*
* If the value should ever change based on dependencies, use `React.useMemo`
instead.
*
* @param initialValue - Initial value, or function to get the initial value.
Similar to ùseState`,
* only the value/function passed in the first time this is called is respected.
* @returns The value. The identity of this value will always be the same.
*/
function useConst(initialValue) {
// Use useRef to store the value because it's the least expensive built-in hook
that works here
// (we could also use `const [value] = React.useState(initialValue)` but that's
more expensive
// internally due to reducer handling which we don't need)
var ref = React.useRef();
if (ref.current === undefined) {
// Box the value in an object so we can tell if it's initialized even if
the initializer
// returns/is undefined
ref.current = {
value: typeof initialValue === 'function' ? initialValue() :
initialValue,
};
}
return ref.current.value;
}
exports.useConst = useConst;
//# sourceMappingURL=useConst.js.map
/***/ }),
/***/ 32825:
"use strict";

exports.useConstCallback = void 0;
/**
* @deprecated Deprecated due to potential for misuse. Generally, use
`React.useCallback` instead.
* If you need a callback reference that never changes, consider
ùseEventCallback`.
*
* This hook was intended for creating callbacks which have no dependencies, and
therefore never
* need to change. It works fine if everyone using it is extremely mindful of how
closures work,
* but that's not a safe assumption--so in practice, usage of this hook tends to
result in bugs
* like unintentionally capturing the first value of a prop and not respecting
updates (when
* updates should be respected).
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function useConstCallback(callback) {
var ref = React.useRef();
if (!ref.current) {
ref.current = callback;
}
return ref.current;
}
exports.useConstCallback = useConstCallback;
//# sourceMappingURL=useConstCallback.js.map
/***/ }),
/***/ 86635:
"use strict";

exports.useControllableValue = void 0;
function useControllableValue(controlledValue, defaultUncontrolledValue, onChange)
{
var _a = React.useState(defaultUncontrolledValue), value = _a[0], setValue =
_a[1];
var isControlled = useConst_1.useConst(controlledValue !== undefined);
var currentValue = isControlled ? controlledValue : value;
// Duplicate the current value and onChange in refs so they're accessible from
// setValueOrCallOnChange without creating a new callback every time
var valueRef = React.useRef(currentValue);
var onChangeRef = React.useRef(onChange);
React.useEffect(function () {
valueRef.current = currentValue;
onChangeRef.current = onChange;
});
// To match the behavior of the setter returned by React.useState, this
callback's identity
// should never change. This means it MUST NOT directly reference variables
that can change.
var setValueOrCallOnChange = useConst_1.useConst(function () { return function
(update, ev) {
// Assuming here that TValue is not a function, because a controllable
value will typically
// be something a user can enter as input
var newValue = typeof update === 'function' ? update(valueRef.current) :
update;
if (onChangeRef.current) {
onChangeRef.current(ev, newValue);
}
if (!isControlled) {
setValue(newValue);
}
}; });
return [currentValue, setValueOrCallOnChange];
}
exports.useControllableValue = useControllableValue;
//# sourceMappingURL=useControllableValue.js.map
/***/ }),
/***/ 25030:
"use strict";

exports.useEventCallback = void 0;
/**
* Modified ùseCallback` that returns the same function reference every time, but
internally calls
* the most-recently passed callback implementation. Can be useful in situations
such as:
* - Event handler dependencies change too frequently, such as user props which
might change on
* every render, or volatile values such as useState/useDispatch
* - Callback must be referenced in a captured context (such as a window event
handler or unmount
* handler that's registered once) but needs access to the latest props
*
* In general, prefer ùseCallback` unless you've encountered one of the problems
above.
*
* https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-
from-usecallback
*
* @param fn - The callback function that will be used
* @returns A function which is referentially stable but internally calls the most
recently passed callback
*/
function useEventCallback(fn) {
var callbackRef = React.useRef(function () {
throw new Error('Cannot call an event handler while rendering');
});
utilities_1.useIsomorphicLayoutEffect(function () {
callbackRef.current = fn;
}, [fn]);
// useConst rather than useCallback to ensure the reference is always stable
// (useCallback's deps list is an optimization, not a guarantee)
return useConst_1.useConst(function () { return function () {
var args = [];
}
var callback = callbackRef.current;
return callback.apply(void 0, args);
}; });
}
exports.useEventCallback = useEventCallback;
//# sourceMappingURL=useEventCallback.js.map
/***/ }),
/***/ 49605:
"use strict";

exports.useForceUpdate = void 0;
/**
* Hook to force update a function component by updating a dummy state.
*/
function useForceUpdate() {
var _a = React.useState(0), setValue = _a[1];
var forceUpdate = useConst_1.useConst(function () { return function () { return
setValue(function (value) { return ++value; }); }; });
return forceUpdate;
}
exports.useForceUpdate = useForceUpdate;
//# sourceMappingURL=useForceUpdate.js.map
/***/ }),
/***/ 75234:
"use strict";

exports.useId = void 0;
/**
* Hook to generate a unique ID in the global scope (spanning across duplicate
copies of the same library).
*
* @param prefix - Optional prefix for the ID
* @param providedId - Optional id provided by a parent component. Defaults to the
provided value if present,
* without conditioning the hook call
* @returns The ID
*/
function useId(prefix, providedId) {
// getId should only be called once since it updates the global constant for
the next ID value.
// (While an extra update isn't likely to cause problems in practice, it's
better to avoid it.)
var ref = React.useRef(providedId);
if (!ref.current) {
ref.current = utilities_1.getId(prefix);
}
return ref.current;
}
exports.useId = useId;
//# sourceMappingURL=useId.js.map
/***/ }),
/***/ 64349:
"use strict";

exports.useMergedRefs = void 0;
/**
* React hook to merge multiple React refs (either MutableRefObjects or ref
callbacks) into a single ref callback that
* updates all provided refs
* @param refs - Refs to collectively update with one ref value.
* @returns A function with an attached "current" prop, so that it can be treated
like a RefObject.
*/
function useMergedRefs() {
var refs = [];
refs[_i] = arguments[_i];
}
var mergedCallback = React.useCallback(function (value) {
// Update the "current" prop hanging on the function.
mergedCallback.current = value;
for (var _i = 0, refs_1 = refs; _i < refs_1.length; _i++) {
var ref = refs_1[_i];
if (typeof ref === 'function') {
ref(value);
}
else if (ref) {
// work around the immutability of the React.Ref type
ref.current = value;
}
}
}, tslib_1.__spreadArray([], refs));
return mergedCallback;
}
exports.useMergedRefs = useMergedRefs;
//# sourceMappingURL=useMergedRefs.js.map
/***/ }),
/***/ 36174:
"use strict";

exports.useMount = void 0;
/**
* Hook which asynchronously executes a callback once the component has been
mounted.
*
* @param callback - Function to call before mount.
*/
var useMount = function (callback) {
var mountRef = React.useRef(callback);
mountRef.current = callback;
var _a;
(_a = mountRef.current) === null || _a === void 0 ? void 0 :
_a.call(mountRef);
}, []);
};
exports.useMount = useMount;
//# sourceMappingURL=useMount.js.map
/***/ }),
/***/ 24694:
"use strict";

exports.useMountSync = void 0;
/**
* Hook which synchronously executes a callback once the component has been
mounted.
*
* `WARNING` This should only be used if you need to perform an action after the
component has been mounted and
* before the browser paints. useMountSync will trigger debug warnings in server-
rendered scenarios and should be used
* sparingly.
*
* @deprecated Consider to use React.useEffect() or React.useLayoutEffect()
directly based on a use case
*
* @param callback - Function to call once the component has been mounted.
*/
var useMountSync = function (callback) {
var mountRef = React.useRef(callback);
mountRef.current = callback;
// eslint-disable-next-line no-restricted-properties
React.useLayoutEffect(function () {
var _a;
(_a = mountRef.current) === null || _a === void 0 ? void 0 :
_a.call(mountRef);
}, []);
};
exports.useMountSync = useMountSync;
//# sourceMappingURL=useMountSync.js.map
/***/ }),
/***/ 8356:
"use strict";

exports.useOnEvent = void 0;
/**
* Hook to attach an event handler on mount and handle cleanup.
* @param element - Element (or ref to an element) to attach the event handler to
* @param eventName - The event to attach a handler for
* @param callback - The handler for the event
* @param useCapture - Whether or not to attach the handler for the capture phase
*/
function useOnEvent(element, eventName, callback, useCapture) {
// Use a ref for the callback to prevent repeatedly attaching/unattaching
callbacks that are unstable across renders
var callbackRef = React.useRef(callback);
callbackRef.current = callback;
var actualElement = element && 'current' in element ? element.current :
element;
if (!actualElement) {
return;
}
var dispose = utilities_1.on(actualElement, eventName, function (ev)
{ return callbackRef.current(ev); }, useCapture);
return dispose;
}, [element, eventName, useCapture]);
}
exports.useOnEvent = useOnEvent;
//# sourceMappingURL=useOnEvent.js.map
/***/ }),
/***/ 74098:
"use strict";

exports.usePrevious = void 0;
var react_1 = __webpack_require__(67294);
/**
* Hook keeping track of a given value from a previous execution of the component
the Hook is used in.
*
* See [React Hooks FAQ](https://reactjs.org/docs/hooks-faq.html#how-to-get-the-
previous-props-or-state)
*/
function usePrevious(value) {
var ref = react_1.useRef();
react_1.useEffect(function () {
});
return ref.current;
}
exports.usePrevious = usePrevious;
//# sourceMappingURL=usePrevious.js.map
/***/ }),
/***/ 32547:
"use strict";

exports.useRefEffect = void 0;
/**
* Creates a ref, and calls a callback whenever the ref changes to a non-null
value. The callback can optionally return
* a cleanup function that'll be called before the value changes, and when the ref
is unmounted.
*
* This can be used to work around a limitation that useEffect cannot depend on
`ref.current` (see
* https://github.com/facebook/react/issues/14387#issuecomment-503616820).
*
* Usage example:
* ```ts
* const myRef = useRefEffect<HTMLElement>(element => {
* ...
* return () => { ... cleanup ... };
* });
* ```
* ```jsx
* <div ref={myRef} />
* ```
*
* @param callback - Called whenever the ref's value changes to non-null. Can
optionally return a cleanup function.
* @param initial - (Optional) The initial value for the ref.
*
* @returns A function that should be called to set the ref's value. The object
also has a `.current` member that can be
* used to access the ref's value (like a normal RefObject). It can be hooked up to
an element's `ref` property.
*/
function useRefEffect(callback, initial) {
if (initial === void 0) { initial = null; }
var createRefCallback = function () {
var refCallback = function (value) {
if (data.ref.current !== value) {
if (data.cleanup) {
data.cleanup();
data.cleanup = undefined;
}
data.ref.current = value;
if (value !== null) {
data.cleanup = data.callback(value);
}
}
};
refCallback.current = initial;
return refCallback;
};
var data = React.useRef({
ref: createRefCallback(),
callback: callback,
}).current;
data.callback = callback;
return data.ref;
}
exports.useRefEffect = useRefEffect;
//# sourceMappingURL=useRefEffect.js.map
/***/ }),
/***/ 37023:
"use strict";

exports.useSetInterval = void 0;
/**
* Returns a wrapper function for `setInterval` which automatically handles
disposal.
*/
var useSetInterval = function () {
var intervalIds = useConst_1.useConst({});
React.useEffect(function () { return function () {
for (var _i = 0, _a = Object.keys(intervalIds); _i < _a.length; _i++) {
var id = _a[_i];
clearInterval(id);
}
}; },
// useConst ensures this will never change, but react-hooks/exhaustive-deps
doesn't know that
[intervalIds]);
return useConst_1.useConst({
setInterval: function (func, duration) {
var id = setInterval(func, duration);
intervalIds[id] = 1;
return id;
},
clearInterval: function (id) {
delete intervalIds[id];
clearInterval(id);
},
});
};
exports.useSetInterval = useSetInterval;
//# sourceMappingURL=useSetInterval.js.map
/***/ }),
/***/ 49309:
"use strict";
exports.useSetTimeout = void 0;
/**
* Returns a wrapper function for `setTimeout` which automatically handles
disposal.
*/
var useSetTimeout = function () {
var timeoutIds = useConst_1.useConst({});
// Cleanup function.
for (var _i = 0, _a = Object.keys(timeoutIds); _i < _a.length; _i++) {
var id = _a[_i];
clearTimeout(id);
}
}; },
// useConst ensures this will never change, but react-hooks/exhaustive-deps
doesn't know that
[timeoutIds]);
// Return wrapper which will auto cleanup.
return useConst_1.useConst({
setTimeout: function (func, duration) {
var id = setTimeout(func, duration);
timeoutIds[id] = 1;
return id;
},
clearTimeout: function (id) {
delete timeoutIds[id];
clearTimeout(id);
},
});
};
exports.useSetTimeout = useSetTimeout;
//# sourceMappingURL=useSetTimeout.js.map
/***/ }),
/***/ 77286:
"use strict";

exports.useTarget = void 0;
var react_window_provider_1 = __webpack_require__(54915);
/**
* Hook to calculate and cache the target element specified by the given target
attribute,
* as well as the target element's (or host element's) parent window
* @param target- Target selector passed to the component as a property, describing
the element that
* the callout should target
* @param hostElement- The callout's host element, used for determining the parent
window.
*/
function useTarget(target, hostElement) {
var previousTargetProp = React.useRef();
var targetRef = React.useRef(null);
/**
* Stores an instance of Window, used to check
* for server side rendering and if focus was lost.
*/
var targetWindow = react_window_provider_1.useWindow();
// If the target element changed, find the new one. If we are tracking
// target with class name, always find element because we do not know if
// fabric has rendered a new element and disposed the old element.
if (!target || target !== previousTargetProp.current || typeof target ===
'string') {
var currentElement = hostElement === null || hostElement === void 0 ? void
0 : hostElement.current;
if (target) {
if (typeof target === 'string') {
var currentDoc = utilities_1.getDocument(currentElement);
targetRef.current = currentDoc ? currentDoc.querySelector(target) :
null;
}
else if ('stopPropagation' in target) {
targetRef.current = target;
}
else if ('getBoundingClientRect' in target) {
}
else if ('current' in target) {
targetRef.current = target.current;
}
else {
}
}
previousTargetProp.current = target;
}
return [targetRef, targetWindow];
}
exports.useTarget = useTarget;
//# sourceMappingURL=useTarget.js.map
/***/ }),
/***/ 65641:
"use strict";

exports.useUnmount = void 0;
/**
* Hook which synchronously executes a callback when the component is about to
unmount.
*
* @param callback - Function to call during unmount.
*/
var useUnmount = function (callback) {
var unmountRef = React.useRef(callback);
unmountRef.current = callback;
var _a;
(_a = unmountRef.current) === null || _a === void 0 ? void 0 :
_a.call(unmountRef);
}; }, []);
};
exports.useUnmount = useUnmount;
//# sourceMappingURL=useUnmount.js.map
/***/ }),
/***/ 77887:
"use strict";

exports.useWarnings = void 0;
var usePrevious_1 = __webpack_require__(74098);
var warningId = 0;
/**
* Only in development mode, display console warnings when certain conditions are
met.
* Note that all warnings except `controlledUsage` will only be shown on first
render
* (new `controlledUsage` warnings may be shown later due to prop changes).
*/
function useWarnings(options) {
if (false) { var req, _b, conditionallyRequired_1, warning, _i, other_1,
oldProps, componentId, hasWarnedRef, name_1, props, _a, other,
conditionallyRequired, deprecations, mutuallyExclusive, controlledUsage; }
}
exports.useWarnings = useWarnings;
//# sourceMappingURL=useWarnings.js.map
/***/ }),
/***/ 81049:
"use strict";

set_version_1.setVersion('@fluentui/react-hooks', '8.6.0');
/***/ }),
/***/ 31013:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 73976:
"use strict";
/* harmony export */ "G": () => (/* binding */ usePortalCompat),
/* harmony export */ "a": () => (/* binding */ PortalCompatContextProvider)
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ =
var PortalCompatContext =
/*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createContext( // eslint-disable-
next-line @typescript-eslint/no-empty-function
function () {
return function () {};
});
var PortalCompatContextProvider = PortalCompatContext.Provider;
function usePortalCompat() {
return react__WEBPACK_IMPORTED_MODULE_0__.useContext(PortalCompatContext);
}
//# sourceMappingURL=PortalCompatContext.js.map
/***/ }),
/***/ 35247:
"use strict";
/* harmony export */ "PortalCompatContextProvider": () => (/* reexport safe */
_PortalCompatContext__WEBPACK_IMPORTED_MODULE_0__.a),
/* harmony export */ "usePortalCompat": () => (/* reexport safe */
_PortalCompatContext__WEBPACK_IMPORTED_MODULE_0__.G)
if (828 != __webpack_require__.j) {
/* harmony import */ var _PortalCompatContext__WEBPACK_IMPORTED_MODULE_0__ =
}
/***/ }),
/***/ 39760:
"use strict";

exports.WindowProvider = exports.useDocument = exports.useWindow =
exports.WindowContext = void 0;
/**
* Context for providing the window.
*/
exports.WindowContext = React.createContext({
window: typeof window === 'object' ? window : undefined,
});
/**
* Hook to access the window object. This can be overridden contextually using the
`WindowProvider`.
*/
var useWindow = function () { return
React.useContext(exports.WindowContext).window; };
exports.useWindow = useWindow;
/**
* Hook to access the document object. This can be overridden contextually using
the `WindowProvider`.
*/
var useDocument = function () { var _a; return (_a =
React.useContext(exports.WindowContext).window) === null || _a === void 0 ? void
0 : _a.document; };
exports.useDocument = useDocument;
/**
* Component to provide the window object contextually. This is useful when
rendering content to an element
* contained within a child window or iframe element, where event handlers and
styling must be projected
* to an alternative window or document.
*/
var WindowProvider = function (props) {
return React.createElement(exports.WindowContext.Provider, { value: props },
props.children);
};
exports.WindowProvider = WindowProvider;
//# sourceMappingURL=WindowProvider.js.map
/***/ }),
/***/ 54915:
"use strict";

/***/ }),
/***/ 70084:
"use strict";

set_version_1.setVersion('@fluentui/react-window-provider', '2.2.1');
/***/ }),
/***/ 3599:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}
without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 12846:
"use strict";

//# sourceMappingURL=ActivityItem.js.map
/***/ }),
/***/ 84399:
"use strict";

//# sourceMappingURL=Announced.js.map
/***/ }),
/***/ 98515:
"use strict";
//# sourceMappingURL=Autofill.js.map
/***/ }),
/***/ 17455:
"use strict";

//# sourceMappingURL=Breadcrumb.js.map
/***/ }),
/***/ 36835:
"use strict";

//# sourceMappingURL=Button.js.map
/***/ }),
/***/ 91251:
"use strict";

//# sourceMappingURL=ButtonGrid.js.map
/***/ }),
/***/ 88210:
"use strict";

//# sourceMappingURL=Calendar.js.map
/***/ }),
/***/ 78658:
"use strict";

//# sourceMappingURL=Callout.js.map
/***/ }),
/***/ 19774:
"use strict";

//# sourceMappingURL=Check.js.map
/***/ }),
/***/ 78754:
"use strict";

//# sourceMappingURL=Checkbox.js.map
/***/ }),
/***/ 47543:
"use strict";

//# sourceMappingURL=ChoiceGroup.js.map
/***/ }),
/***/ 39269:
"use strict";

//# sourceMappingURL=Coachmark.js.map
/***/ }),
/***/ 43803:
"use strict";

//# sourceMappingURL=Color.js.map
/***/ }),
/***/ 52687:
"use strict";

//# sourceMappingURL=ColorPicker.js.map
/***/ }),
/***/ 20862:
"use strict";

//# sourceMappingURL=ComboBox.js.map
/***/ }),
/***/ 30992:
"use strict";

//# sourceMappingURL=CommandBar.js.map
/***/ }),
/***/ 34649:
"use strict";

//# sourceMappingURL=ContextualMenu.js.map
/***/ }),
/***/ 20311:
"use strict";

//# sourceMappingURL=DatePicker.js.map
/***/ }),
/***/ 96005:
"use strict";

exports.TimeConstants = exports.MonthOfYear = exports.FirstWeekOfYear =
exports.DayOfWeek = exports.DateRangeType = exports.DAYS_IN_WEEK = exports.setMonth
= exports.isInDateRangeArray = exports.getYearStart = exports.getYearEnd =
exports.getWeekNumbersInMonth = exports.getWeekNumber = exports.getStartDateOfWeek
= exports.getMonthStart = exports.getMonthEnd = exports.getEndDateOfWeek =
exports.getDateRangeArray = exports.getDatePartHashValue = exports.compareDates =
exports.compareDatePart = exports.addYears = exports.addWeeks = exports.addMonths =
exports.addDays = void 0;
// NOTE: This is not a full re-export because date-time-utilities includes some
additional stuff
// which is exported elsewhere, causes conflicts, or isn't needed.
var date_time_utilities_1 = __webpack_require__(45733);
Object.defineProperty(exports, "addDays", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.addDays; } }));
Object.defineProperty(exports, "addMonths", ({ enumerable: true, get: function () {
return date_time_utilities_1.addMonths; } }));
Object.defineProperty(exports, "addWeeks", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.addWeeks; } }));
Object.defineProperty(exports, "addYears", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.addYears; } }));
Object.defineProperty(exports, "compareDatePart", ({ enumerable: true, get:
function () { return date_time_utilities_1.compareDatePart; } }));
Object.defineProperty(exports, "compareDates", ({ enumerable: true, get: function
() { return date_time_utilities_1.compareDates; } }));
Object.defineProperty(exports, "getDatePartHashValue", ({ enumerable: true, get:
function () { return date_time_utilities_1.getDatePartHashValue; } }));
Object.defineProperty(exports, "getDateRangeArray", ({ enumerable: true, get:
function () { return date_time_utilities_1.getDateRangeArray; } }));
Object.defineProperty(exports, "getEndDateOfWeek", ({ enumerable: true, get:
function () { return date_time_utilities_1.getEndDateOfWeek; } }));
Object.defineProperty(exports, "getMonthEnd", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.getMonthEnd; } }));
Object.defineProperty(exports, "getMonthStart", ({ enumerable: true, get: function
() { return date_time_utilities_1.getMonthStart; } }));
Object.defineProperty(exports, "getStartDateOfWeek", ({ enumerable: true, get:
function () { return date_time_utilities_1.getStartDateOfWeek; } }));
Object.defineProperty(exports, "getWeekNumber", ({ enumerable: true, get: function
() { return date_time_utilities_1.getWeekNumber; } }));
Object.defineProperty(exports, "getWeekNumbersInMonth", ({ enumerable: true, get:
function () { return date_time_utilities_1.getWeekNumbersInMonth; } }));
Object.defineProperty(exports, "getYearEnd", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.getYearEnd; } }));
Object.defineProperty(exports, "getYearStart", ({ enumerable: true, get: function
() { return date_time_utilities_1.getYearStart; } }));
Object.defineProperty(exports, "isInDateRangeArray", ({ enumerable: true, get:
function () { return date_time_utilities_1.isInDateRangeArray; } }));
Object.defineProperty(exports, "setMonth", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.setMonth; } }));
Object.defineProperty(exports, "DAYS_IN_WEEK", ({ enumerable: true, get: function
() { return date_time_utilities_1.DAYS_IN_WEEK; } }));
Object.defineProperty(exports, "DateRangeType", ({ enumerable: true, get: function
() { return date_time_utilities_1.DateRangeType; } }));
Object.defineProperty(exports, "DayOfWeek", ({ enumerable: true, get: function () {
return date_time_utilities_1.DayOfWeek; } }));
Object.defineProperty(exports, "FirstWeekOfYear", ({ enumerable: true, get:
function () { return date_time_utilities_1.FirstWeekOfYear; } }));
Object.defineProperty(exports, "MonthOfYear", ({ enumerable: true, get: function ()
{ return date_time_utilities_1.MonthOfYear; } }));
Object.defineProperty(exports, "TimeConstants", ({ enumerable: true, get: function
() { return date_time_utilities_1.TimeConstants; } }));
//# sourceMappingURL=DateTimeUtilities.js.map
/***/ }),
/***/ 4737:
"use strict";

//# sourceMappingURL=DetailsList.js.map
/***/ }),
/***/ 69786:
"use strict";

exports["default"] = void 0;
var index_1 = __webpack_require__(93315);
Object.defineProperty(exports, "default", ({ enumerable: true, get: function ()
{ return index_1.Dialog; } }));
//# sourceMappingURL=Dialog.js.map
/***/ }),
/***/ 80028:
"use strict";

//# sourceMappingURL=Divider.js.map
/***/ }),
/***/ 31843:
"use strict";

//# sourceMappingURL=DocumentCard.js.map
/***/ }),
/***/ 67337:
"use strict";

//# sourceMappingURL=DragDrop.js.map
/***/ }),
/***/ 19167:
"use strict";

//# sourceMappingURL=Dropdown.js.map
/***/ }),
/***/ 55420:
"use strict";

//# sourceMappingURL=ExtendedPicker.js.map
/***/ }),
/***/ 20349:
"use strict";

//# sourceMappingURL=Fabric.js.map
/***/ }),
/***/ 51543:
"use strict";

//# sourceMappingURL=Facepile.js.map
/***/ }),
/***/ 68782:
"use strict";

//# sourceMappingURL=FloatingPicker.js.map
/***/ }),
/***/ 38136:
"use strict";

//# sourceMappingURL=FocusTrapZone.js.map
/***/ }),
/***/ 6171:
"use strict";

exports.FocusZoneTabbableElements = exports.FocusZoneDirection = exports.FocusZone
= void 0;
var react_focus_1 = __webpack_require__(39552);
Object.defineProperty(exports, "FocusZone", ({ enumerable: true, get: function () {
return react_focus_1.FocusZone; } }));
Object.defineProperty(exports, "FocusZoneDirection", ({ enumerable: true, get:
function () { return react_focus_1.FocusZoneDirection; } }));
Object.defineProperty(exports, "FocusZoneTabbableElements", ({ enumerable: true,
get: function () { return react_focus_1.FocusZoneTabbableElements; } }));
//# sourceMappingURL=FocusZone.js.map
/***/ }),
/***/ 70644:
"use strict";

//# sourceMappingURL=Grid.js.map
/***/ }),
/***/ 33893:
"use strict";

//# sourceMappingURL=GroupedList.js.map
/***/ }),
/***/ 7547:
"use strict";

//# sourceMappingURL=HoverCard.js.map
/***/ }),
/***/ 84819:
"use strict";

//# sourceMappingURL=Icon.js.map
/***/ }),
/***/ 10955:
"use strict";

var font_icons_mdl2_1 = __webpack_require__(10106);
Object.defineProperty(exports, "initializeIcons", ({ enumerable: true, get:
function () { return font_icons_mdl2_1.initializeIcons; } }));
//# sourceMappingURL=Icons.js.map
/***/ }),
/***/ 63132:
"use strict";

//# sourceMappingURL=Image.js.map
/***/ }),
/***/ 8149:
"use strict";

//# sourceMappingURL=Keytip.js.map
/***/ }),
/***/ 77566:
"use strict";

//# sourceMappingURL=KeytipData.js.map
/***/ }),
/***/ 38802:
"use strict";

//# sourceMappingURL=KeytipLayer.js.map
/***/ }),
/***/ 40508:
"use strict";

//# sourceMappingURL=Keytips.js.map
/***/ }),
/***/ 8084:
"use strict";

//# sourceMappingURL=Label.js.map
/***/ }),
/***/ 16276:
"use strict";

//# sourceMappingURL=Layer.js.map
/***/ }),
/***/ 66023:
"use strict";

//# sourceMappingURL=Link.js.map
/***/ }),
/***/ 80618:
"use strict";

//# sourceMappingURL=List.js.map
/***/ }),
/***/ 98387:
"use strict";

//# sourceMappingURL=MarqueeSelection.js.map
/***/ }),
/***/ 85173:
"use strict";

//# sourceMappingURL=MessageBar.js.map
/***/ }),
/***/ 14086:
"use strict";

exports["default"] = void 0;
Object.defineProperty(exports, "default", ({ enumerable: true, get: function ()
{ return index_1.Modal; } }));
//# sourceMappingURL=Modal.js.map
/***/ }),
/***/ 2431:
"use strict";

//# sourceMappingURL=Nav.js.map
/***/ }),
/***/ 65941:
"use strict";

//# sourceMappingURL=OverflowSet.js.map
/***/ }),
/***/ 18494:
"use strict";

//# sourceMappingURL=Overlay.js.map
/***/ }),
/***/ 71927:
"use strict";

//# sourceMappingURL=Panel.js.map
/***/ }),
/***/ 92650:
"use strict";

//# sourceMappingURL=Persona.js.map
/***/ }),
/***/ 9609:
"use strict";

//# sourceMappingURL=PersonaCoin.js.map
/***/ }),
/***/ 85641:
"use strict";

//# sourceMappingURL=Pickers.js.map
/***/ }),
/***/ 101:
"use strict";

//# sourceMappingURL=Pivot.js.map
/***/ }),
/***/ 39612:
"use strict";

//# sourceMappingURL=Popup.js.map
/***/ }),
/***/ 38669:
"use strict";

//# sourceMappingURL=Positioning.js.map
/***/ }),
/***/ 53188:
"use strict";

//# sourceMappingURL=PositioningContainer.js.map
/***/ }),
/***/ 46667:
"use strict";
//# sourceMappingURL=ProgressIndicator.js.map
/***/ }),
/***/ 68673:
"use strict";

//# sourceMappingURL=Rating.js.map
/***/ }),
/***/ 93418:
"use strict";

//# sourceMappingURL=ResizeGroup.js.map
/***/ }),
/***/ 46395:
"use strict";

//# sourceMappingURL=ResponsiveMode.js.map
/***/ }),
/***/ 71089:
"use strict";

//# sourceMappingURL=ScrollablePane.js.map
/***/ }),
/***/ 25635:
"use strict";

//# sourceMappingURL=SearchBox.js.map
/***/ }),
/***/ 51087:
"use strict";

//# sourceMappingURL=SelectableOption.js.map
/***/ }),
/***/ 93335:
"use strict";

//# sourceMappingURL=SelectedItemsList.js.map
/***/ }),
/***/ 59398:
"use strict";

//# sourceMappingURL=Selection.js.map
/***/ }),
/***/ 15239:
"use strict";

//# sourceMappingURL=Separator.js.map
/***/ }),
/***/ 50759:
"use strict";

//# sourceMappingURL=Shimmer.js.map
/***/ }),
/***/ 98855:
"use strict";

//# sourceMappingURL=ShimmeredDetailsList.js.map
/***/ }),
/***/ 96544:
"use strict";

//# sourceMappingURL=Slider.js.map
/***/ }),
/***/ 5175:
"use strict";

//# sourceMappingURL=SpinButton.js.map
/***/ }),
/***/ 36875:
"use strict";

//# sourceMappingURL=Spinner.js.map
/***/ }),
/***/ 54648:
"use strict";

//# sourceMappingURL=Stack.js.map
/***/ }),
/***/ 14754:
"use strict";

//# sourceMappingURL=Sticky.js.map
/***/ }),
/***/ 76891:
"use strict";

exports.getTheme = exports.getScreenSelector = exports.getPlaceholderStyles =
exports.getInputFocusStyle = exports.getIconClassName = exports.getIcon =
exports.getHighContrastNoAdjustStyle = exports.getGlobalClassNames =
exports.getFocusStyle = exports.getFocusOutlineStyle =
exports.getFadedOverflowStyle = exports.getEdgeChromiumNoHighContrastAdjustSelector
= exports.fontFace = exports.focusClear = exports.createFontStyles =
exports.concatStyleSetsWithProps = exports.concatStyleSets = exports.buildClassMap
= exports.ZIndexes = exports.ThemeSettingName = exports.Stylesheet =
exports.ScreenWidthMinXXXLarge = exports.ScreenWidthMinXXLarge =
exports.ScreenWidthMinXLarge = exports.ScreenWidthMinUhfMobile =
exports.ScreenWidthMinSmall = exports.ScreenWidthMinMedium =
exports.ScreenWidthMinLarge = exports.ScreenWidthMaxXXLarge =
exports.ScreenWidthMaxXLarge = exports.ScreenWidthMaxSmall =
exports.ScreenWidthMaxMedium = exports.ScreenWidthMaxLarge =
exports.PulsingBeaconAnimationStyles = exports.InjectionMode =
exports.IconFontSizes = exports.HighContrastSelectorWhite =
exports.HighContrastSelectorBlack = exports.HighContrastSelector =
exports.FontWeights = exports.FontSizes = exports.FontClassNames =
exports.EdgeChromiumHighContrastSelector = exports.DefaultPalette =
exports.DefaultFontStyles = exports.DefaultEffects = exports.ColorClassNames =
exports.AnimationVariables = exports.AnimationStyles = exports.AnimationClassNames
= void 0;
exports.registerDefaultFontFaces = exports.createTheme = exports.unregisterIcons =
exports.setIconOptions = exports.removeOnThemeChangeCallback =
exports.registerOnThemeChangeCallback = exports.registerIcons =
exports.registerIconAlias = exports.normalize = exports.noWrap =
exports.mergeStyles = exports.mergeStyleSets = exports.loadTheme =
exports.keyframes = exports.hiddenContentStyle = exports.getThemedContext = void 0;
Object.defineProperty(exports, "AnimationClassNames", ({ enumerable: true, get:
function () { return style_utilities_1.AnimationClassNames; } }));
Object.defineProperty(exports, "AnimationStyles", ({ enumerable: true, get:
function () { return style_utilities_1.AnimationStyles; } }));
Object.defineProperty(exports, "AnimationVariables", ({ enumerable: true, get:
function () { return style_utilities_1.AnimationVariables; } }));
Object.defineProperty(exports, "ColorClassNames", ({ enumerable: true, get:
function () { return style_utilities_1.ColorClassNames; } }));
Object.defineProperty(exports, "DefaultEffects", ({ enumerable: true, get: function
() { return style_utilities_1.DefaultEffects; } }));
Object.defineProperty(exports, "DefaultFontStyles", ({ enumerable: true, get:
function () { return style_utilities_1.DefaultFontStyles; } }));
Object.defineProperty(exports, "DefaultPalette", ({ enumerable: true, get: function
() { return style_utilities_1.DefaultPalette; } }));
Object.defineProperty(exports, "EdgeChromiumHighContrastSelector", ({ enumerable:
true, get: function () { return style_utilities_1.EdgeChromiumHighContrastSelector;
} }));
Object.defineProperty(exports, "FontClassNames", ({ enumerable: true, get: function
() { return style_utilities_1.FontClassNames; } }));
Object.defineProperty(exports, "FontSizes", ({ enumerable: true, get: function () {
return style_utilities_1.FontSizes; } }));
Object.defineProperty(exports, "FontWeights", ({ enumerable: true, get: function ()
{ return style_utilities_1.FontWeights; } }));
Object.defineProperty(exports, "HighContrastSelector", ({ enumerable: true, get:
function () { return style_utilities_1.HighContrastSelector; } }));
Object.defineProperty(exports, "HighContrastSelectorBlack", ({ enumerable: true,
get: function () { return style_utilities_1.HighContrastSelectorBlack; } }));
Object.defineProperty(exports, "HighContrastSelectorWhite", ({ enumerable: true,
get: function () { return style_utilities_1.HighContrastSelectorWhite; } }));
Object.defineProperty(exports, "IconFontSizes", ({ enumerable: true, get: function
() { return style_utilities_1.IconFontSizes; } }));
Object.defineProperty(exports, "InjectionMode", ({ enumerable: true, get: function
() { return style_utilities_1.InjectionMode; } }));
Object.defineProperty(exports, "PulsingBeaconAnimationStyles", ({ enumerable: true,
get: function () { return style_utilities_1.PulsingBeaconAnimationStyles; } }));
Object.defineProperty(exports, "ScreenWidthMaxLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMaxLarge; } }));
Object.defineProperty(exports, "ScreenWidthMaxMedium", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMaxMedium; } }));
Object.defineProperty(exports, "ScreenWidthMaxSmall", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMaxSmall; } }));
Object.defineProperty(exports, "ScreenWidthMaxXLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMaxXLarge; } }));
Object.defineProperty(exports, "ScreenWidthMaxXXLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMaxXXLarge; } }));
Object.defineProperty(exports, "ScreenWidthMinLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinLarge; } }));
Object.defineProperty(exports, "ScreenWidthMinMedium", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinMedium; } }));
Object.defineProperty(exports, "ScreenWidthMinSmall", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinSmall; } }));
Object.defineProperty(exports, "ScreenWidthMinUhfMobile", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinUhfMobile; } }));
Object.defineProperty(exports, "ScreenWidthMinXLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinXLarge; } }));
Object.defineProperty(exports, "ScreenWidthMinXXLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinXXLarge; } }));
Object.defineProperty(exports, "ScreenWidthMinXXXLarge", ({ enumerable: true, get:
function () { return style_utilities_1.ScreenWidthMinXXXLarge; } }));
Object.defineProperty(exports, "Stylesheet", ({ enumerable: true, get: function ()
{ return style_utilities_1.Stylesheet; } }));
Object.defineProperty(exports, "ThemeSettingName", ({ enumerable: true, get:
function () { return style_utilities_1.ThemeSettingName; } }));
Object.defineProperty(exports, "ZIndexes", ({ enumerable: true, get: function ()
{ return style_utilities_1.ZIndexes; } }));
Object.defineProperty(exports, "buildClassMap", ({ enumerable: true, get: function
() { return style_utilities_1.buildClassMap; } }));
function () { return style_utilities_1.concatStyleSets; } }));
get: function () { return style_utilities_1.concatStyleSetsWithProps; } }));
Object.defineProperty(exports, "createFontStyles", ({ enumerable: true, get:
function () { return style_utilities_1.createFontStyles; } }));
Object.defineProperty(exports, "focusClear", ({ enumerable: true, get: function ()
{ return style_utilities_1.focusClear; } }));
{ return style_utilities_1.fontFace; } }));
Object.defineProperty(exports, "getEdgeChromiumNoHighContrastAdjustSelector",
({ enumerable: true, get: function () { return
style_utilities_1.getEdgeChromiumNoHighContrastAdjustSelector; } }));
Object.defineProperty(exports, "getFadedOverflowStyle", ({ enumerable: true, get:
function () { return style_utilities_1.getFadedOverflowStyle; } }));
Object.defineProperty(exports, "getFocusOutlineStyle", ({ enumerable: true, get:
function () { return style_utilities_1.getFocusOutlineStyle; } }));
Object.defineProperty(exports, "getFocusStyle", ({ enumerable: true, get: function
() { return style_utilities_1.getFocusStyle; } }));
Object.defineProperty(exports, "getGlobalClassNames", ({ enumerable: true, get:
function () { return style_utilities_1.getGlobalClassNames; } }));
Object.defineProperty(exports, "getHighContrastNoAdjustStyle", ({ enumerable: true,
get: function () { return style_utilities_1.getHighContrastNoAdjustStyle; } }));
Object.defineProperty(exports, "getIcon", ({ enumerable: true, get: function ()
{ return style_utilities_1.getIcon; } }));
Object.defineProperty(exports, "getIconClassName", ({ enumerable: true, get:
function () { return style_utilities_1.getIconClassName; } }));
Object.defineProperty(exports, "getInputFocusStyle", ({ enumerable: true, get:
function () { return style_utilities_1.getInputFocusStyle; } }));
Object.defineProperty(exports, "getPlaceholderStyles", ({ enumerable: true, get:
function () { return style_utilities_1.getPlaceholderStyles; } }));
Object.defineProperty(exports, "getScreenSelector", ({ enumerable: true, get:
function () { return style_utilities_1.getScreenSelector; } }));
Object.defineProperty(exports, "getTheme", ({ enumerable: true, get: function ()
{ return style_utilities_1.getTheme; } }));
Object.defineProperty(exports, "getThemedContext", ({ enumerable: true, get:
function () { return style_utilities_1.getThemedContext; } }));
Object.defineProperty(exports, "hiddenContentStyle", ({ enumerable: true, get:
function () { return style_utilities_1.hiddenContentStyle; } }));
return style_utilities_1.keyframes; } }));
Object.defineProperty(exports, "loadTheme", ({ enumerable: true, get: function () {
return style_utilities_1.loadTheme; } }));
() { return style_utilities_1.mergeStyleSets; } }));
{ return style_utilities_1.mergeStyles; } }));
Object.defineProperty(exports, "noWrap", ({ enumerable: true, get: function ()
{ return style_utilities_1.noWrap; } }));
Object.defineProperty(exports, "normalize", ({ enumerable: true, get: function () {
return style_utilities_1.normalize; } }));
Object.defineProperty(exports, "registerIconAlias", ({ enumerable: true, get:
function () { return style_utilities_1.registerIconAlias; } }));
Object.defineProperty(exports, "registerIcons", ({ enumerable: true, get: function
() { return style_utilities_1.registerIcons; } }));
Object.defineProperty(exports, "registerOnThemeChangeCallback", ({ enumerable:
true, get: function () { return
style_utilities_1.registerOnThemeChangeCallback; } }));
Object.defineProperty(exports, "removeOnThemeChangeCallback", ({ enumerable: true,
get: function () { return style_utilities_1.removeOnThemeChangeCallback; } }));
Object.defineProperty(exports, "setIconOptions", ({ enumerable: true, get: function
() { return style_utilities_1.setIconOptions; } }));
Object.defineProperty(exports, "unregisterIcons", ({ enumerable: true, get:
function () { return style_utilities_1.unregisterIcons; } }));
var theme_1 = __webpack_require__(44337);
Object.defineProperty(exports, "createTheme", ({ enumerable: true, get: function ()
{ return theme_1.createTheme; } }));
Object.defineProperty(exports, "registerDefaultFontFaces", ({ enumerable: true,
get: function () { return theme_1.registerDefaultFontFaces; } }));
//# sourceMappingURL=Styling.js.map
/***/ }),
/***/ 9185:
"use strict";

//# sourceMappingURL=SwatchColorPicker.js.map
/***/ }),
/***/ 33547:
"use strict";

//# sourceMappingURL=TeachingBubble.js.map
/***/ }),
/***/ 31850:
"use strict";

//# sourceMappingURL=Text.js.map
/***/ }),
/***/ 76422:
"use strict";

//# sourceMappingURL=TextField.js.map
/***/ }),
/***/ 36754:
"use strict";

exports.registerDefaultFontFaces = exports.SharedColors = exports.NeutralColors =
exports.MotionAnimations = exports.MotionTimings = exports.MotionDurations =
exports.mergeThemes = exports.LocalizedFontNames = exports.LocalizedFontFamilies =
exports.createTheme = exports.createFontStyles = exports.FluentTheme =
exports.Depths = exports.DefaultSpacing = exports.DefaultPalette =
exports.DefaultFontStyles = exports.DefaultEffects = exports.CommunicationColors =
exports.AnimationVariables = exports.AnimationStyles = void 0;
//When adding new exports to this file, also add them to index.ts.
function () { return theme_1.AnimationStyles; } }));
function () { return theme_1.AnimationVariables; } }));
Object.defineProperty(exports, "CommunicationColors", ({ enumerable: true, get:
function () { return theme_1.CommunicationColors; } }));
() { return theme_1.DefaultEffects; } }));
function () { return theme_1.DefaultFontStyles; } }));
() { return theme_1.DefaultPalette; } }));
Object.defineProperty(exports, "DefaultSpacing", ({ enumerable: true, get: function
() { return theme_1.DefaultSpacing; } }));
Object.defineProperty(exports, "Depths", ({ enumerable: true, get: function ()
{ return theme_1.Depths; } }));
Object.defineProperty(exports, "FluentTheme", ({ enumerable: true, get: function ()
{ return theme_1.FluentTheme; } }));
function () { return theme_1.createFontStyles; } }));
Object.defineProperty(exports, "LocalizedFontFamilies", ({ enumerable: true, get:
function () { return theme_1.LocalizedFontFamilies; } }));
Object.defineProperty(exports, "LocalizedFontNames", ({ enumerable: true, get:
function () { return theme_1.LocalizedFontNames; } }));
Object.defineProperty(exports, "mergeThemes", ({ enumerable: true, get: function ()
{ return theme_1.mergeThemes; } }));
Object.defineProperty(exports, "MotionDurations", ({ enumerable: true, get:
function () { return theme_1.MotionDurations; } }));
Object.defineProperty(exports, "MotionTimings", ({ enumerable: true, get: function
() { return theme_1.MotionTimings; } }));
Object.defineProperty(exports, "MotionAnimations", ({ enumerable: true, get:
function () { return theme_1.MotionAnimations; } }));
Object.defineProperty(exports, "NeutralColors", ({ enumerable: true, get: function
() { return theme_1.NeutralColors; } }));
Object.defineProperty(exports, "SharedColors", ({ enumerable: true, get: function
() { return theme_1.SharedColors; } }));
//When adding new exports to this file, also add them to index.ts.
//# sourceMappingURL=Theme.js.map
/***/ }),
/***/ 85007:
"use strict";

//# sourceMappingURL=ThemeGenerator.js.map
/***/ }),
/***/ 87060:
"use strict";

//# sourceMappingURL=TimePicker.js.map
/***/ }),
/***/ 6278:
"use strict";

//# sourceMappingURL=Toggle.js.map
/***/ }),
/***/ 91481:
"use strict";

//# sourceMappingURL=Tooltip.js.map
/***/ }),
/***/ 56175:
"use strict";

exports.elementContainsAttribute = exports.elementContains =
exports.doesElementContainFocus = exports.divProperties = exports.disableBodyScroll
= exports.customizable = exports.css = exports.createMergedRef =
exports.createMemoizer = exports.createArray = exports.composeRenderFunction =
exports.composeComponentAs = exports.colProperties = exports.colGroupProperties =
exports.classNamesFunction = exports.calculatePrecision = exports.buttonProperties
= exports.baseElementProperties = exports.baseElementEvents =
exports.audioProperties = exports.assign = exports.assertNever = exports.asAsync =
exports.arraysEqual = exports.appendFunction = exports.anchorProperties =
exports.allowScrollOnElement = exports.allowOverscrollOnElement =
exports.addElementAtIndex = exports.addDirectionalKeyCode = exports.SelectionMode =
exports.SelectionDirection = exports.Selection = exports.SELECTION_CHANGE =
exports.Rectangle = exports.KeyCodes = exports.IsFocusVisibleClassName =
exports.GlobalSettings = exports.FocusRects = exports.FabricPerformance =
exports.EventGroup = exports.DelayedRender = exports.DATA_PORTAL_ATTRIBUTE =
exports.DATA_IS_SCROLLABLE_ATTRIBUTE = exports.CustomizerContext =
exports.Customizer = exports.Customizations = exports.BaseComponent =
exports.AutoScroll = exports.Async = void 0;
exports.initializeFocusRects = exports.initializeComponentRef =
exports.imgProperties = exports.imageProperties = exports.iframeProperties =
exports.htmlElementProperties = exports.hoistStatics = exports.hoistMethods =
exports.hasVerticalOverflow = exports.hasOverflow = exports.hasHorizontalOverflow =
exports.getWindow = exports.getVirtualParent = exports.getScrollbarWidth =
exports.getResourceUrl = exports.getRect = exports.getRTLSafeKeyCode =
exports.getRTL = exports.getPropsWithDefaults = exports.getPreviousElement =
exports.getParent = exports.getNextElement = exports.getNativeProps =
exports.getNativeElementProps = exports.getLastTabbable = exports.getLastFocusable
= exports.getLanguage = exports.getInitials = exports.getId =
exports.getFocusableByIndexPath = exports.getFirstVisibleElementFromSelector =
exports.getFirstTabbable = exports.getFirstFocusable = exports.getElementIndexPath
= exports.getDocument = exports.getDistanceBetweenPoints = exports.getChildren =
exports.format = exports.formProperties = exports.focusFirstChild =
exports.focusAsync = exports.flatten = exports.fitContentToBounds =
exports.findScrollableParent = exports.findIndex = exports.findElementRecursive =
exports.find = exports.filteredAssign = exports.extendComponent =
exports.enableBodyScroll = void 0;
exports.shouldWrapFocus = exports.shallowCompare = exports.setWarningCallback =
exports.setVirtualParent = exports.setSSR = exports.setRTL =
exports.setPortalAttribute = exports.setMemoizeWeakMap = exports.setLanguage =
exports.setFocusVisibility = exports.setBaseUrl = exports.selectProperties =
exports.safeSetTimeout = exports.safeRequestAnimationFrame =
exports.resetMemoizations = exports.resetIds = exports.resetControlledWarnings =
exports.replaceElement = exports.removeIndex = exports.raiseClick =
exports.precisionRound = exports.portalContainsElement = exports.optionProperties =
exports.on = exports.omit = exports.olProperties = exports.nullRender =
exports.modalize = exports.mergeSettings = exports.mergeScopedSettings =
exports.mergeCustomizations = exports.mergeAriaAttributeValues = exports.merge =
exports.memoizeFunction = exports.memoize = exports.mapEnumByName =
exports.liProperties = exports.labelProperties = exports.isVirtualElement =
exports.isMac = exports.isIOS = exports.isIE11 =
exports.isElementVisibleAndNotHidden = exports.isElementVisible =
exports.isElementTabbable = exports.isElementFocusZone =
exports.isElementFocusSubZone = exports.isDirectionalKeyCode = exports.isControlled
= exports.inputProperties = void 0;
exports.warnMutuallyExclusive = exports.warnDeprecations =
exports.warnControlledUsage = exports.warnConditionallyRequiredProps = exports.warn
= exports.videoProperties = exports.values = exports.useFocusRects =
exports.useCustomizationSettings = exports.unhoistMethods = exports.trProperties =
exports.toMatrix = exports.thProperties = exports.textAreaProperties =
exports.tdProperties = exports.tableProperties = exports.styled = void 0;
Object.defineProperty(exports, "Async", ({ enumerable: true, get: function ()
{ return utilities_1.Async; } }));
Object.defineProperty(exports, "AutoScroll", ({ enumerable: true, get: function ()
{ return utilities_1.AutoScroll; } }));
Object.defineProperty(exports, "BaseComponent", ({ enumerable: true, get: function
() { return utilities_1.BaseComponent; } }));
Object.defineProperty(exports, "Customizations", ({ enumerable: true, get: function
() { return utilities_1.Customizations; } }));
Object.defineProperty(exports, "Customizer", ({ enumerable: true, get: function ()
{ return utilities_1.Customizer; } }));
Object.defineProperty(exports, "CustomizerContext", ({ enumerable: true, get:
function () { return utilities_1.CustomizerContext; } }));
Object.defineProperty(exports, "DATA_IS_SCROLLABLE_ATTRIBUTE", ({ enumerable: true,
get: function () { return utilities_1.DATA_IS_SCROLLABLE_ATTRIBUTE; } }));
Object.defineProperty(exports, "DATA_PORTAL_ATTRIBUTE", ({ enumerable: true, get:
function () { return utilities_1.DATA_PORTAL_ATTRIBUTE; } }));
Object.defineProperty(exports, "DelayedRender", ({ enumerable: true, get: function
() { return utilities_1.DelayedRender; } }));
Object.defineProperty(exports, "EventGroup", ({ enumerable: true, get: function ()
{ return utilities_1.EventGroup; } }));
Object.defineProperty(exports, "FabricPerformance", ({ enumerable: true, get:
function () { return utilities_1.FabricPerformance; } }));
Object.defineProperty(exports, "FocusRects", ({ enumerable: true, get: function ()
{ return utilities_1.FocusRects; } }));
Object.defineProperty(exports, "GlobalSettings", ({ enumerable: true, get: function
() { return utilities_1.GlobalSettings; } }));
Object.defineProperty(exports, "IsFocusVisibleClassName", ({ enumerable: true, get:
function () { return utilities_1.IsFocusVisibleClassName; } }));
Object.defineProperty(exports, "KeyCodes", ({ enumerable: true, get: function ()
{ return utilities_1.KeyCodes; } }));
Object.defineProperty(exports, "Rectangle", ({ enumerable: true, get: function () {
return utilities_1.Rectangle; } }));
Object.defineProperty(exports, "SELECTION_CHANGE", ({ enumerable: true, get:
function () { return utilities_1.SELECTION_CHANGE; } }));
Object.defineProperty(exports, "Selection", ({ enumerable: true, get: function () {
return utilities_1.Selection; } }));
Object.defineProperty(exports, "SelectionDirection", ({ enumerable: true, get:
function () { return utilities_1.SelectionDirection; } }));
Object.defineProperty(exports, "SelectionMode", ({ enumerable: true, get: function
() { return utilities_1.SelectionMode; } }));
Object.defineProperty(exports, "addDirectionalKeyCode", ({ enumerable: true, get:
function () { return utilities_1.addDirectionalKeyCode; } }));
Object.defineProperty(exports, "addElementAtIndex", ({ enumerable: true, get:
function () { return utilities_1.addElementAtIndex; } }));
Object.defineProperty(exports, "allowOverscrollOnElement", ({ enumerable: true,
get: function () { return utilities_1.allowOverscrollOnElement; } }));
Object.defineProperty(exports, "allowScrollOnElement", ({ enumerable: true, get:
function () { return utilities_1.allowScrollOnElement; } }));
Object.defineProperty(exports, "anchorProperties", ({ enumerable: true, get:
function () { return utilities_1.anchorProperties; } }));
Object.defineProperty(exports, "appendFunction", ({ enumerable: true, get: function
() { return utilities_1.appendFunction; } }));
Object.defineProperty(exports, "arraysEqual", ({ enumerable: true, get: function ()
{ return utilities_1.arraysEqual; } }));
Object.defineProperty(exports, "asAsync", ({ enumerable: true, get: function ()
{ return utilities_1.asAsync; } }));
Object.defineProperty(exports, "assertNever", ({ enumerable: true, get: function ()
{ return utilities_1.assertNever; } }));
Object.defineProperty(exports, "assign", ({ enumerable: true, get: function ()
{ return utilities_1.assign; } }));
Object.defineProperty(exports, "audioProperties", ({ enumerable: true, get:
function () { return utilities_1.audioProperties; } }));
Object.defineProperty(exports, "baseElementEvents", ({ enumerable: true, get:
function () { return utilities_1.baseElementEvents; } }));
Object.defineProperty(exports, "baseElementProperties", ({ enumerable: true, get:
function () { return utilities_1.baseElementProperties; } }));
Object.defineProperty(exports, "buttonProperties", ({ enumerable: true, get:
function () { return utilities_1.buttonProperties; } }));
Object.defineProperty(exports, "calculatePrecision", ({ enumerable: true, get:
function () { return utilities_1.calculatePrecision; } }));
Object.defineProperty(exports, "classNamesFunction", ({ enumerable: true, get:
function () { return utilities_1.classNamesFunction; } }));
Object.defineProperty(exports, "colGroupProperties", ({ enumerable: true, get:
function () { return utilities_1.colGroupProperties; } }));
Object.defineProperty(exports, "colProperties", ({ enumerable: true, get: function
() { return utilities_1.colProperties; } }));
Object.defineProperty(exports, "composeComponentAs", ({ enumerable: true, get:
function () { return utilities_1.composeComponentAs; } }));
Object.defineProperty(exports, "composeRenderFunction", ({ enumerable: true, get:
function () { return utilities_1.composeRenderFunction; } }));
Object.defineProperty(exports, "createArray", ({ enumerable: true, get: function ()
{ return utilities_1.createArray; } }));
Object.defineProperty(exports, "createMemoizer", ({ enumerable: true, get: function
() { return utilities_1.createMemoizer; } }));
Object.defineProperty(exports, "createMergedRef", ({ enumerable: true, get:
function () { return utilities_1.createMergedRef; } }));
Object.defineProperty(exports, "css", ({ enumerable: true, get: function ()
{ return utilities_1.css; } }));
Object.defineProperty(exports, "customizable", ({ enumerable: true, get: function
() { return utilities_1.customizable; } }));
Object.defineProperty(exports, "disableBodyScroll", ({ enumerable: true, get:
function () { return utilities_1.disableBodyScroll; } }));
Object.defineProperty(exports, "divProperties", ({ enumerable: true, get: function
() { return utilities_1.divProperties; } }));
Object.defineProperty(exports, "doesElementContainFocus", ({ enumerable: true, get:
function () { return utilities_1.doesElementContainFocus; } }));
Object.defineProperty(exports, "elementContains", ({ enumerable: true, get:
function () { return utilities_1.elementContains; } }));
Object.defineProperty(exports, "elementContainsAttribute", ({ enumerable: true,
get: function () { return utilities_1.elementContainsAttribute; } }));
Object.defineProperty(exports, "enableBodyScroll", ({ enumerable: true, get:
function () { return utilities_1.enableBodyScroll; } }));
Object.defineProperty(exports, "extendComponent", ({ enumerable: true, get:
function () { return utilities_1.extendComponent; } }));
Object.defineProperty(exports, "filteredAssign", ({ enumerable: true, get: function
() { return utilities_1.filteredAssign; } }));
Object.defineProperty(exports, "find", ({ enumerable: true, get: function ()
{ return utilities_1.find; } }));
Object.defineProperty(exports, "findElementRecursive", ({ enumerable: true, get:
function () { return utilities_1.findElementRecursive; } }));
Object.defineProperty(exports, "findIndex", ({ enumerable: true, get: function () {
return utilities_1.findIndex; } }));
Object.defineProperty(exports, "findScrollableParent", ({ enumerable: true, get:
function () { return utilities_1.findScrollableParent; } }));
Object.defineProperty(exports, "fitContentToBounds", ({ enumerable: true, get:
function () { return utilities_1.fitContentToBounds; } }));
Object.defineProperty(exports, "flatten", ({ enumerable: true, get: function ()
{ return utilities_1.flatten; } }));
Object.defineProperty(exports, "focusAsync", ({ enumerable: true, get: function ()
{ return utilities_1.focusAsync; } }));
Object.defineProperty(exports, "focusFirstChild", ({ enumerable: true, get:
function () { return utilities_1.focusFirstChild; } }));
Object.defineProperty(exports, "formProperties", ({ enumerable: true, get: function
() { return utilities_1.formProperties; } }));
Object.defineProperty(exports, "format", ({ enumerable: true, get: function ()
{ return utilities_1.format; } }));
Object.defineProperty(exports, "getChildren", ({ enumerable: true, get: function ()
{ return utilities_1.getChildren; } }));
Object.defineProperty(exports, "getDistanceBetweenPoints", ({ enumerable: true,
get: function () { return utilities_1.getDistanceBetweenPoints; } }));
Object.defineProperty(exports, "getDocument", ({ enumerable: true, get: function ()
{ return utilities_1.getDocument; } }));
Object.defineProperty(exports, "getElementIndexPath", ({ enumerable: true, get:
function () { return utilities_1.getElementIndexPath; } }));
Object.defineProperty(exports, "getFirstFocusable", ({ enumerable: true, get:
function () { return utilities_1.getFirstFocusable; } }));
Object.defineProperty(exports, "getFirstTabbable", ({ enumerable: true, get:
function () { return utilities_1.getFirstTabbable; } }));
Object.defineProperty(exports, "getFirstVisibleElementFromSelector", ({ enumerable:
utilities_1.getFirstVisibleElementFromSelector; } }));
Object.defineProperty(exports, "getFocusableByIndexPath", ({ enumerable: true, get:
function () { return utilities_1.getFocusableByIndexPath; } }));
Object.defineProperty(exports, "getId", ({ enumerable: true, get: function ()
{ return utilities_1.getId; } }));
Object.defineProperty(exports, "getInitials", ({ enumerable: true, get: function ()
{ return utilities_1.getInitials; } }));
Object.defineProperty(exports, "getLanguage", ({ enumerable: true, get: function ()
{ return utilities_1.getLanguage; } }));
Object.defineProperty(exports, "getLastFocusable", ({ enumerable: true, get:
function () { return utilities_1.getLastFocusable; } }));
Object.defineProperty(exports, "getLastTabbable", ({ enumerable: true, get:
function () { return utilities_1.getLastTabbable; } }));
Object.defineProperty(exports, "getNativeElementProps", ({ enumerable: true, get:
function () { return utilities_1.getNativeElementProps; } }));
Object.defineProperty(exports, "getNativeProps", ({ enumerable: true, get: function
() { return utilities_1.getNativeProps; } }));
Object.defineProperty(exports, "getNextElement", ({ enumerable: true, get: function
() { return utilities_1.getNextElement; } }));
Object.defineProperty(exports, "getParent", ({ enumerable: true, get: function () {
return utilities_1.getParent; } }));
Object.defineProperty(exports, "getPreviousElement", ({ enumerable: true, get:
function () { return utilities_1.getPreviousElement; } }));
Object.defineProperty(exports, "getPropsWithDefaults", ({ enumerable: true, get:
function () { return utilities_1.getPropsWithDefaults; } }));
Object.defineProperty(exports, "getRTL", ({ enumerable: true, get: function ()
{ return utilities_1.getRTL; } }));
Object.defineProperty(exports, "getRTLSafeKeyCode", ({ enumerable: true, get:
function () { return utilities_1.getRTLSafeKeyCode; } }));
Object.defineProperty(exports, "getRect", ({ enumerable: true, get: function ()
{ return utilities_1.getRect; } }));
Object.defineProperty(exports, "getResourceUrl", ({ enumerable: true, get: function
() { return utilities_1.getResourceUrl; } }));
Object.defineProperty(exports, "getScrollbarWidth", ({ enumerable: true, get:
function () { return utilities_1.getScrollbarWidth; } }));
Object.defineProperty(exports, "getVirtualParent", ({ enumerable: true, get:
function () { return utilities_1.getVirtualParent; } }));
Object.defineProperty(exports, "getWindow", ({ enumerable: true, get: function () {
return utilities_1.getWindow; } }));
Object.defineProperty(exports, "hasHorizontalOverflow", ({ enumerable: true, get:
function () { return utilities_1.hasHorizontalOverflow; } }));
Object.defineProperty(exports, "hasOverflow", ({ enumerable: true, get: function ()
{ return utilities_1.hasOverflow; } }));
Object.defineProperty(exports, "hasVerticalOverflow", ({ enumerable: true, get:
function () { return utilities_1.hasVerticalOverflow; } }));
Object.defineProperty(exports, "hoistMethods", ({ enumerable: true, get: function
() { return utilities_1.hoistMethods; } }));
Object.defineProperty(exports, "hoistStatics", ({ enumerable: true, get: function
() { return utilities_1.hoistStatics; } }));
Object.defineProperty(exports, "htmlElementProperties", ({ enumerable: true, get:
function () { return utilities_1.htmlElementProperties; } }));
Object.defineProperty(exports, "iframeProperties", ({ enumerable: true, get:
function () { return utilities_1.iframeProperties; } }));
Object.defineProperty(exports, "imageProperties", ({ enumerable: true, get:
function () { return utilities_1.imageProperties; } }));
Object.defineProperty(exports, "imgProperties", ({ enumerable: true, get: function
() { return utilities_1.imgProperties; } }));
Object.defineProperty(exports, "initializeComponentRef", ({ enumerable: true, get:
function () { return utilities_1.initializeComponentRef; } }));
Object.defineProperty(exports, "initializeFocusRects", ({ enumerable: true, get:
function () { return utilities_1.initializeFocusRects; } }));
Object.defineProperty(exports, "inputProperties", ({ enumerable: true, get:
function () { return utilities_1.inputProperties; } }));
Object.defineProperty(exports, "isControlled", ({ enumerable: true, get: function
() { return utilities_1.isControlled; } }));
Object.defineProperty(exports, "isDirectionalKeyCode", ({ enumerable: true, get:
function () { return utilities_1.isDirectionalKeyCode; } }));
Object.defineProperty(exports, "isElementFocusSubZone", ({ enumerable: true, get:
function () { return utilities_1.isElementFocusSubZone; } }));
Object.defineProperty(exports, "isElementFocusZone", ({ enumerable: true, get:
function () { return utilities_1.isElementFocusZone; } }));
Object.defineProperty(exports, "isElementTabbable", ({ enumerable: true, get:
function () { return utilities_1.isElementTabbable; } }));
Object.defineProperty(exports, "isElementVisible", ({ enumerable: true, get:
function () { return utilities_1.isElementVisible; } }));
Object.defineProperty(exports, "isElementVisibleAndNotHidden", ({ enumerable: true,
get: function () { return utilities_1.isElementVisibleAndNotHidden; } }));
Object.defineProperty(exports, "isIE11", ({ enumerable: true, get: function ()
{ return utilities_1.isIE11; } }));
Object.defineProperty(exports, "isIOS", ({ enumerable: true, get: function ()
{ return utilities_1.isIOS; } }));
Object.defineProperty(exports, "isMac", ({ enumerable: true, get: function ()
{ return utilities_1.isMac; } }));
Object.defineProperty(exports, "isVirtualElement", ({ enumerable: true, get:
function () { return utilities_1.isVirtualElement; } }));
Object.defineProperty(exports, "labelProperties", ({ enumerable: true, get:
function () { return utilities_1.labelProperties; } }));
Object.defineProperty(exports, "liProperties", ({ enumerable: true, get: function
() { return utilities_1.liProperties; } }));
Object.defineProperty(exports, "mapEnumByName", ({ enumerable: true, get: function
() { return utilities_1.mapEnumByName; } }));
Object.defineProperty(exports, "memoize", ({ enumerable: true, get: function ()
{ return utilities_1.memoize; } }));
Object.defineProperty(exports, "memoizeFunction", ({ enumerable: true, get:
function () { return utilities_1.memoizeFunction; } }));
Object.defineProperty(exports, "merge", ({ enumerable: true, get: function ()
{ return utilities_1.merge; } }));
Object.defineProperty(exports, "mergeAriaAttributeValues", ({ enumerable: true,
get: function () { return utilities_1.mergeAriaAttributeValues; } }));
Object.defineProperty(exports, "mergeCustomizations", ({ enumerable: true, get:
function () { return utilities_1.mergeCustomizations; } }));
Object.defineProperty(exports, "mergeScopedSettings", ({ enumerable: true, get:
function () { return utilities_1.mergeScopedSettings; } }));
Object.defineProperty(exports, "mergeSettings", ({ enumerable: true, get: function
() { return utilities_1.mergeSettings; } }));
Object.defineProperty(exports, "modalize", ({ enumerable: true, get: function ()
{ return utilities_1.modalize; } }));
Object.defineProperty(exports, "nullRender", ({ enumerable: true, get: function ()
{ return utilities_1.nullRender; } }));
Object.defineProperty(exports, "olProperties", ({ enumerable: true, get: function
() { return utilities_1.olProperties; } }));
Object.defineProperty(exports, "omit", ({ enumerable: true, get: function ()
{ return utilities_1.omit; } }));
Object.defineProperty(exports, "on", ({ enumerable: true, get: function () { return
utilities_1.on; } }));
Object.defineProperty(exports, "optionProperties", ({ enumerable: true, get:
function () { return utilities_1.optionProperties; } }));
Object.defineProperty(exports, "portalContainsElement", ({ enumerable: true, get:
function () { return utilities_1.portalContainsElement; } }));
Object.defineProperty(exports, "precisionRound", ({ enumerable: true, get: function
() { return utilities_1.precisionRound; } }));
Object.defineProperty(exports, "raiseClick", ({ enumerable: true, get: function ()
{ return utilities_1.raiseClick; } }));
Object.defineProperty(exports, "removeIndex", ({ enumerable: true, get: function ()
{ return utilities_1.removeIndex; } }));
Object.defineProperty(exports, "replaceElement", ({ enumerable: true, get: function
() { return utilities_1.replaceElement; } }));
Object.defineProperty(exports, "resetControlledWarnings", ({ enumerable: true, get:
function () { return utilities_1.resetControlledWarnings; } }));
Object.defineProperty(exports, "resetIds", ({ enumerable: true, get: function ()
{ return utilities_1.resetIds; } }));
Object.defineProperty(exports, "resetMemoizations", ({ enumerable: true, get:
function () { return utilities_1.resetMemoizations; } }));
Object.defineProperty(exports, "safeRequestAnimationFrame", ({ enumerable: true,
get: function () { return utilities_1.safeRequestAnimationFrame; } }));
Object.defineProperty(exports, "safeSetTimeout", ({ enumerable: true, get: function
() { return utilities_1.safeSetTimeout; } }));
Object.defineProperty(exports, "selectProperties", ({ enumerable: true, get:
function () { return utilities_1.selectProperties; } }));
Object.defineProperty(exports, "setBaseUrl", ({ enumerable: true, get: function ()
{ return utilities_1.setBaseUrl; } }));
Object.defineProperty(exports, "setFocusVisibility", ({ enumerable: true, get:
function () { return utilities_1.setFocusVisibility; } }));
Object.defineProperty(exports, "setLanguage", ({ enumerable: true, get: function ()
{ return utilities_1.setLanguage; } }));
Object.defineProperty(exports, "setMemoizeWeakMap", ({ enumerable: true, get:
function () { return utilities_1.setMemoizeWeakMap; } }));
Object.defineProperty(exports, "setPortalAttribute", ({ enumerable: true, get:
function () { return utilities_1.setPortalAttribute; } }));
{ return utilities_1.setRTL; } }));
Object.defineProperty(exports, "setSSR", ({ enumerable: true, get: function ()
{ return utilities_1.setSSR; } }));
Object.defineProperty(exports, "setVirtualParent", ({ enumerable: true, get:
function () { return utilities_1.setVirtualParent; } }));
Object.defineProperty(exports, "setWarningCallback", ({ enumerable: true, get:
function () { return utilities_1.setWarningCallback; } }));
Object.defineProperty(exports, "shallowCompare", ({ enumerable: true, get: function
() { return utilities_1.shallowCompare; } }));
Object.defineProperty(exports, "shouldWrapFocus", ({ enumerable: true, get:
function () { return utilities_1.shouldWrapFocus; } }));
Object.defineProperty(exports, "styled", ({ enumerable: true, get: function ()
{ return utilities_1.styled; } }));
Object.defineProperty(exports, "tableProperties", ({ enumerable: true, get:
function () { return utilities_1.tableProperties; } }));
Object.defineProperty(exports, "tdProperties", ({ enumerable: true, get: function
() { return utilities_1.tdProperties; } }));
Object.defineProperty(exports, "textAreaProperties", ({ enumerable: true, get:
function () { return utilities_1.textAreaProperties; } }));
Object.defineProperty(exports, "thProperties", ({ enumerable: true, get: function
() { return utilities_1.thProperties; } }));
Object.defineProperty(exports, "toMatrix", ({ enumerable: true, get: function ()
{ return utilities_1.toMatrix; } }));
Object.defineProperty(exports, "trProperties", ({ enumerable: true, get: function
() { return utilities_1.trProperties; } }));
Object.defineProperty(exports, "unhoistMethods", ({ enumerable: true, get: function
() { return utilities_1.unhoistMethods; } }));
Object.defineProperty(exports, "useCustomizationSettings", ({ enumerable: true,
get: function () { return utilities_1.useCustomizationSettings; } }));
Object.defineProperty(exports, "useFocusRects", ({ enumerable: true, get: function
() { return utilities_1.useFocusRects; } }));
Object.defineProperty(exports, "values", ({ enumerable: true, get: function ()
{ return utilities_1.values; } }));
Object.defineProperty(exports, "videoProperties", ({ enumerable: true, get:
function () { return utilities_1.videoProperties; } }));
Object.defineProperty(exports, "warn", ({ enumerable: true, get: function ()
{ return utilities_1.warn; } }));
Object.defineProperty(exports, "warnConditionallyRequiredProps", ({ enumerable:
true, get: function () { return utilities_1.warnConditionallyRequiredProps; } }));
Object.defineProperty(exports, "warnControlledUsage", ({ enumerable: true, get:
function () { return utilities_1.warnControlledUsage; } }));
Object.defineProperty(exports, "warnDeprecations", ({ enumerable: true, get:
function () { return utilities_1.warnDeprecations; } }));
Object.defineProperty(exports, "warnMutuallyExclusive", ({ enumerable: true, get:
function () { return utilities_1.warnMutuallyExclusive; } }));
//# sourceMappingURL=Utilities.js.map
/***/ }),
/***/ 32898:
"use strict";

//# sourceMappingURL=WeeklyDayPicker.js.map
/***/ }),
/***/ 71189:
"use strict";

exports.useWindow = exports.useDocument = exports.WindowProvider =
exports.WindowContext = void 0;
Object.defineProperty(exports, "WindowContext", ({ enumerable: true, get: function
() { return react_window_provider_1.WindowContext; } }));
Object.defineProperty(exports, "WindowProvider", ({ enumerable: true, get: function
() { return react_window_provider_1.WindowProvider; } }));
Object.defineProperty(exports, "useDocument", ({ enumerable: true, get: function ()
{ return react_window_provider_1.useDocument; } }));
Object.defineProperty(exports, "useWindow", ({ enumerable: true, get: function () {
return react_window_provider_1.useWindow; } }));
//# sourceMappingURL=WindowProvider.js.map
/***/ }),
/***/ 83861:
"use strict";

exports.DirectionalHint = void 0;
exports.DirectionalHint = {
/**
* Appear above the target element, with the left edges of the callout and
target aligning.
*/
topLeftEdge: 0,
/**
* Appear above the target element, with the centers of the callout and target
aligning.
*/
topCenter: 1,
/**
* Appear above the target element, with the right edges of the callout and
target aligning.
*/
topRightEdge: 2,
/**
* Appear above the target element, aligning with the target element such that
the callout tends toward
* the center of the screen.
*/
topAutoEdge: 3,
/**
* Appear below the target element, with the left edges of the callout and
target aligning.
*/
bottomLeftEdge: 4,
/**
* Appear below the target element, with the centers of the callout and target
aligning.
*/
bottomCenter: 5,
/**
* Appear below the target element, with the right edges of the callout and
target aligning.
*/
bottomRightEdge: 6,
/**
* Appear below the target element, aligning with the target element such that
the callout tends toward
* the center of the screen.
*/
bottomAutoEdge: 7,
/**
* Appear to the left of the target element, with the top edges of the callout
and target aligning.
*/
leftTopEdge: 8,
/**
* Appear to the left of the target element, with the centers of the callout
*/
leftCenter: 9,
/**
* Appear to the left of the target element, with the bottom edges of the
callout and target aligning.
*/
leftBottomEdge: 10,
/**
* Appear to the right of the target element, with the top edges of the callout
*/
rightTopEdge: 11,
/**
* Appear to the right of the target element, with the centers of the callout
*/
rightCenter: 12,
/**
* Appear to the right of the target element, with the bottom edges of the
callout and target aligning.
*/
rightBottomEdge: 13,
};
//# sourceMappingURL=DirectionalHint.js.map
/***/ }),
/***/ 1553:
"use strict";

exports.getClassNames = void 0;
var Styling_1 = __webpack_require__(76891);
var Utilities_1 = __webpack_require__(56175);
exports.getClassNames = Utilities_1.memoizeFunction(function (styles, className,
activityPersonas, isCompact) {
return {
root: Styling_1.mergeStyles('ms-ActivityItem', className, styles.root,
isCompact && styles.isCompactRoot),
pulsingBeacon: Styling_1.mergeStyles('ms-ActivityItem-pulsingBeacon',
styles.pulsingBeacon),
personaContainer: Styling_1.mergeStyles('ms-ActivityItem-personaContainer',
styles.personaContainer, isCompact && styles.isCompactPersonaContainer),
activityPersona: Styling_1.mergeStyles('ms-ActivityItem-activityPersona',
styles.activityPersona, isCompact && styles.isCompactPersona, !isCompact &&
activityPersonas && activityPersonas.length === 2 && styles.doublePersona),
activityTypeIcon: Styling_1.mergeStyles('ms-ActivityItem-activityTypeIcon',
styles.activityTypeIcon, isCompact && styles.isCompactIcon),
activityContent: Styling_1.mergeStyles('ms-ActivityItem-activityContent',
styles.activityContent, isCompact && styles.isCompactContent),
activityText: Styling_1.mergeStyles('ms-ActivityItem-activityText',
styles.activityText),
commentText: Styling_1.mergeStyles('ms-ActivityItem-commentText',
styles.commentText),
timeStamp: Styling_1.mergeStyles('ms-ActivityItem-timeStamp',
styles.timeStamp, isCompact && styles.isCompactTimeStamp),
};
});
//# sourceMappingURL=ActivityItem.classNames.js.map
/***/ }),
/***/ 16217:
"use strict";

exports.ActivityItem = void 0;
var ActivityItem_classNames_1 = __webpack_require__(1553);
var ActivityItem_styles_1 = __webpack_require__(18068);
var Persona_1 = __webpack_require__(92650);
/**
* {@docCategory ActivityItem}
*/
var ActivityItem = /** @class */ (function (_super) {
tslib_1.__extends(ActivityItem, _super);
function ActivityItem(props) {
_this._onRenderIcon = function (props) {
if (props.activityPersonas) {
return _this._onRenderPersonaArray(props);
}
else {
return _this.props.activityIcon;
}
};
_this._onRenderActivityDescription = function (props) {
var classNames = _this._getClassNames(props);
var activityDescription = props.activityDescription ||
props.activityDescriptionText;
if (activityDescription) {
return React.createElement("span", { className:
classNames.activityText }, activityDescription);
}
return null;
};
_this._onRenderComments = function (props) {
var comments = props.comments || props.commentText;
if (!props.isCompact && comments) {
return React.createElement("div", { className:
classNames.commentText }, comments);
}
return null;
};
_this._onRenderTimeStamp = function (props) {
if (!props.isCompact && props.timeStamp) {
return React.createElement("div", { className: classNames.timeStamp
}, props.timeStamp);
}
return null;
};
// If activityPersonas is an array of persona props, build the persona
cluster element.
_this._onRenderPersonaArray = function (props) {
var personaElement = null;
var activityPersonas = props.activityPersonas;
if (activityPersonas[0].imageUrl || activityPersonas[0].imageInitials)
{
var personaList_1 = [];
var showSize16Personas_1 = activityPersonas.length > 1 ||
props.isCompact;
var personaLimit_1 = props.isCompact ? 3 : 4;
var style_1 = undefined;
if (props.isCompact) {
style_1 = {
display: 'inline-block',
width: '10px',
minWidth: '10px',
overflow: 'visible',
};
}
activityPersonas
.filter(function (person, index) { return index <
personaLimit_1; })
.forEach(function (person, index) {
personaList_1.push(React.createElement(Persona_1.PersonaCoin,
tslib_1.__assign({}, person, { key: person.key || index, className:
classNames.activityPersona,
size: showSize16Personas_1 ? Persona_1.PersonaSize.size16 :
Persona_1.PersonaSize.size32, style: style_1 })));
});
personaElement = React.createElement("div", { className:
classNames.personaContainer }, personaList_1);
}
return personaElement;
};
return _this;
}
ActivityItem.prototype.render = function () {
var _a = this.props, _b = _a.onRenderIcon, onRenderIcon = _b === void 0 ?
this._onRenderIcon : _b, _c = _a.onRenderActivityDescription,
onRenderActivityDescription = _c === void 0 ? this._onRenderActivityDescription :
_c, _d = _a.onRenderComments, onRenderComments = _d === void 0 ?
this._onRenderComments : _d, _e = _a.onRenderTimeStamp, onRenderTimeStamp = _e ===
void 0 ? this._onRenderTimeStamp : _e, animateBeaconSignal =
_a.animateBeaconSignal, isCompact = _a.isCompact;
var classNames = this._getClassNames(this.props);
return (React.createElement("div", { className: classNames.root, style:
this.props.style },
(this.props.activityPersonas || this.props.activityIcon ||
this.props.onRenderIcon) && (React.createElement("div", { className:
classNames.activityTypeIcon },
animateBeaconSignal && isCompact && React.createElement("div",
{ className: classNames.pulsingBeacon }),
onRenderIcon(this.props))),
React.createElement("div", { className: classNames.activityContent },
onRenderActivityDescription(this.props,
this._onRenderActivityDescription),
onRenderComments(this.props, this._onRenderComments),
onRenderTimeStamp(this.props, this._onRenderTimeStamp))));
};
ActivityItem.prototype._getClassNames = function (props) {
return
ActivityItem_classNames_1.getClassNames(ActivityItem_styles_1.getStyles(undefined,
props.styles, props.animateBeaconSignal, props.beaconColorOne,
props.beaconColorTwo, props.isCompact), props.className, props.activityPersonas,
props.isCompact);
};
return ActivityItem;
exports.ActivityItem = ActivityItem;
//# sourceMappingURL=ActivityItem.js.map
/***/ }),
/***/ 18068:
"use strict";

exports.getStyles = void 0;
var DEFAULT_PERSONA_SIZE = '32px';
var COMPACT_PERSONA_SIZE = '16px';
var DEFAULT_ICON_SIZE = '16px';
var COMPACT_ICON_SIZE = '13px';
var ANIMATION_INNER_DIMENSION = '4px';
var ANIMATION_OUTER_DIMENSION = '28px';
var ANIMATION_BORDER_WIDTH = '4px';
var fadeIn = Utilities_1.memoizeFunction(function () {
return Styling_1.keyframes({
from: { opacity: 0 },
to: { opacity: 1 },
});
});
var slideIn = Utilities_1.memoizeFunction(function () {
from: { transform: 'translateX(-10px)' },
to: { transform: 'translateX(0)' },
});
});
exports.getStyles = Utilities_1.memoizeFunction(function (theme, customStyles,
animateBeaconSignal, beaconColorOne, beaconColorTwo, isCompact) {
var _a;
if (theme === void 0) { theme = Styling_1.getTheme(); }
var continuousPulse =
Styling_1.PulsingBeaconAnimationStyles.continuousPulseAnimationSingle(beaconColorOn
e ? beaconColorOne : theme.palette.themePrimary, beaconColorTwo ? beaconColorTwo :
theme.palette.themeTertiary, ANIMATION_INNER_DIMENSION, ANIMATION_OUTER_DIMENSION,
ANIMATION_BORDER_WIDTH);
var continuousPulseAnimation = {
animationName: continuousPulse,
animationIterationCount: '1',
animationDuration: '.8s',
zIndex: 1,
};
var slideInAnimation = {
animationName: slideIn(),
};
var fadeInAnimation = {
animationName: fadeIn(),
};
var ActivityItemStyles = {
root: [
theme.fonts.small,
{
display: 'flex',
justifyContent: 'flex-start',
alignItems: 'flex-start',
boxSizing: 'border-box',
color: theme.palette.neutralSecondary,
},
isCompact && animateBeaconSignal && fadeInAnimation,
],
pulsingBeacon: [
{
position: 'absolute',
top: '50%',
left: '50%',
transform: 'translate(-50%, -50%)',
width: '0px',
height: '0px',
borderRadius: '225px',
borderStyle: 'solid',
opacity: 0,
},
isCompact && animateBeaconSignal && continuousPulseAnimation,
],
isCompactRoot: {
alignItems: 'center',
},
personaContainer: {
display: 'flex',
flexWrap: 'wrap',
minWidth: DEFAULT_PERSONA_SIZE,
width: DEFAULT_PERSONA_SIZE,
height: DEFAULT_PERSONA_SIZE,
},
isCompactPersonaContainer: {
display: 'inline-flex',
flexWrap: 'nowrap',
flexBasis: 'auto',
height: COMPACT_PERSONA_SIZE,
width: 'auto',
minWidth: '0',
paddingRight: '6px',
},
activityTypeIcon: {
height: DEFAULT_PERSONA_SIZE,
fontSize: DEFAULT_ICON_SIZE,
lineHeight: DEFAULT_ICON_SIZE,
marginTop: '3px',
},
isCompactIcon: {
height: COMPACT_PERSONA_SIZE,
minWidth: COMPACT_PERSONA_SIZE,
fontSize: COMPACT_ICON_SIZE,
lineHeight: COMPACT_ICON_SIZE,
color: theme.palette.themePrimary,
marginTop: '1px',
position: 'relative',
display: 'flex',
justifyContent: 'center',
selectors: {
'.ms-Persona-imageArea': {
margin: '-2px 0 0 -2px',
border: '2px solid' + theme.palette.white,
borderRadius: '50%',
selectors: (_a = {},
_a[Styling_1.HighContrastSelector] = {
border: 'none',
margin: '0',
},
_a),
},
},
},
activityPersona: {
display: 'block',
},
doublePersona: {
selectors: {
':first-child': {
alignSelf: 'flex-end',
},
},
},
isCompactPersona: {
width: '8px',
minWidth: '8px',
},
activityContent: [
{
padding: '0 8px',
},
isCompact && animateBeaconSignal && slideInAnimation,
],
activityText: {
display: 'inline',
},
isCompactContent: {
flex: '1',
padding: '0 4px',
whiteSpace: 'nowrap',
textOverflow: 'ellipsis',
overflowX: 'hidden',
},
commentText: {
color: theme.palette.neutralPrimary,
},
timeStamp: [
theme.fonts.tiny,
{
fontWeight: 400,
},
],
isCompactTimeStamp: {
paddingLeft: '0.3em',
fontSize: '1em',
},
};
return Styling_1.concatStyleSets(ActivityItemStyles, customStyles);
});
//# sourceMappingURL=ActivityItem.styles.js.map
/***/ }),
/***/ 95772:
"use strict";

//# sourceMappingURL=ActivityItem.types.js.map
/***/ }),
/***/ 87654:
"use strict";

/***/ }),
/***/ 81576:
"use strict";

exports.AnnouncedBase = void 0;
var getClassNames = Utilities_1.classNamesFunction();
/**
* {@docCategory Announced}
*/
var AnnouncedBase = /** @class */ (function (_super) {
tslib_1.__extends(AnnouncedBase, _super);
function AnnouncedBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
AnnouncedBase.prototype.render = function () {
var _a = this.props, message = _a.message, styles = _a.styles, _b = _a.as,
Root = _b === void 0 ? 'div' : _b, className = _a.className;
var classNames = getClassNames(styles, { className: className });
return (React.createElement(Root, tslib_1.__assign({ role: "status",
className: classNames.root }, Utilities_1.getNativeProps(this.props,
Utilities_1.divProperties, ['className'])),
React.createElement(Utilities_1.DelayedRender, null,
React.createElement("div", { className: classNames.screenReaderText
}, message))));
};
AnnouncedBase.defaultProps = {
'aria-live': 'polite',
};
return AnnouncedBase;
exports.AnnouncedBase = AnnouncedBase;
//# sourceMappingURL=Announced.base.js.map
/***/ }),
/***/ 7132:
"use strict";

exports.Announced = void 0;
var Announced_base_1 = __webpack_require__(81576);
var Announced_styles_1 = __webpack_require__(6217);
exports.Announced = Utilities_1.styled(Announced_base_1.AnnouncedBase,
Announced_styles_1.getStyles);
//# sourceMappingURL=Announced.js.map
/***/ }),
/***/ 6217:
"use strict";

var getStyles = function (props) {
return {
root: props.className,
screenReaderText: Styling_1.hiddenContentStyle,
};
};
exports.getStyles = getStyles;
//# sourceMappingURL=Announced.styles.js.map
/***/ }),
/***/ 63120:
"use strict";

//# sourceMappingURL=Announced.types.js.map
/***/ }),
/***/ 80627:
"use strict";

/***/ }),
/***/ 53912:
"use strict";

exports.Autofill = void 0;
var SELECTION_FORWARD = 'forward';
var SELECTION_BACKWARD = 'backward';
/**
* {@docCategory Autofill}
*/
var Autofill = /** @class */ (function (_super) {
tslib_1.__extends(Autofill, _super);
function Autofill(props) {
_this._inputElement = React.createRef();
_this._autoFillEnabled = true;
// Composition events are used when the character/text requires several
keystrokes to be completed.
// Some examples of this are mobile text input and languages like Japanese
or Arabic.
// Find out more at
https://developer.mozilla.org/en-US/docs/Web/Events/compositionstart
_this._onCompositionStart = function (ev) {
_this.setState({ isComposing: true });
_this._autoFillEnabled = false;
};
or Arabic.
// Find out more at
_this._onCompositionUpdate = function () {
if (Utilities_1.isIE11()) {
_this._updateValue(_this._getCurrentInputValue(), true);
}
};
or Arabic.
// Find out more at
_this._onCompositionEnd = function (ev) {
var inputValue = _this._getCurrentInputValue();
_this._tryEnableAutofill(inputValue, _this.value, false, true);
_this.setState({ isComposing: false });
// Due to timing, this needs to be async, otherwise no text will be
selected.
_this._async.setTimeout(function () {
// it's technically possible that the value of isComposing is reset
during this timeout,
// so explicitly trigger this with composing=true here, since it is
supposed to be the
// update for composition end
_this._updateValue(_this._getCurrentInputValue(), false);
}, 0);
};
_this._onClick = function () {
if (_this.value && _this.value !== '' && _this._autoFillEnabled) {
}
};
_this._onKeyDown = function (ev) {
}
// If the event is actively being composed, then don't alert autofill.
// Right now typing does not have isComposing, once that has been fixed
any should be removed.
if (!ev.nativeEvent.isComposing) {
switch (ev.which) {
case Utilities_1.KeyCodes.backspace:
break;
case Utilities_1.KeyCodes.left:
case Utilities_1.KeyCodes.right:
if (_this._autoFillEnabled) {
_this.setState({ inputValue:
_this.props.suggestedDisplayValue || '' });
}
break;
default:
if (!_this._autoFillEnabled) {
if
(_this.props.enableAutofillOnKeyPress.indexOf(ev.which) !== -1) {
_this._autoFillEnabled = true;
}
}
break;
}
}
};
_this._onInputChanged = function (ev) {
var value = _this._getCurrentInputValue(ev);
if (!_this.state.isComposing) {
_this._tryEnableAutofill(value, _this.value,
ev.nativeEvent.isComposing);
}
// If it is not IE11 and currently composing, update the value
if (!(Utilities_1.isIE11() && _this.state.isComposing)) {
var nativeEventComposing = ev.nativeEvent.isComposing;
var isComposing = nativeEventComposing === undefined ?
_this.state.isComposing : nativeEventComposing;
_this._updateValue(value, isComposing);
}
};
_this._onChanged = function () {
// Swallow this event, we don't care about it
// We must provide it because React PropTypes marks it as required, but
onInput serves the correct purpose
return;
};
/**
* Updates the current input value as well as getting a new display value.
* @param newValue - The new value from the input
*/
_this._updateValue = function (newValue, composing) {
// Only proceed if the value is nonempty and is different from the old
value
// This is to work around the fact that, in IE 11, inputs with a
placeholder fire an onInput event on focus
if (!newValue && newValue === _this.value) {
return;
}
var _a = _this.props, onInputChange = _a.onInputChange,
onInputValueChange = _a.onInputValueChange;
if (onInputChange) {
newValue = (onInputChange === null || onInputChange === void 0 ?
void 0 : onInputChange(newValue, composing)) || '';
}
_this.setState({ inputValue: newValue }, function () { return
onInputValueChange === null || onInputValueChange === void 0 ? void 0 :
onInputValueChange(newValue, composing); });
};
Utilities_1.initializeComponentRef(_this);
_this._async = new Utilities_1.Async(_this);
_this.state = {
inputValue: props.defaultVisibleValue || '',
isComposing: false,
};
return _this;
}
Autofill.getDerivedStateFromProps = function (props, state) {
if (props.updateValueInWillReceiveProps) {
var updatedInputValue = props.updateValueInWillReceiveProps();
// Don't update if we have a null value or the value isn't changing
// the value should still update if an empty string is passed in
if (updatedInputValue !== null && updatedInputValue !==
state.inputValue && !state.isComposing) {
return tslib_1.__assign(tslib_1.__assign({}, state), { inputValue:
updatedInputValue });
}
}
return null;
};
Object.defineProperty(Autofill.prototype, "cursorLocation", {
get: function () {
if (this._inputElement.current) {
var inputElement = this._inputElement.current;
if (inputElement.selectionDirection !== SELECTION_FORWARD) {
return inputElement.selectionEnd;
}
else {
return inputElement.selectionStart;
}
}
else {
return -1;
}
},
enumerable: false,
configurable: true
});
Object.defineProperty(Autofill.prototype, "isValueSelected", {
get: function () {
return Boolean(this.inputElement && this.inputElement.selectionStart !
== this.inputElement.selectionEnd);
},
enumerable: false,
configurable: true
});
Object.defineProperty(Autofill.prototype, "value", {
get: function () {
return this._getControlledValue() || this.state.inputValue || '';
},
enumerable: false,
configurable: true
});
Object.defineProperty(Autofill.prototype, "selectionStart", {
get: function () {
return this._inputElement.current ?
this._inputElement.current.selectionStart : -1;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Autofill.prototype, "selectionEnd", {
get: function () {
return this._inputElement.current ?
this._inputElement.current.selectionEnd : -1;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Autofill.prototype, "inputElement", {
get: function () {
return this._inputElement.current;
},
enumerable: false,
configurable: true
});
Autofill.prototype.componentDidUpdate = function (_, _1, cursor) {
var _a = this.props, suggestedDisplayValue = _a.suggestedDisplayValue,
shouldSelectFullInputValueInComponentDidUpdate =
_a.shouldSelectFullInputValueInComponentDidUpdate, preventValueSelection =
_a.preventValueSelection;
var differenceIndex = 0;
if (preventValueSelection) {
return;
}
if (this._autoFillEnabled &&
this.value &&
suggestedDisplayValue &&
_doesTextStartWith(suggestedDisplayValue, this.value)) {
var shouldSelectFullRange = false;
if (shouldSelectFullInputValueInComponentDidUpdate) {
shouldSelectFullRange =
shouldSelectFullInputValueInComponentDidUpdate();
}
if (shouldSelectFullRange && this._inputElement.current) {
this._inputElement.current.setSelectionRange(0,
suggestedDisplayValue.length, SELECTION_BACKWARD);
}
else {
while (differenceIndex < this.value.length &&
this.value[differenceIndex].toLocaleLowerCase() ===
suggestedDisplayValue[differenceIndex].toLocaleLowerCase()) {
differenceIndex++;
}
if (differenceIndex > 0 && this._inputElement.current) {
this._inputElement.current.setSelectionRange(differenceIndex,
suggestedDisplayValue.length, SELECTION_BACKWARD);
}
}
}
else if (this._inputElement.current) {
if (cursor !== null && !this._autoFillEnabled && !
this.state.isComposing) {
this._inputElement.current.setSelectionRange(cursor.start,
cursor.end, cursor.dir);
}
}
};
Autofill.prototype.componentWillUnmount = function () {
this._async.dispose();
};
Autofill.prototype.render = function () {
var nativeProps = Utilities_1.getNativeProps(this.props,
Utilities_1.inputProperties);
var style = tslib_1.__assign(tslib_1.__assign({}, this.props.style),
{ fontFamily: 'inherit' });
return (React.createElement("input", tslib_1.__assign({ autoCapitalize:
"off", autoComplete: "off", "aria-autocomplete": 'both' }, nativeProps, { style:
style, ref: this._inputElement, value: this._getDisplayValue(), onCompositionStart:
this._onCompositionStart, onCompositionUpdate: this._onCompositionUpdate,
onCompositionEnd: this._onCompositionEnd,
// TODO (Fabric 8?) - switch to calling only onChange. See notes in
TextField._onInputChange.
onChange: this._onChanged, onInput: this._onInputChanged, onKeyDown:
this._onKeyDown, onClick: this.props.onClick ? this.props.onClick : this._onClick,
"data-lpignore": true })));
};
Autofill.prototype.focus = function () {
this._inputElement.current && this._inputElement.current.focus();
};
Autofill.prototype.clear = function () {
this._autoFillEnabled = true;
this._updateValue('', false);
this._inputElement.current &&
this._inputElement.current.setSelectionRange(0, 0);
};
Autofill.prototype.getSnapshotBeforeUpdate = function () {
var _a, _b;
var inel = this._inputElement.current;
if (inel && inel.selectionStart !== this.value.length) {
return {
start: (_a = inel.selectionStart) !== null && _a !== void 0 ? _a :
inel.value.length,
end: (_b = inel.selectionEnd) !== null && _b !== void 0 ? _b :
inel.value.length,
dir: inel.selectionDirection || 'backward' || 0,
};
}
return null;
};
Autofill.prototype._getCurrentInputValue = function (ev) {
if (ev && ev.target && ev.target.value) {
return ev.target.value;
}
else if (this.inputElement && this.inputElement.value) {
return this.inputElement.value;
}
else {
return '';
}
};
/**
* Attempts to enable autofill. Whether or not autofill is enabled depends on
the input value,
* whether or not any text is selected, and only if the new input value is
longer than the old input value.
* Autofill should never be set to true if the value is composing. Once
compositionEnd is called, then
* it should be completed.
* See https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent for
more information on composition.
* @param newValue - new input value
* @param oldValue - old input value
* @param isComposing - if true then the text is actively being composed and it
has not completed.
* @param isComposed - if the text is a composed text value.
*/
Autofill.prototype._tryEnableAutofill = function (newValue, oldValue,
isComposing, isComposed) {
if (!isComposing &&
newValue &&
this._inputElement.current &&
this._inputElement.current.selectionStart === newValue.length &&
!this._autoFillEnabled &&
(newValue.length > oldValue.length || isComposed)) {
this._autoFillEnabled = true;
}
};
Autofill.prototype._getDisplayValue = function () {
if (this._autoFillEnabled) {
return _getDisplayValue(this.value, this.props.suggestedDisplayValue);
}
return this.value;
};
Autofill.prototype._getControlledValue = function () {
var value = this.props.value;
if (value === undefined || typeof value === 'string') {
return value;
}
// eslint-disable-next-line no-console
console.warn("props.value of Autofill should be a string, but it is " +
value + " with type of " + typeof value);
return value.toString();
};
Autofill.defaultProps = {
enableAutofillOnKeyPress: [Utilities_1.KeyCodes.down,
Utilities_1.KeyCodes.up],
};
return Autofill;
exports.Autofill = Autofill;
/**
* Returns a string that should be used as the display value.
* It evaluates this based on whether or not the suggested value starts with the
input value
* and whether or not autofill is enabled.
* @param inputValue - the value that the input currently has.
* @param suggestedDisplayValue - the possible full value
*/
function _getDisplayValue(inputValue, suggestedDisplayValue) {
var displayValue = inputValue;
if (suggestedDisplayValue && inputValue &&
_doesTextStartWith(suggestedDisplayValue, displayValue)) {
displayValue = suggestedDisplayValue;
}
return displayValue;
}
function _doesTextStartWith(text, startWith) {
if (!text || !startWith) {
return false;
}
if (false) { var val, _i, _a; }
return text.toLocaleLowerCase().indexOf(startWith.toLocaleLowerCase()) === 0;
}
//# sourceMappingURL=Autofill.js.map
/***/ }),
/***/ 98354:
"use strict";
//# sourceMappingURL=Autofill.types.js.map
/***/ }),
/***/ 96425:
"use strict";

/***/ }),
/***/ 49816:
"use strict";

exports.BreadcrumbBase = void 0;
var FocusZone_1 = __webpack_require__(6171);
var Link_1 = __webpack_require__(66023);
var Icon_1 = __webpack_require__(84819);
var Button_1 = __webpack_require__(36835);
var DirectionalHint_1 = __webpack_require__(83861);
var ResizeGroup_1 = __webpack_require__(93418);
var Tooltip_1 = __webpack_require__(91481);
var OVERFLOW_KEY = 'overflow';
var nullFunction = function () { return null; };
var nonActionableItemProps = {
styles: function (props) {
var theme = props.theme;
return {
root: {
selectors: {
'&.is-disabled': {
color: theme.semanticColors.bodyText,
},
},
},
};
},
};
/**
* {@docCategory Breadcrumb}
*/
var BreadcrumbBase = /** @class */ (function (_super) {
tslib_1.__extends(BreadcrumbBase, _super);
function BreadcrumbBase(props) {
_this._focusZone = React.createRef();
/**
* Remove the first rendered item past the overlow point and put it and the
end the overflow set.
*/
_this._onReduceData = function (data) {
var renderedItems = data.renderedItems, renderedOverflowItems =
data.renderedOverflowItems;
var overflowIndex = data.props.overflowIndex;
var movedItem = renderedItems[overflowIndex];
if (!movedItem) {
return undefined;
}
renderedItems = tslib_1.__spreadArray([], renderedItems);
renderedItems.splice(overflowIndex, 1);
renderedOverflowItems = tslib_1.__spreadArray(tslib_1.__spreadArray([],
renderedOverflowItems), [movedItem]);
return tslib_1.__assign(tslib_1.__assign({}, data), { renderedItems:
renderedItems, renderedOverflowItems: renderedOverflowItems });
};
/**
* Remove the last item of the overflow set and insert the item as the
start of the rendered set past the overflow
* point.
*/
_this._onGrowData = function (data) {
var renderedItems = data.renderedItems, renderedOverflowItems =
data.renderedOverflowItems;
var _a = data.props, overflowIndex = _a.overflowIndex,
maxDisplayedItems = _a.maxDisplayedItems;
renderedOverflowItems = tslib_1.__spreadArray([],
renderedOverflowItems);
var movedItem = renderedOverflowItems.pop();
if (!movedItem || renderedItems.length >= maxDisplayedItems) {
return undefined;
}
renderedItems = tslib_1.__spreadArray([], renderedItems);
renderedItems.splice(overflowIndex, 0, movedItem);
return tslib_1.__assign(tslib_1.__assign({}, data), { renderedItems:
renderedItems, renderedOverflowItems: renderedOverflowItems });
};
_this._onRenderBreadcrumb = function (data) {
var _a = data.props, ariaLabel = _a.ariaLabel, _b = _a.dividerAs,
DividerType = _b === void 0 ? Icon_1.Icon : _b, onRenderItem = _a.onRenderItem,
overflowAriaLabel = _a.overflowAriaLabel, overflowIndex = _a.overflowIndex,
onRenderOverflowIcon = _a.onRenderOverflowIcon, overflowButtonAs =
_a.overflowButtonAs;
var renderedOverflowItems = data.renderedOverflowItems, renderedItems =
data.renderedItems;
var contextualItems = renderedOverflowItems.map(function (item) {
var isActionable = !!(item.onClick || item.href);
return {
text: item.text,
name: item.text,
key: item.key,
onClick: item.onClick ? _this._onBreadcrumbClicked.bind(_this,
item) : null,
href: item.href,
disabled: !isActionable,
itemProps: isActionable ? undefined : nonActionableItemProps,
};
});
// Find index of last rendered item so the divider icon
// knows not to render on that item
var lastItemIndex = renderedItems.length - 1;
var hasOverflowItems = renderedOverflowItems &&
renderedOverflowItems.length !== 0;
var itemElements = renderedItems.map(function (item, index) {
var finalOnRenderItem = _this._onRenderItem;
if (item.onRender) {
finalOnRenderItem =
Utilities_2.composeRenderFunction(item.onRender, finalOnRenderItem);
}
if (onRenderItem) {
finalOnRenderItem =
Utilities_2.composeRenderFunction(onRenderItem, finalOnRenderItem);
}
return (React.createElement("li", { className:
_this._classNames.listItem, key: item.key || String(index) },
finalOnRenderItem(item),
(index !== lastItemIndex || (hasOverflowItems && index ===
overflowIndex - 1)) && (React.createElement(DividerType, { className:
_this._classNames.chevron, iconName: Utilities_1.getRTL(_this.props.theme) ?
'ChevronLeft' : 'ChevronRight', item: item }))));
});
if (hasOverflowItems) {
var iconProps = !onRenderOverflowIcon ? { iconName: 'More' } : {};
var onRenderMenuIcon = onRenderOverflowIcon ?
onRenderOverflowIcon : nullFunction;
var OverflowButton = overflowButtonAs ? overflowButtonAs :
Button_1.IconButton;
itemElements.splice(overflowIndex, 0, React.createElement("li",
{ className: _this._classNames.overflow, key: OVERFLOW_KEY },
React.createElement(OverflowButton, { className:
_this._classNames.overflowButton, iconProps: iconProps, role: "button", "aria-
haspopup": "true", ariaLabel: overflowAriaLabel, onRenderMenuIcon:
onRenderMenuIcon, menuProps: {
items: contextualItems,
directionalHint:
DirectionalHint_1.DirectionalHint.bottomLeftEdge,
} }),
overflowIndex !== lastItemIndex + 1 &&
(React.createElement(DividerType, { className: _this._classNames.chevron, iconName:
Utilities_1.getRTL(_this.props.theme) ? 'ChevronLeft' : 'ChevronRight', item:
renderedOverflowItems[renderedOverflowItems.length - 1] }))));
}
var nativeProps = Utilities_1.getNativeProps(_this.props,
Utilities_1.htmlElementProperties, [
'className',
]);
return (React.createElement("div", tslib_1.__assign({ className:
_this._classNames.root, role: "navigation", "aria-label": ariaLabel },
nativeProps),
React.createElement(FocusZone_1.FocusZone,
tslib_1.__assign({ componentRef: _this._focusZone, direction:
FocusZone_1.FocusZoneDirection.horizontal }, _this.props.focusZoneProps),
React.createElement("ol", { className:
_this._classNames.list }, itemElements))));
};
_this._onRenderItem = function (item) {
if (!item) {
return null;
}
var as = item.as, href = item.href, onClick = item.onClick,
isCurrentItem = item.isCurrentItem, text = item.text, onRenderContent =
item.onRenderContent, additionalProps = tslib_1.__rest(item, ["as", "href",
"onClick", "isCurrentItem", "text", "onRenderContent"]);
var finalOnRenderContent = defaultOnRenderCrumbContent;
if (onRenderContent) {
finalOnRenderContent =
Utilities_2.composeRenderFunction(onRenderContent, finalOnRenderContent);
}
if (_this.props.onRenderItemContent) {
finalOnRenderContent =
Utilities_2.composeRenderFunction(_this.props.onRenderItemContent,
finalOnRenderContent);
}
if (onClick || href) {
return (React.createElement(Link_1.Link, tslib_1.__assign({},
additionalProps, { as: as, className: _this._classNames.itemLink, href: href,
"aria-current": isCurrentItem ? 'page' : undefined,
onClick: _this._onBreadcrumbClicked.bind(_this, item) }),
React.createElement(Tooltip_1.TooltipHost,
tslib_1.__assign({ content: text, overflowMode:
Tooltip_1.TooltipOverflowMode.Parent }, _this.props.tooltipHostProps),
finalOnRenderContent(item))));
}
else {
var Tag = as || 'span';
return (React.createElement(Tag, tslib_1.__assign({},
additionalProps, { className: _this._classNames.item }),
tslib_1.__assign({ content: text, overflowMode:
Tooltip_1.TooltipOverflowMode.Parent }, _this.props.tooltipHostProps),
finalOnRenderContent(item))));
}
};
_this._onBreadcrumbClicked = function (item, ev) {
if (item.onClick) {
item.onClick(ev, item);
}
};
_this._validateProps(props);
return _this;
}
/**
* Sets focus to the first breadcrumb link.
*/
BreadcrumbBase.prototype.focus = function () {
if (this._focusZone.current) {
this._focusZone.current.focus();
}
};
BreadcrumbBase.prototype.render = function () {
this._validateProps(this.props);
var _a = this.props, _b = _a.onReduceData, onReduceData = _b === void 0 ?
this._onReduceData : _b, _c = _a.onGrowData, onGrowData = _c === void 0 ?
this._onGrowData : _c, overflowIndex = _a.overflowIndex, maxDisplayedItems =
_a.maxDisplayedItems, items = _a.items, className = _a.className, theme = _a.theme,
styles = _a.styles;
var renderedItems = tslib_1.__spreadArray([], items);
var renderedOverflowItems = renderedItems.splice(overflowIndex,
renderedItems.length - maxDisplayedItems);
var breadcrumbData = {
props: this.props,
renderedItems: renderedItems,
renderedOverflowItems: renderedOverflowItems,
};
this._classNames = getClassNames(styles, {
className: className,
theme: theme,
});
return (React.createElement(ResizeGroup_1.ResizeGroup, { onRenderData:
this._onRenderBreadcrumb, onReduceData: onReduceData, onGrowData: onGrowData, data:
breadcrumbData }));
};
/**
* Validate incoming props
* @param props - Props to validate
*/
BreadcrumbBase.prototype._validateProps = function (props) {
var maxDisplayedItems = props.maxDisplayedItems, overflowIndex =
props.overflowIndex, items = props.items;
if (overflowIndex < 0 ||
(maxDisplayedItems > 1 && overflowIndex > maxDisplayedItems - 1) ||
(items.length > 0 && overflowIndex > items.length - 1)) {
throw new Error('Breadcrumb: overflowIndex out of range');
}
};
BreadcrumbBase.defaultProps = {
items: [],
maxDisplayedItems: 999,
overflowIndex: 0,
};
return BreadcrumbBase;
exports.BreadcrumbBase = BreadcrumbBase;
function defaultOnRenderCrumbContent(item) {
return item ? React.createElement(React.Fragment, null, item.text) : null;
}
//# sourceMappingURL=Breadcrumb.base.js.map
/***/ }),
/***/ 41646:
"use strict";

exports.Breadcrumb = void 0;
var Breadcrumb_base_1 = __webpack_require__(49816);
var Breadcrumb_styles_1 = __webpack_require__(86094);
exports.Breadcrumb = Utilities_1.styled(Breadcrumb_base_1.BreadcrumbBase,
Breadcrumb_styles_1.getStyles, undefined, { scope: 'Breadcrumb' });
//# sourceMappingURL=Breadcrumb.js.map
/***/ }),
/***/ 86094:
"use strict";

var GlobalClassNames = {
root: 'ms-Breadcrumb',
list: 'ms-Breadcrumb-list',
listItem: 'ms-Breadcrumb-listItem',
chevron: 'ms-Breadcrumb-chevron',
overflow: 'ms-Breadcrumb-overflow',
overflowButton: 'ms-Breadcrumb-overflowButton',
itemLink: 'ms-Breadcrumb-itemLink',
item: 'ms-Breadcrumb-item',
};
var SingleLineTextStyle = {
overflow: 'hidden',
};
var overflowButtonFontSize = 16;
var chevronSmallFontSize = 8;
var itemLineHeight = 36;
var itemFontSize = 18;
var MinimumScreenSelector = Styling_1.getScreenSelector(0,
Styling_1.ScreenWidthMaxSmall);
var MediumScreenSelector =
Styling_1.getScreenSelector(Styling_1.ScreenWidthMinMedium,
Styling_1.ScreenWidthMaxMedium);
var _a, _b, _c, _d, _e;
var className = props.className, theme = props.theme;
var palette = theme.palette, semanticColors = theme.semanticColors, fonts =
theme.fonts;
var classNames = Styling_1.getGlobalClassNames(GlobalClassNames, theme);
// Tokens
var itemBackgroundHoveredColor = semanticColors.menuItemBackgroundHovered;
var itemBackgroundPressedColor = semanticColors.menuItemBackgroundPressed;
var itemTextColor = palette.neutralSecondary;
var itemTextFontWeight = Styling_1.FontWeights.regular;
var itemTextHoveredOrPressedColor = palette.neutralPrimary;
var itemLastChildTextColor = palette.neutralPrimary;
var itemLastChildTextFontWeight = Styling_1.FontWeights.semibold;
var chevronButtonColor = palette.neutralSecondary;
var overflowButtonColor = palette.neutralSecondary;
var lastChildItemStyles = {
fontWeight: itemLastChildTextFontWeight,
color: itemLastChildTextColor,
};
var itemStateSelectors = {
':hover': {
color: itemTextHoveredOrPressedColor,
backgroundColor: itemBackgroundHoveredColor,
cursor: 'pointer',
color: 'Highlight',
backgroundColor: 'transparent',
},
_a),
},
':active': {
backgroundColor: itemBackgroundPressedColor,
},
'&:active:hover': {
backgroundColor: itemBackgroundPressedColor,
},
'&:active, &:hover, &:active:hover': {
textDecoration: 'none',
},
};
var commonItemStyles = {
color: itemTextColor,
padding: '0 8px',
lineHeight: itemLineHeight,
fontSize: itemFontSize,
fontWeight: itemTextFontWeight,
};
return {
root: [
classNames.root,
fonts.medium,
{
margin: '11px 0 1px',
},
className,
],
list: [
classNames.list,
{
padding: 0,
margin: 0,
display: 'flex',
alignItems: 'stretch',
},
],
listItem: [
classNames.listItem,
{
listStyleType: 'none',
margin: '0',
padding: '0',
display: 'flex',
selectors: {
'&:last-child .ms-Breadcrumb-itemLink':
tslib_1.__assign(tslib_1.__assign({}, lastChildItemStyles), (_b = {},
_b[Styling_1.HighContrastSelector] = {
MsHighContrastAdjust: 'auto',
forcedColorAdjust: 'auto',
}, _b)),
'&:last-child .ms-Breadcrumb-item': lastChildItemStyles,
},
},
],
chevron: [
classNames.chevron,
{
color: chevronButtonColor,
fontSize: fonts.small.fontSize,
selectors: (_c = {},
_c[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'WindowText' }, Styling_1.getHighContrastNoAdjustStyle()),
_c[MediumScreenSelector] = {
fontSize: chevronSmallFontSize,
},
_c[MinimumScreenSelector] = {
fontSize: chevronSmallFontSize,
},
_c),
},
],
overflow: [
classNames.overflow,
{
display: 'flex',
},
],
overflowButton: [
classNames.overflowButton,
Styling_1.getFocusStyle(theme),
SingleLineTextStyle,
{
fontSize: overflowButtonFontSize,
color: overflowButtonColor,
height: '100%',
cursor: 'pointer',
selectors: tslib_1.__assign(tslib_1.__assign({},
itemStateSelectors), (_d = {}, _d[MinimumScreenSelector] = {
padding: '4px 6px',
}, _d[MediumScreenSelector] = {
fontSize: fonts.mediumPlus.fontSize,
}, _d)),
},
],
itemLink: [
classNames.itemLink,
SingleLineTextStyle,
tslib_1.__assign(tslib_1.__assign({}, commonItemStyles), { selectors:
tslib_1.__assign((_e = { ':focus': {
color: palette.neutralDark,
} }, _e["." + Utilities_1.IsFocusVisibleClassName + "
&:focus"] = {
outline: "none",
}, _e), itemStateSelectors) }),
],
item: [
classNames.item,
tslib_1.__assign(tslib_1.__assign({}, commonItemStyles), { selectors: {
':hover': {
cursor: 'default',
},
} }),
],
};
};
//# sourceMappingURL=Breadcrumb.styles.js.map
/***/ }),
/***/ 61467:
"use strict";

//# sourceMappingURL=Breadcrumb.types.js.map
/***/ }),
/***/ 80972:
"use strict";

/***/ }),
/***/ 67176:
"use strict";

exports.ActionButton = void 0;
var BaseButton_1 = __webpack_require__(46993);
var ActionButton_styles_1 = __webpack_require__(40731);
/**
* {@docCategory Button}
*/
var ActionButton = /** @class */ (function (_super) {
tslib_1.__extends(ActionButton, _super);
function ActionButton() {
}
ActionButton.prototype.render = function () {
var _a = this.props, styles = _a.styles, theme = _a.theme;
return (React.createElement(BaseButton_1.BaseButton, tslib_1.__assign({},
this.props, { variantClassName: "ms-Button--action ms-Button--command", styles:
ActionButton_styles_1.getStyles(theme, styles), onRenderDescription:
Utilities_1.nullRender })));
};
ActionButton = tslib_1.__decorate([
Utilities_1.customizable('ActionButton', ['theme', 'styles'], true)
], ActionButton);
return ActionButton;
exports.ActionButton = ActionButton;
//# sourceMappingURL=ActionButton.js.map
/***/ }),
/***/ 40731:
"use strict";

var BaseButton_styles_1 = __webpack_require__(51100);
var DEFAULT_BUTTON_HEIGHT = '40px';
var DEFAULT_PADDING = '0 4px';
exports.getStyles = Utilities_1.memoizeFunction(function (theme, customStyles) {
var _a, _b, _c;
var baseButtonStyles = BaseButton_styles_1.getStyles(theme);
var actionButtonStyles = {
root: {
padding: DEFAULT_PADDING,
height: DEFAULT_BUTTON_HEIGHT,
border: '1px solid transparent',
borderColor: 'Window',
},
_a),
},
rootHovered: {
selectors: (_b = {},
color: 'Highlight',
},
_b),
},
iconHovered: {
},
rootPressed: {
color: theme.palette.black,
},
rootExpanded: {
},
iconPressed: {
color: theme.palette.themeDarker,
},
rootDisabled: {
color: theme.palette.neutralTertiary,
borderColor: 'transparent',
_c[Styling_1.HighContrastSelector] = {
color: 'GrayText',
},
_c),
},
rootChecked: {
color: theme.palette.black,
},
iconChecked: {
color: theme.palette.themeDarker,
},
flexContainer: {
justifyContent: 'flex-start',
},
icon: {
color: theme.palette.themeDarkAlt,
},
iconDisabled: {
color: 'inherit',
},
menuIcon: {
},
textContainer: {
flexGrow: 0,
},
};
return Styling_1.concatStyleSets(baseButtonStyles, actionButtonStyles,
customStyles);
});
//# sourceMappingURL=ActionButton.styles.js.map
/***/ }),
/***/ 55650:
"use strict";
exports.getBaseButtonClassNames = exports.ButtonGlobalClassNames = void 0;
exports.ButtonGlobalClassNames = {
msButton: 'ms-Button',
msButtonHasMenu: 'ms-Button--hasMenu',
msButtonIcon: 'ms-Button-icon',
msButtonMenuIcon: 'ms-Button-menuIcon',
msButtonLabel: 'ms-Button-label',
msButtonDescription: 'ms-Button-description',
msButtonScreenReaderText: 'ms-Button-screenReaderText',
msButtonFlexContainer: 'ms-Button-flexContainer',
msButtonTextContainer: 'ms-Button-textContainer',
};
exports.getBaseButtonClassNames = Utilities_1.memoizeFunction(function (theme,
styles, className, variantClassName, iconClassName, menuIconClassName, disabled,
hasMenu, checked, expanded, isSplit) {
var _a, _b;
var classNames = Styling_1.getGlobalClassNames(exports.ButtonGlobalClassNames,
theme || {});
var isExpanded = expanded && !isSplit;
return Styling_1.mergeStyleSets({
root: [
classNames.msButton,
styles.root,
variantClassName,
checked && ['is-checked', styles.rootChecked],
isExpanded && [
'is-expanded',
styles.rootExpanded,
{
_a[":hover ." + classNames.msButtonIcon] =
styles.iconExpandedHovered,
// menuIcon falls back to rootExpandedHovered to support
original behavior
_a[":hover ." + classNames.msButtonMenuIcon] =
styles.menuIconExpandedHovered || styles.rootExpandedHovered,
_a[':hover'] = styles.rootExpandedHovered,
_a),
},
],
hasMenu && [exports.ButtonGlobalClassNames.msButtonHasMenu,
styles.rootHasMenu],
disabled && ['is-disabled', styles.rootDisabled],
!disabled &&
!isExpanded &&
!checked && {
selectors: (_b = {
':hover': styles.rootHovered
},
_b[":hover ." + classNames.msButtonLabel] =
styles.labelHovered,
_b[":hover ." + classNames.msButtonIcon] = styles.iconHovered,
_b[":hover ." + classNames.msButtonDescription] =
styles.descriptionHovered,
_b[":hover ." + classNames.msButtonMenuIcon] =
styles.menuIconHovered,
_b[':focus'] = styles.rootFocused,
_b[':active'] = styles.rootPressed,
_b[":active ." + classNames.msButtonIcon] = styles.iconPressed,
_b[":active ." + classNames.msButtonDescription] =
styles.descriptionPressed,
_b[":active ." + classNames.msButtonMenuIcon] =
styles.menuIconPressed,
_b),
},
disabled && checked && [styles.rootCheckedDisabled],
!disabled &&
checked && {
selectors: {
':hover': styles.rootCheckedHovered,
':active': styles.rootCheckedPressed,
},
},
className,
],
flexContainer: [classNames.msButtonFlexContainer, styles.flexContainer],
textContainer: [classNames.msButtonTextContainer, styles.textContainer],
icon: [
classNames.msButtonIcon,
iconClassName,
styles.icon,
isExpanded && styles.iconExpanded,
checked && styles.iconChecked,
disabled && styles.iconDisabled,
],
label: [classNames.msButtonLabel, styles.label, checked &&
styles.labelChecked, disabled && styles.labelDisabled],
menuIcon: [
classNames.msButtonMenuIcon,
menuIconClassName,
styles.menuIcon,
checked && styles.menuIconChecked,
disabled && !isSplit && styles.menuIconDisabled,
!disabled &&
!isExpanded &&
!checked && {
selectors: {
':hover': styles.menuIconHovered,
':active': styles.menuIconPressed,
},
},
isExpanded && ['is-expanded', styles.menuIconExpanded],
],
description: [
classNames.msButtonDescription,
styles.description,
checked && styles.descriptionChecked,
disabled && styles.descriptionDisabled,
],
screenReaderText: [classNames.msButtonScreenReaderText,
styles.screenReaderText],
});
});
//# sourceMappingURL=BaseButton.classNames.js.map
/***/ }),
/***/ 46993:
"use strict";

exports.BaseButton = void 0;
var ContextualMenu_1 = __webpack_require__(34649);
var BaseButton_classNames_1 = __webpack_require__(55650);
var SplitButton_classNames_1 = __webpack_require__(55531);
var KeytipData_1 = __webpack_require__(77566);
var TouchIdleDelay = 500; /* ms */
var COMPONENT_NAME = 'BaseButton';
/**
*/
var BaseButton = /** @class */ (function (_super) {
tslib_1.__extends(BaseButton, _super);
function BaseButton(props) {
_this._buttonElement = React.createRef();
_this._splitButtonContainer = React.createRef();
_this._mergedRef = Utilities_1.createMergedRef();
_this._renderedVisibleMenu = false;
_this._getMemoizedMenuButtonKeytipProps =
Utilities_1.memoizeFunction(function (keytipProps) {
return tslib_1.__assign(tslib_1.__assign({}, keytipProps), { hasMenu:
true });
});
_this._onRenderIcon = function (buttonProps, defaultRender) {
var iconProps = _this.props.iconProps;
if (iconProps && (iconProps.iconName !== undefined ||
iconProps.imageProps)) {
var className = iconProps.className, imageProps =
iconProps.imageProps, rest = tslib_1.__rest(iconProps, ["className",
"imageProps"]);
// If the styles prop is specified as part of iconProps, fall back
to regular Icon as FontIcon and ImageIcon
// do not have this prop.
if (iconProps.styles) {
return React.createElement(Icon_1.Icon,
tslib_1.__assign({ className: Utilities_1.css(_this._classNames.icon, className),
imageProps: imageProps }, rest));
}
if (iconProps.iconName) {
return React.createElement(Icon_1.FontIcon,
tslib_1.__assign({ className: Utilities_1.css(_this._classNames.icon, className) },
rest));
}
if (imageProps) {
return React.createElement(Icon_1.ImageIcon, tslib_1.__assign({
className: Utilities_1.css(_this._classNames.icon, className), imageProps:
imageProps }, rest));
}
}
return null;
};
_this._onRenderTextContents = function () {
var _a = _this.props, text = _a.text, children = _a.children,
_b = _a.secondaryText,
secondaryText = _b === void 0 ? _this.props.description : _b, _c =
_a.onRenderText, onRenderText = _c === void 0 ? _this._onRenderText : _c, _d =
_a.onRenderDescription, onRenderDescription = _d === void 0 ?
_this._onRenderDescription : _d;
if (text || typeof children === 'string' || secondaryText) {
return (React.createElement("span", { className:
_this._classNames.textContainer },
onRenderText(_this.props, _this._onRenderText),
onRenderDescription(_this.props, _this._onRenderDescription)));
}
return [onRenderText(_this.props, _this._onRenderText),
onRenderDescription(_this.props, _this._onRenderDescription)];
};
_this._onRenderText = function () {
var text = _this.props.text;
var children = _this.props.children;
// For backwards compat, we should continue to take in the text content
from children.
if (text === undefined && typeof children === 'string') {
text = children;
}
if (_this._hasText()) {
return (React.createElement("span", { key: _this._labelId,
className: _this._classNames.label, id: _this._labelId }, text));
}
return null;
};
_this._onRenderChildren = function () {
var children = _this.props.children;
// If children is just a string, either it or the text will be rendered
via onRenderLabel
// If children is another component, it will be rendered after text
if (typeof children === 'string') {
return null;
}
return children;
};
_this._onRenderDescription = function (props) {
var _a = props.secondaryText, secondaryText = _a === void 0 ?
_this.props.description : _a;
// ms-Button-description is only shown when the button type is
compound.
// In other cases it will not be displayed.
return secondaryText ? (React.createElement("span", { key:
_this._descriptionId, className: _this._classNames.description, id:
_this._descriptionId }, secondaryText)) : null;
};
_this._onRenderAriaDescription = function () {
var ariaDescription = _this.props.ariaDescription;
// If ariaDescription is given, descriptionId will be assigned to
ariaDescriptionSpan,
// otherwise it will be assigned to descriptionSpan.
return ariaDescription ? (React.createElement("span", { className:
_this._classNames.screenReaderText, id: _this._ariaDescriptionId },
ariaDescription)) : null;
};
_this._onRenderMenuIcon = function (props) {
var menuIconProps = _this.props.menuIconProps;
return React.createElement(Icon_1.FontIcon,
tslib_1.__assign({ iconName: "ChevronDown" }, menuIconProps, { className:
_this._classNames.menuIcon }));
};
_this._onRenderMenu = function (menuProps) {
var MenuType = _this.props.menuAs ?
Utilities_2.composeComponentAs(_this.props.menuAs, ContextualMenu_1.ContextualMenu)
: ContextualMenu_1.ContextualMenu;
return React.createElement(MenuType, tslib_1.__assign({}, menuProps));
};
_this._onDismissMenu = function (ev) {
var menuProps = _this.props.menuProps;
if (menuProps && menuProps.onDismiss) {
menuProps.onDismiss(ev);
}
if (!ev || !ev.defaultPrevented) {
_this._dismissMenu();
}
};
_this._dismissMenu = function () {
_this._menuShouldFocusOnMount = undefined;
_this._menuShouldFocusOnContainer = undefined;
_this.setState({ menuHidden: true });
};
_this._openMenu = function (shouldFocusOnContainer, shouldFocusOnMount) {
if (shouldFocusOnMount === void 0) { shouldFocusOnMount = true; }
if (_this.props.menuProps) {
_this._menuShouldFocusOnContainer = shouldFocusOnContainer;
_this._menuShouldFocusOnMount = shouldFocusOnMount;
_this._renderedVisibleMenu = true;
_this.setState({ menuHidden: false });
}
};
_this._onToggleMenu = function (shouldFocusOnContainer) {
var shouldFocusOnMount = true;
if (_this.props.menuProps && _this.props.menuProps.shouldFocusOnMount
=== false) {
shouldFocusOnMount = false;
}
_this.state.menuHidden ? _this._openMenu(shouldFocusOnContainer,
shouldFocusOnMount) : _this._dismissMenu();
};
_this._onSplitContainerFocusCapture = function (ev) {
var container = _this._splitButtonContainer.current;
// If the target is coming from the portal we do not need to set focus
on the container.
if (!container || (ev.target &&
Utilities_1.portalContainsElement(ev.target, container))) {
return;
}
// We should never be able to focus the individual buttons in a split
button. Focus
// should always remain on the container.
container.focus();
};
_this._onSplitButtonPrimaryClick = function (ev) {
if (!_this.state.menuHidden) {
_this._dismissMenu();
}
if (!_this._processingTouch && _this.props.onClick) {
_this.props.onClick(ev);
}
else if (_this._processingTouch) {
_this._onMenuClick(ev);
}
};
// explicity cancelling event so click won't fire after this
if (_this.props.disabled && (ev.which === Utilities_1.KeyCodes.enter ||
ev.which === Utilities_1.KeyCodes.space)) {
}
else if (!_this.props.disabled) {
_this._onMenuKeyDown(ev);
}
else if (_this.props.onKeyDown !== undefined) {
_this.props.onKeyDown(ev); // not cancelling event because it's
not disabled
}
}
};
_this._onKeyUp = function (ev) {
if (!_this.props.disabled && _this.props.onKeyUp !== undefined) {
_this.props.onKeyUp(ev); // not cancelling event because it's not
disabled
}
};
_this._onKeyPress = function (ev) {
if (!_this.props.disabled && _this.props.onKeyPress !== undefined) {
_this.props.onKeyPress(ev); // not cancelling event because it's
not disabled
}
};
_this._onMouseUp = function (ev) {
if (!_this.props.disabled && _this.props.onMouseUp !== undefined) {
_this.props.onMouseUp(ev); // not cancelling event because it's not
disabled
}
};
if (!_this.props.disabled && _this.props.onMouseDown !== undefined) {
_this.props.onMouseDown(ev); // not cancelling event because it's
not disabled
}
};
_this._onClick = function (ev) {
if (!_this.props.disabled) {
_this._onMenuClick(ev);
}
else if (_this.props.onClick !== undefined) {
_this.props.onClick(ev); // not cancelling event because it's
not disabled
}
}
};
_this._onSplitButtonContainerKeyDown = function (ev) {
if (ev.which === Utilities_1.KeyCodes.enter || ev.which ===
Utilities_1.KeyCodes.space) {
if (_this._buttonElement.current) {
_this._buttonElement.current.click();
}
}
else {
_this._onMenuKeyDown(ev);
}
};
_this._onMenuKeyDown = function (ev) {
if (_this.props.disabled) {
return;
}
}
var isUp = ev.which === Utilities_1.KeyCodes.up;
var isDown = ev.which === Utilities_1.KeyCodes.down;
if (!ev.defaultPrevented && _this._isValidMenuOpenKey(ev)) {
var onMenuClick = _this.props.onMenuClick;
if (onMenuClick) {
onMenuClick(ev, _this.props);
}
_this._onToggleMenu(false);
}
// We manually set the focus visibility to true if opening via
Enter or Space to account for the scenario where
// a user clicks on the button, closes the menu and then opens it
via keyboard. In this scenario our default logic
// for setting focus visibility is not triggered since there is no
keyboard navigation present beforehand.
Utilities_1.setFocusVisibility(true, ev.target);
}
if (!(ev.altKey || ev.metaKey) && (isUp || isDown)) {
// Suppose a menu, with shouldFocusOnMount: false, is open, and
user wants to keyboard to the menu items
// We need to re-render the menu with shouldFocusOnMount as true.
if (!_this.state.menuHidden && _this.props.menuProps) {
var currentShouldFocusOnMount = _this._menuShouldFocusOnMount !
== undefined
? _this._menuShouldFocusOnMount
: _this.props.menuProps.shouldFocusOnMount;
if (!currentShouldFocusOnMount) {
_this._menuShouldFocusOnMount = true;
_this.forceUpdate();
}
}
}
};
_this._onTouchStart = function () {
if (_this._isSplitButton &&
_this._splitButtonContainer.current &&
!('onpointerdown' in _this._splitButtonContainer.current)) {
_this._handleTouchAndPointerEvent();
}
};
_this._onMenuClick = function (ev) {
var _a = _this.props, onMenuClick = _a.onMenuClick, menuProps =
_a.menuProps;
if (onMenuClick) {
onMenuClick(ev, _this.props);
}
// focus on the container by default when the menu is opened with a
click event
// this differentiates from a keyboard interaction triggering the click
event
var shouldFocusOnContainer = typeof (menuProps === null || menuProps
=== void 0 ? void 0 : menuProps.shouldFocusOnContainer) === 'boolean'
? menuProps.shouldFocusOnContainer
: ev.nativeEvent.pointerType === 'mouse';
if (!ev.defaultPrevented) {
_this._onToggleMenu(shouldFocusOnContainer);
}
};
_this._events = new Utilities_1.EventGroup(_this);
Utilities_1.warnConditionallyRequiredProps(COMPONENT_NAME, props,
['menuProps', 'onClick'], 'split', _this.props.split);
Utilities_1.warnDeprecations(COMPONENT_NAME, props, {
rootProps: undefined,
description: 'secondaryText',
toggled: 'checked',
});
_this._labelId = Utilities_1.getId();
_this._descriptionId = Utilities_1.getId();
_this._ariaDescriptionId = Utilities_1.getId();
_this.state = {
menuHidden: true,
};
return _this;
}
Object.defineProperty(BaseButton.prototype, "_isSplitButton", {
get: function () {
return !!this.props.menuProps && !!this.props.onClick &&
this.props.split === true;
},
enumerable: false,
configurable: true
});
BaseButton.prototype.render = function () {
var _a;
var _b = this.props, ariaDescription = _b.ariaDescription, ariaLabel =
_b.ariaLabel, ariaHidden = _b.ariaHidden, className = _b.className, disabled =
_b.disabled, allowDisabledFocus = _b.allowDisabledFocus, primaryDisabled =
_b.primaryDisabled,
_c = _b.secondaryText,
secondaryText = _c === void 0 ? this.props.description : _c, href =
_b.href, iconProps = _b.iconProps, menuIconProps = _b.menuIconProps, styles =
_b.styles, checked = _b.checked, variantClassName = _b.variantClassName, theme =
_b.theme, toggle = _b.toggle, getClassNames = _b.getClassNames, role = _b.role;
var menuHidden = this.state.menuHidden;
// Button is disabled if the whole button (in case of splitButton is
disabled) or if the primary action is disabled
var isPrimaryButtonDisabled = disabled || primaryDisabled;
this._classNames = getClassNames
? getClassNames(theme, className, variantClassName, iconProps &&
iconProps.className, menuIconProps && menuIconProps.className,
isPrimaryButtonDisabled, checked, !menuHidden, !!this.props.menuProps,
this.props.split, !!allowDisabledFocus)
: BaseButton_classNames_1.getBaseButtonClassNames(theme, styles,
className, variantClassName, iconProps && iconProps.className, menuIconProps &&
menuIconProps.className, isPrimaryButtonDisabled, !!this.props.menuProps,
checked, !menuHidden, this.props.split);
var _d = this, _ariaDescriptionId = _d._ariaDescriptionId, _labelId =
_d._labelId, _descriptionId = _d._descriptionId;
// Anchor tag cannot be disabled hence in disabled state rendering
// anchor button as normal button
var renderAsAnchor = !isPrimaryButtonDisabled && !!href;
var tag = renderAsAnchor ? 'a' : 'button';
var nativeProps = Utilities_1.getNativeProps(
Utilities_1.assign(renderAsAnchor ? {} : { type: 'button' },
this.props.rootProps, this.props), renderAsAnchor ? Utilities_1.anchorProperties :
Utilities_1.buttonProperties, [
'disabled', // let disabled buttons be focused and styled as disabled.
]);
// Check for ariaLabel passed in via Button props, and fall back to aria-
label passed in via native props
var resolvedAriaLabel = ariaLabel || nativeProps['aria-label'];
// Check for ariaDescription, secondaryText or aria-describedby in the
native props to determine source of
// aria-describedby. Otherwise default to undefined so property does not
appear in output.
var ariaDescribedBy = undefined;
if (ariaDescription) {
ariaDescribedBy = _ariaDescriptionId;
}
else if (secondaryText && this.props.onRenderDescription !==
Utilities_1.nullRender) {
// for buttons like CompoundButton with a valid onRenderDescription, we
need to set an ariaDescribedBy
// for buttons that do not render anything (via nullRender), we should
not set an ariaDescribedBy
ariaDescribedBy = _descriptionId;
}
else if (nativeProps['aria-describedby']) {
ariaDescribedBy = nativeProps['aria-describedby'];
}
// If an explicit aria-labelledby is given, use that and we're done.
// If any kind of description is given (which will end up as an aria-
describedby attribute)
// and no ariaLabel is specified, set the labelledby element.
// Otherwise, the button is labeled implicitly by the descendent text on
the button (if it exists).
var ariaLabelledBy = undefined;
if (nativeProps['aria-labelledby']) {
ariaLabelledBy = nativeProps['aria-labelledby'];
}
else if (ariaDescribedBy && !resolvedAriaLabel) {
ariaLabelledBy = this._hasText() ? _labelId : undefined;
}
var dataIsFocusable = this.props['data-is-focusable'] === false ||
(disabled && !allowDisabledFocus) || this._isSplitButton
? false
: true;
var isCheckboxTypeRole = role === 'menuitemcheckbox' || role ===
'checkbox';
// if isCheckboxTypeRole, always return a checked value.
// Otherwise only return checked value if toggle is set to true.
// This is because role="checkbox" always needs to have an aria-checked
value
// but our checked prop only sets aria-pressed if we mark the button as a
toggle="true"
var checkedOrPressedValue = isCheckboxTypeRole ? !!checked : toggle ===
true ? !!checked : undefined;
var buttonProps = Utilities_1.assign(nativeProps, (_a = {
className: this._classNames.root,
ref: this._mergedRef(this.props.elementRef, this._buttonElement),
disabled: isPrimaryButtonDisabled && !allowDisabledFocus,
onKeyDown: this._onKeyDown,
onKeyPress: this._onKeyPress,
onKeyUp: this._onKeyUp,
onMouseDown: this._onMouseDown,
onMouseUp: this._onMouseUp,
onClick: this._onClick,
'aria-label': resolvedAriaLabel,
'aria-labelledby': ariaLabelledBy,
'aria-describedby': ariaDescribedBy,
'aria-disabled': isPrimaryButtonDisabled,
'data-is-focusable': dataIsFocusable
},
// aria-pressed attribute should only be present for toggle buttons
// aria-checked attribute should only be present for toggle buttons
with checkbox type role
_a[isCheckboxTypeRole ? 'aria-checked' : 'aria-pressed'] =
checkedOrPressedValue,
_a));
if (ariaHidden) {
buttonProps['aria-hidden'] = true;
}
if (this._isSplitButton) {
return this._onRenderSplitButtonContent(tag, buttonProps);
}
else if (this.props.menuProps) {
var _e = this.props.menuProps.id, id = _e === void 0 ? this._labelId +
"-menu" : _e;
Utilities_1.assign(buttonProps, {
'aria-expanded': !menuHidden,
'aria-controls': !menuHidden ? id : null,
'aria-haspopup': true,
});
}
return this._onRenderContent(tag, buttonProps);
};
BaseButton.prototype.componentDidMount = function () {
// For split buttons, touching anywhere in the button should drop the
dropdown, which should contain the
// primary action. This gives more hit target space for touch environments.
We're setting the onpointerdown here,
// because React does not support Pointer events yet.
if (this._isSplitButton && this._splitButtonContainer.current) {
if ('onpointerdown' in this._splitButtonContainer.current) {
this._events.on(this._splitButtonContainer.current, 'pointerdown',
this._onPointerDown, true);
}
if ('onpointerup' in this._splitButtonContainer.current &&
this.props.onPointerUp) {
this._events.on(this._splitButtonContainer.current, 'pointerup',
this.props.onPointerUp, true);
}
}
};
BaseButton.prototype.componentDidUpdate = function (prevProps, prevState) {
// If Button's menu was closed, run onAfterMenuDismiss.
if (this.props.onAfterMenuDismiss && !prevState.menuHidden &&
this.state.menuHidden) {
this.props.onAfterMenuDismiss();
}
};
BaseButton.prototype.componentWillUnmount = function () {
this._events.dispose();
};
BaseButton.prototype.focus = function () {
if (this._isSplitButton && this._splitButtonContainer.current) {
Utilities_1.setFocusVisibility(true);
this._splitButtonContainer.current.focus();
}
else if (this._buttonElement.current) {
Utilities_1.setFocusVisibility(true);
this._buttonElement.current.focus();
}
};
BaseButton.prototype.dismissMenu = function () {
this._dismissMenu();
};
BaseButton.prototype.openMenu = function (shouldFocusOnContainer,
shouldFocusOnMount) {
this._openMenu(shouldFocusOnContainer, shouldFocusOnMount);
};
BaseButton.prototype._onRenderContent = function (tag, buttonProps) {
var _this = this;
var props = this.props;
var Tag = tag;
var menuIconProps = props.menuIconProps, menuProps = props.menuProps, _a =
props.onRenderIcon, onRenderIcon = _a === void 0 ? this._onRenderIcon : _a, _b =
props.onRenderAriaDescription, onRenderAriaDescription = _b === void 0 ?
this._onRenderAriaDescription : _b, _c = props.onRenderChildren, onRenderChildren =
_c === void 0 ? this._onRenderChildren : _c,
_d = props.onRenderMenu,
onRenderMenu = _d === void 0 ? this._onRenderMenu : _d, _e =
props.onRenderMenuIcon, onRenderMenuIcon = _e === void 0 ? this._onRenderMenuIcon :
_e, disabled = props.disabled;
var keytipProps = props.keytipProps;
if (keytipProps && menuProps) {
keytipProps = this._getMemoizedMenuButtonKeytipProps(keytipProps);
}
var Button = function (keytipAttributes) { return (React.createElement(Tag,
tslib_1.__assign({}, buttonProps, keytipAttributes),
React.createElement("span", { className:
_this._classNames.flexContainer, "data-automationid": "splitbuttonprimary" },
onRenderIcon(props, _this._onRenderIcon),
_this._onRenderTextContents(),
onRenderAriaDescription(props, _this._onRenderAriaDescription),
onRenderChildren(props, _this._onRenderChildren),
!_this._isSplitButton &&
(menuProps || menuIconProps || _this.props.onRenderMenuIcon) &&
onRenderMenuIcon(_this.props, _this._onRenderMenuIcon),
menuProps &&
!menuProps.doNotLayer &&
_this._shouldRenderMenu() &&
onRenderMenu(_this._getMenuProps(menuProps),
_this._onRenderMenu)))); };
var Content = keytipProps ? (
// If we're making a split button, we won't put the keytip here
React.createElement(KeytipData_1.KeytipData, { keytipProps: !
this._isSplitButton ? keytipProps : undefined, ariaDescribedBy: buttonProps['aria-
describedby'], disabled: disabled }, function (keytipAttributes) { return
Button(keytipAttributes); })) : (Button());
if (menuProps && menuProps.doNotLayer) {
return (React.createElement(React.Fragment, null,
Content,
this._shouldRenderMenu() &&
onRenderMenu(this._getMenuProps(menuProps), this._onRenderMenu)));
}
Content,
React.createElement(Utilities_1.FocusRects, null)));
};
/**
* Method to help determine if the menu's component tree should
* be rendered. It takes into account whether the menu is expanded,
* whether it is a persisted menu and whether it has been shown to the user.
*/
BaseButton.prototype._shouldRenderMenu = function () {
var _a = this.props, persistMenu = _a.persistMenu,
renderPersistedMenuHiddenOnMount = _a.renderPersistedMenuHiddenOnMount;
if (!menuHidden) {
// Always should render a menu when it is expanded
return true;
}
else if (persistMenu && (this._renderedVisibleMenu ||
renderPersistedMenuHiddenOnMount)) {
// _renderedVisibleMenu ensures that the first rendering of
// the menu happens on-screen, as edge's scrollbar calculations are off
if done while hidden.
return true;
}
return false;
};
BaseButton.prototype._hasText = function () {
// _onRenderTextContents and _onRenderText do not perform the same checks.
Below is parity with what _onRenderText
// used to have before the refactor that introduced this function.
_onRenderTextContents does not require props.
// text to be undefined in order for props.children to be used as a
fallback.
// Purely a code maintainability/reuse issue, but logged as Issue #4979.
return this.props.text !== null && (this.props.text !== undefined || typeof
this.props.children === 'string');
};
BaseButton.prototype._getMenuProps = function (menuProps) {
var persistMenu = this.props.persistMenu;
// the accessible menu label (accessible name) has a relationship to the
button.
// If the menu props do not specify an explicit value for aria-label or
aria-labelledBy,
// AND the button has text, we'll set the menu aria-labelledBy to the text
element id.
if (!menuProps.ariaLabel && !menuProps.labelElementId && this._hasText()) {
menuProps = tslib_1.__assign(tslib_1.__assign({}, menuProps),
{ labelElementId: this._labelId });
}
return tslib_1.__assign(tslib_1.__assign({ id: this._labelId + '-menu',
directionalHint: DirectionalHint_1.DirectionalHint.bottomLeftEdge }, menuProps),
{ shouldFocusOnContainer: this._menuShouldFocusOnContainer, shouldFocusOnMount:
this._menuShouldFocusOnMount, hidden: persistMenu ? menuHidden : undefined,
className: Utilities_1.css('ms-BaseButton-menuhost', menuProps.className), target:
this._isSplitButton ? this._splitButtonContainer.current :
this._buttonElement.current, onDismiss: this._onDismissMenu });
};
BaseButton.prototype._onRenderSplitButtonContent = function (tag, buttonProps)
{
var _this = this;
var _a = this.props, _b = _a.styles, styles = _b === void 0 ? {} : _b,
disabled = _a.disabled, allowDisabledFocus = _a.allowDisabledFocus, checked =
_a.checked, getSplitButtonClassNames = _a.getSplitButtonClassNames, primaryDisabled
= _a.primaryDisabled, menuProps = _a.menuProps, toggle = _a.toggle, role = _a.role,
primaryActionButtonProps = _a.primaryActionButtonProps;
var keytipProps = this.props.keytipProps;
var classNames = getSplitButtonClassNames
? getSplitButtonClassNames(!!disabled, !menuHidden, !!checked, !!
allowDisabledFocus)
: styles &&
SplitButton_classNames_1.getSplitButtonClassNames(styles, !!disabled, !
menuHidden, !!checked, !!primaryDisabled);
Utilities_1.assign(buttonProps, {
onClick: undefined,
onPointerDown: undefined,
onPointerUp: undefined,
tabIndex: -1,
'data-is-focusable': false,
});
if (keytipProps && menuProps) {
}
var containerProps = Utilities_1.getNativeProps(buttonProps, [],
['disabled']);
// Add additional props to apply on primary action button
if (primaryActionButtonProps) {
Utilities_1.assign(buttonProps, primaryActionButtonProps);
}
var SplitButton = function (keytipAttributes) { return
(React.createElement("div", tslib_1.__assign({}, containerProps, { "data-ktp-
target": keytipAttributes ? keytipAttributes['data-ktp-target'] : undefined, role:
role ? role : 'button', "aria-disabled": disabled, "aria-haspopup": true, "aria-
expanded": !menuHidden, "aria-pressed": toggle ? !!checked : undefined, "aria-
describedby": Utilities_1.mergeAriaAttributeValues(buttonProps['aria-describedby'],
keytipAttributes ? keytipAttributes['aria-describedby'] : undefined), className:
classNames && classNames.splitButtonContainer, onKeyDown:
_this._onSplitButtonContainerKeyDown, onTouchStart: _this._onTouchStart, ref:
_this._splitButtonContainer, "data-is-focusable": true, onClick: !disabled && !
primaryDisabled ? _this._onSplitButtonPrimaryClick : undefined, tabIndex: (!
disabled && !primaryDisabled) || allowDisabledFocus ? 0 : undefined, "aria-
roledescription": buttonProps['aria-roledescription'], onFocusCapture:
_this._onSplitContainerFocusCapture }),
React.createElement("span", { style: { display: 'flex', width: '100%' }
},
_this._onRenderContent(tag, buttonProps),
_this._onRenderSplitButtonMenuButton(classNames, keytipAttributes),
_this._onRenderSplitButtonDivider(classNames)))); };
return keytipProps ? (React.createElement(KeytipData_1.KeytipData,
{ keytipProps: keytipProps, disabled: disabled }, function (keytipAttributes)
{ return SplitButton(keytipAttributes); })) : (SplitButton());
};
BaseButton.prototype._onRenderSplitButtonDivider = function (classNames) {
if (classNames && classNames.divider) {
var onClick = function (ev) {
};
return React.createElement("span", { className: classNames.divider,
"aria-hidden": true, onClick: onClick });
}
return null;
};
BaseButton.prototype._onRenderSplitButtonMenuButton = function (classNames,
keytipAttributes) {
var _a = this.props, allowDisabledFocus = _a.allowDisabledFocus, checked =
_a.checked, disabled = _a.disabled, splitButtonMenuProps = _a.splitButtonMenuProps,
splitButtonAriaLabel = _a.splitButtonAriaLabel, primaryDisabled =
_a.primaryDisabled;
var menuIconProps = this.props.menuIconProps;
if (menuIconProps === undefined) {
menuIconProps = {
iconName: 'ChevronDown',
};
}
var splitButtonProps = tslib_1.__assign(tslib_1.__assign({},
splitButtonMenuProps), { styles: classNames, checked: checked, disabled: disabled,
allowDisabledFocus: allowDisabledFocus, onClick: this._onMenuClick, menuProps:
undefined, iconProps: tslib_1.__assign(tslib_1.__assign({}, menuIconProps),
{ className: this._classNames.menuIcon }), ariaLabel: splitButtonAriaLabel, 'aria-
haspopup': true, 'aria-expanded': !menuHidden, 'data-is-focusable': false });
// Add data-ktp-execute-target to the split button if the keytip is defined
return (React.createElement(BaseButton, tslib_1.__assign({},
splitButtonProps, { "data-ktp-execute-target": keytipAttributes ?
keytipAttributes['data-ktp-execute-target'] : keytipAttributes, onMouseDown:
this._onMouseDown, tabIndex: primaryDisabled && !allowDisabledFocus ? 0 : -1 })));
};
BaseButton.prototype._onPointerDown = function (ev) {
var onPointerDown = this.props.onPointerDown;
if (onPointerDown) {
onPointerDown(ev);
}
if (ev.pointerType === 'touch') {
this._handleTouchAndPointerEvent();
ev.stopImmediatePropagation();
}
};
BaseButton.prototype._handleTouchAndPointerEvent = function () {
var _this = this;
// If we already have an existing timeout from a previous touch and pointer
event
// cancel that timeout so we can set a new one.
if (this._lastTouchTimeoutId !== undefined) {
this._async.clearTimeout(this._lastTouchTimeoutId);
this._lastTouchTimeoutId = undefined;
}
this._processingTouch = true;
this._lastTouchTimeoutId = this._async.setTimeout(function () {
_this._processingTouch = false;
_this._lastTouchTimeoutId = undefined;
// Touch and pointer events don't focus the button naturally,
// so adding an imperative focus call to guarantee this behavior.
_this.focus();
}, TouchIdleDelay);
};
/**
* Returns if the user hits a valid keyboard key to open the menu
* @param ev - the keyboard event
* @returns True if user clicks on custom trigger key if enabled or alt + down
arrow if not. False otherwise.
*/
BaseButton.prototype._isValidMenuOpenKey = function (ev) {
if (this.props.menuTriggerKeyCode) {
return ev.which === this.props.menuTriggerKeyCode;
}
else if (this.props.menuProps) {
return ev.which === Utilities_1.KeyCodes.down && (ev.altKey ||
ev.metaKey);
}
// Note: When enter is pressed, we will let the event continue to propagate
// to trigger the onClick event on the button
return false;
};
BaseButton.defaultProps = {
baseClassName: 'ms-Button',
styles: {},
split: false,
};
return BaseButton;
exports.BaseButton = BaseButton;
//# sourceMappingURL=BaseButton.js.map
/***/ }),
/***/ 51100:
"use strict";

var noOutline = {
outline: 0,
};
var iconStyle = function (fontSize) {
return {
fontSize: fontSize,
margin: '0 4px',
height: '16px',
lineHeight: '16px',
textAlign: 'center',
flexShrink: 0,
};
};
/**
* Gets the base button styles. Note: because it is a base class to be used with
the `mergeRules`
* helper, it should have values for all class names in the interface. This let
`mergeRules` optimize
* mixing class names together.
*/
exports.getStyles = Utilities_1.memoizeFunction(function (theme) {
var _a, _b;
var semanticColors = theme.semanticColors, effects = theme.effects, fonts =
theme.fonts;
var border = semanticColors.buttonBorder;
var disabledBackground = semanticColors.disabledBackground;
var disabledText = semanticColors.disabledText;
var buttonHighContrastFocus = {
left: -2,
top: -2,
bottom: -2,
right: -2,
outlineColor: 'ButtonText',
};
return {
root: [
Styling_1.getFocusStyle(theme, { inset: 1, highContrastStyle:
buttonHighContrastFocus, borderColor: 'transparent' }),
theme.fonts.medium,
{
border: '1px solid ' + border,
userSelect: 'none',
cursor: 'pointer',
padding: '0 16px',
borderRadius: effects.roundedCorner2,
selectors: {
// IE11 workaround for preventing shift of child elements of a
button when active.
':active > span': {
left: 0,
top: 0,
},
},
},
],
rootDisabled: [
Styling_1.getFocusStyle(theme, { inset: 1, highContrastStyle:
buttonHighContrastFocus, borderColor: 'transparent' }),
{
backgroundColor: disabledBackground,
borderColor: disabledBackground,
color: disabledText,
cursor: 'default',
selectors: {
':hover': noOutline,
':focus': noOutline,
},
},
],
iconDisabled: {
color: 'GrayText',
},
_a),
},
menuIconDisabled: {
color: 'GrayText',
},
_b),
},
flexContainer: {
display: 'flex',
height: '100%',
flexWrap: 'nowrap',
},
description: {
display: 'block',
},
textContainer: {
flexGrow: 1,
display: 'block',
},
icon: iconStyle(fonts.mediumPlus.fontSize),
menuIcon: iconStyle(fonts.small.fontSize),
label: {
margin: '0 4px',
lineHeight: '100%',
display: 'block',
},
};
});
//# sourceMappingURL=BaseButton.styles.js.map
/***/ }),
/***/ 82982:
"use strict";

exports.Button = void 0;
var Button_types_1 = __webpack_require__(91475);
var DefaultButton_1 = __webpack_require__(21349);
var ActionButton_1 = __webpack_require__(67176);
var CompoundButton_1 = __webpack_require__(91713);
var IconButton_1 = __webpack_require__(94027);
var PrimaryButton_1 = __webpack_require__(18321);
/**
* This class is deprecated. Use the individual *Button components instead.
* @deprecated Use the individual *Button components instead.
*/
var Button = /** @class */ (function (_super) {
tslib_1.__extends(Button, _super);
function Button(props) {
Utilities_1.warn("The Button component has been deprecated. Use specific
variants instead. " +
"(PrimaryButton, DefaultButton, IconButton, ActionButton, etc.)");
return _this;
}
Button.prototype.render = function () {
switch (props.buttonType) {
case Button_types_1.ButtonType.command:
return React.createElement(ActionButton_1.ActionButton,
tslib_1.__assign({}, props));
case Button_types_1.ButtonType.compound:
return React.createElement(CompoundButton_1.CompoundButton,
case Button_types_1.ButtonType.icon:
return React.createElement(IconButton_1.IconButton,
case Button_types_1.ButtonType.primary:
return React.createElement(PrimaryButton_1.PrimaryButton,
default:
return React.createElement(DefaultButton_1.DefaultButton,
}
};
return Button;
exports.Button = Button;
//# sourceMappingURL=Button.js.map
/***/ }),
/***/ 91475:
"use strict";

exports.ButtonType = exports.ElementType = void 0;
/**
*/
var ElementType;
(function (ElementType) {
/** `button` element. */
ElementType[ElementType["button"] = 0] = "button";
/** à` element. */
ElementType[ElementType["anchor"] = 1] = "anchor";
})(ElementType = exports.ElementType || (exports.ElementType = {}));
/**
*/
var ButtonType;
(function (ButtonType) {
ButtonType[ButtonType["normal"] = 0] = "normal";
ButtonType[ButtonType["primary"] = 1] = "primary";
ButtonType[ButtonType["hero"] = 2] = "hero";
ButtonType[ButtonType["compound"] = 3] = "compound";
ButtonType[ButtonType["command"] = 4] = "command";
ButtonType[ButtonType["icon"] = 5] = "icon";
ButtonType[ButtonType["default"] = 6] = "default";
})(ButtonType = exports.ButtonType || (exports.ButtonType = {}));
//# sourceMappingURL=Button.types.js.map
/***/ }),
/***/ 8028:
"use strict";

exports.primaryStyles = exports.standardStyles = void 0;
var splitButtonDividerBaseStyles = function () {
return {
width: 1,
right: 31,
top: 8,
bottom: 8,
};
};
function standardStyles(theme) {
var _a, _b, _c, _d, _e;
var s = theme.semanticColors, p = theme.palette;
var buttonBackground = s.buttonBackground;
var buttonBackgroundPressed = s.buttonBackgroundPressed;
var buttonBackgroundHovered = s.buttonBackgroundHovered;
var buttonBackgroundDisabled = s.buttonBackgroundDisabled;
var buttonText = s.buttonText;
var buttonTextHovered = s.buttonTextHovered;
var buttonTextDisabled = s.buttonTextDisabled;
var buttonTextChecked = s.buttonTextChecked;
var buttonTextCheckedHovered = s.buttonTextCheckedHovered;
return {
root: {
backgroundColor: buttonBackground,
color: buttonText,
},
rootHovered: {
backgroundColor: buttonBackgroundHovered,
color: buttonTextHovered,
borderColor: 'Highlight',
color: 'Highlight',
},
_a),
},
rootPressed: {
backgroundColor: buttonBackgroundPressed,
color: buttonTextChecked,
},
rootExpanded: {
},
rootChecked: {
},
rootCheckedHovered: {
color: buttonTextCheckedHovered,
},
rootDisabled: {
color: buttonTextDisabled,
backgroundColor: buttonBackgroundDisabled,
color: 'GrayText',
borderColor: 'GrayText',
backgroundColor: 'Window',
},
_b),
},
// Split button styles
splitButtonContainer: {
border: 'none',
},
_c),
},
splitButtonMenuButton: {
color: p.white,
selectors: {
':hover': {
backgroundColor: p.neutralLight,
selectors: (_d = {},
_d[Styling_1.HighContrastSelector] = {
color: 'Highlight',
},
_d),
},
},
},
splitButtonMenuButtonDisabled: {
backgroundColor: s.buttonBackgroundDisabled,
selectors: {
':hover': {
backgroundColor: s.buttonBackgroundDisabled,
},
},
},
splitButtonDivider: tslib_1.__assign(tslib_1.__assign({},
splitButtonDividerBaseStyles()), { backgroundColor: p.neutralTertiaryAlt,
selectors: (_e = {},
_e[Styling_1.HighContrastSelector] = {
backgroundColor: 'WindowText',
},
_e) }),
splitButtonDividerDisabled: {
backgroundColor: theme.palette.neutralTertiaryAlt,
},
splitButtonMenuButtonChecked: {
backgroundColor: p.neutralQuaternaryAlt,
selectors: {
':hover': {
},
},
},
splitButtonMenuButtonExpanded: {
selectors: {
':hover': {
},
},
},
splitButtonMenuIcon: {
color: s.buttonText,
},
splitButtonMenuIconDisabled: {
color: s.buttonTextDisabled,
},
};
}
exports.standardStyles = standardStyles;
function primaryStyles(theme) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j;
var p = theme.palette, s = theme.semanticColors;
return {
root: {
backgroundColor: s.primaryButtonBackground,
border: "1px solid " + s.primaryButtonBackground,
color: s.primaryButtonText,
_a[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'Window', backgroundColor: 'WindowText', borderColor: 'WindowText' },
Styling_1.getHighContrastNoAdjustStyle()),
_a["." + Utilities_1.IsFocusVisibleClassName + " &:focus"] = {
selectors: {
':after': {
border: "none",
outlineColor: p.white,
},
},
},
_a),
},
rootHovered: {
backgroundColor: s.primaryButtonBackgroundHovered,
border: "1px solid " + s.primaryButtonBackgroundHovered,
color: s.primaryButtonTextHovered,
color: 'Window',
backgroundColor: 'Highlight',
},
_b),
},
rootPressed: {
backgroundColor: s.primaryButtonBackgroundPressed,
border: "1px solid " + s.primaryButtonBackgroundPressed,
color: s.primaryButtonTextPressed,
'Window', backgroundColor: 'WindowText', borderColor: 'WindowText' },
_c),
},
rootExpanded: {
},
rootChecked: {
},
},
rootDisabled: {
color: s.primaryButtonTextDisabled,
backgroundColor: s.primaryButtonBackgroundDisabled,
color: 'GrayText',
},
_d),
},
border: 'none',
},
_e),
},
splitButtonDividerBaseStyles()), { backgroundColor: p.white, selectors: (_f = {},
_f[Styling_1.HighContrastSelector] = {
},
_f) }),
backgroundColor: s.primaryButtonBackground,
selectors: (_g = {},
_g[Styling_1.HighContrastSelector] = {
},
_g[':hover'] = {
backgroundColor: s.primaryButtonBackgroundHovered,
selectors: (_h = {},
_h[Styling_1.HighContrastSelector] = {
color: 'Highlight',
},
_h),
},
_g),
},
selectors: {
':hover': {
},
},
},
selectors: {
':hover': {
},
},
},
selectors: {
':hover': {
},
},
},
},
color: p.neutralTertiary,
selectors: (_j = {},
_j[Styling_1.HighContrastSelector] = {
color: 'GrayText',
},
_j),
},
};
}
exports.primaryStyles = primaryStyles;
//# sourceMappingURL=ButtonThemes.js.map
/***/ }),
/***/ 82593:
"use strict";

exports.CommandBarButton = void 0;
var CommandBarButton_styles_1 = __webpack_require__(83126);
/**
*/
var CommandBarButton = /** @class */ (function (_super) {
tslib_1.__extends(CommandBarButton, _super);
function CommandBarButton() {
}
CommandBarButton.prototype.render = function () {
this.props, { variantClassName: "ms-Button--commandBar", styles:
CommandBarButton_styles_1.getStyles(theme, styles), onRenderDescription:
Utilities_1.nullRender })));
};
CommandBarButton = tslib_1.__decorate([
Utilities_1.customizable('CommandBarButton', ['theme', 'styles'], true)
], CommandBarButton);
return CommandBarButton;
exports.CommandBarButton = CommandBarButton;
//# sourceMappingURL=CommandBarButton.js.map
/***/ }),
/***/ 83126:
"use strict";

var SplitButton_styles_1 = __webpack_require__(67287);
focusInset, focusColor) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
var baseSplitButtonStyles = SplitButton_styles_1.getStyles(theme);
var p = theme.palette, semanticColors = theme.semanticColors;
var commandButtonHighContrastFocus = {
left: 4,
top: 4,
bottom: 4,
right: 4,
border: 'none',
};
var commandButtonStyles = {
root: [
Styling_1.getFocusStyle(theme, {
inset: 2,
highContrastStyle: commandButtonHighContrastFocus,
}),
theme.fonts.medium,
{
minWidth: '40px',
backgroundColor: p.white,
color: p.neutralPrimary,
padding: '0 4px',
border: 'none',
borderRadius: 0,
border: 'none',
},
_a),
},
],
rootHovered: {
backgroundColor: p.neutralLighter,
color: p.neutralDark,
color: 'Highlight',
},
_b["." +
BaseButton_classNames_1.ButtonGlobalClassNames.msButtonIcon] = {
color: p.themeDarkAlt,
},
_b["." +
BaseButton_classNames_1.ButtonGlobalClassNames.msButtonMenuIcon] = {
},
_b),
},
rootPressed: {
_c["." +
color: p.themeDark,
},
_c["." +
},
_c),
},
rootChecked: {
_d["." +
color: p.themeDark,
},
_d["." +
},
_d),
},
_e["." +
color: p.themeDark,
},
_e["." +
},
_e),
},
rootExpanded: {
selectors: (_f = {},
_f["." +
color: p.themeDark,
},
_f["." +
},
_f),
},
rootExpandedHovered: {
},
rootDisabled: {
_g["." +
color: semanticColors.disabledBodySubtext,
_h[Styling_1.HighContrastSelector] =
tslib_1.__assign({ color: 'GrayText' }, Styling_1.getHighContrastNoAdjustStyle()),
_h),
},
_g[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'GrayText', backgroundColor: 'Window' }, Styling_1.getHighContrastNoAdjustStyle()),
_g),
},
height: '100%',
border: 'none',
},
_j),
},
splitButtonDividerDisabled: {
selectors: (_k = {},
_k[Styling_1.HighContrastSelector] = {
},
_k),
},
splitButtonDivider: {
backgroundColor: p.neutralTertiaryAlt,
},
border: 'none',
borderTopRightRadius: '0',
borderBottomRightRadius: '0',
color: p.neutralSecondary,
selectors: {
':hover': {
backgroundColor: p.neutralLighter,
selectors: (_l = {},
_l[Styling_1.HighContrastSelector] = {
color: 'Highlight',
},
_l["." +
},
_l),
},
':active': {
selectors: (_m = {},
_m["." +
},
_m),
},
},
},
selectors: (_o = {},
_o[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'GrayText', border: 'none', backgroundColor: 'Window' },
_o),
},
selectors: {
':hover': {
},
},
},
color: p.black,
selectors: {
':hover': {
},
},
},
},
color: p.neutralTertiary,
},
label: {
fontWeight: 'normal', // theme.fontWeights.semibold,
},
icon: {
color: p.themePrimary,
},
menuIcon: (_p = {
color: p.neutralSecondary
},
_p[Styling_1.HighContrastSelector] = {
color: 'GrayText',
},
_p),
};
return Styling_1.concatStyleSets(baseButtonStyles, baseSplitButtonStyles,
commandButtonStyles, customStyles);
});
//# sourceMappingURL=CommandBarButton.styles.js.map
/***/ }),
/***/ 75786:
"use strict";

exports.CommandButton = void 0;
var ActionButton_1 = __webpack_require__(67176);
/**
*/
exports.CommandButton = ActionButton_1.ActionButton;
//# sourceMappingURL=CommandButton.js.map
/***/ }),
/***/ 91713:
"use strict";

exports.CompoundButton = void 0;
var CompoundButton_styles_1 = __webpack_require__(55182);
/**
*/
var CompoundButton = /** @class */ (function (_super) {
tslib_1.__extends(CompoundButton, _super);
function CompoundButton() {
}
CompoundButton.prototype.render = function () {
var _a = this.props, _b = _a.primary, primary = _b === void 0 ? false : _b,
styles = _a.styles, theme = _a.theme;
this.props, { variantClassName: primary ? 'ms-Button--compoundPrimary' : 'ms-
Button--compound', styles: CompoundButton_styles_1.getStyles(theme, styles,
primary) })));
};
CompoundButton = tslib_1.__decorate([
Utilities_1.customizable('CompoundButton', ['theme', 'styles'], true)
], CompoundButton);
return CompoundButton;
exports.CompoundButton = CompoundButton;
//# sourceMappingURL=CompoundButton.js.map
/***/ }),
/***/ 55182:
"use strict";

var ButtonThemes_1 = __webpack_require__(8028);
primary) {
var _a, _b, _c, _d, _e;
var fonts = theme.fonts, palette = theme.palette;
var splitButtonStyles = SplitButton_styles_1.getStyles(theme);
var compoundButtonStyles = {
root: {
maxWidth: '280px',
minHeight: '72px',
height: 'auto',
padding: '16px 12px',
},
flexContainer: {
flexDirection: 'row',
minWidth: '100%',
margin: '',
},
textContainer: {
textAlign: 'left',
},
icon: {
fontSize: '2em',
lineHeight: '1em',
height: '1em',
margin: '0px 8px 0px 0px',
flexBasis: '1em',
flexShrink: '0',
},
label: {
margin: '0 0 5px',
lineHeight: '100%',
fontWeight: Styling_1.FontWeights.semibold,
},
description: [
fonts.small,
{
lineHeight: '100%',
},
],
};
var standardCompoundTheme = {
description: {
color: palette.neutralSecondary,
},
descriptionHovered: {
},
descriptionPressed: {
color: 'inherit',
},
descriptionChecked: {
color: 'inherit',
},
descriptionDisabled: {
color: 'inherit',
},
};
var primaryCompoundTheme = {
description: {
color: palette.white,
_a[Styling_1.HighContrastSelector] =
tslib_1.__assign({ backgroundColor: 'WindowText', color: 'Window' },
_a),
},
descriptionHovered: {
color: 'Window',
},
_b),
},
descriptionPressed: {
color: 'inherit',
'Window', backgroundColor: 'WindowText' },
_c),
},
descriptionChecked: {
color: 'inherit',
_d[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'Window', backgroundColor: 'WindowText' },
_d),
},
descriptionDisabled: {
color: 'inherit',
color: 'inherit',
},
_e),
},
};
return Styling_1.concatStyleSets(baseButtonStyles, compoundButtonStyles,
primary ? ButtonThemes_1.primaryStyles(theme) :
ButtonThemes_1.standardStyles(theme), primary ? primaryCompoundTheme :
standardCompoundTheme, splitButtonStyles, customStyles);
});
//# sourceMappingURL=CompoundButton.styles.js.map
/***/ }),
/***/ 21349:
"use strict";

exports.DefaultButton = void 0;
var DefaultButton_styles_1 = __webpack_require__(67642);
/**
*/
var DefaultButton = /** @class */ (function (_super) {
tslib_1.__extends(DefaultButton, _super);
function DefaultButton() {
}
DefaultButton.prototype.render = function () {
var _a = this.props, _b = _a.primary, primary = _b === void 0 ? false : _b,
styles = _a.styles, theme = _a.theme;
this.props, { variantClassName: primary ? 'ms-Button--primary' : 'ms-Button--
default', styles: DefaultButton_styles_1.getStyles(theme, styles, primary),
onRenderDescription: Utilities_1.nullRender })));
};
DefaultButton = tslib_1.__decorate([
Utilities_1.customizable('DefaultButton', ['theme', 'styles'], true)
], DefaultButton);
return DefaultButton;
exports.DefaultButton = DefaultButton;
//# sourceMappingURL=DefaultButton.js.map
/***/ }),
/***/ 67642:
"use strict";

var ButtonThemes_1 = __webpack_require__(8028);
var DEFAULT_BUTTON_HEIGHT = '32px';
var DEFAULT_BUTTON_MIN_WIDTH = '80px';
primary) {
var defaultButtonStyles = {
root: {
minWidth: DEFAULT_BUTTON_MIN_WIDTH,
height: DEFAULT_BUTTON_HEIGHT,
},
label: {
},
};
return Styling_1.concatStyleSets(baseButtonStyles, defaultButtonStyles, primary
? ButtonThemes_1.primaryStyles(theme) : ButtonThemes_1.standardStyles(theme),
splitButtonStyles, customStyles);
});
//# sourceMappingURL=DefaultButton.styles.js.map
/***/ }),
/***/ 94027:
"use strict";

exports.IconButton = void 0;
var IconButton_styles_1 = __webpack_require__(59070);
/**
*/
var IconButton = /** @class */ (function (_super) {
tslib_1.__extends(IconButton, _super);
function IconButton() {
}
IconButton.prototype.render = function () {
this.props, { variantClassName: "ms-Button--icon", styles:
IconButton_styles_1.getStyles(theme, styles), onRenderText: Utilities_1.nullRender,
};
IconButton = tslib_1.__decorate([
Utilities_1.customizable('IconButton', ['theme', 'styles'], true)
], IconButton);
return IconButton;
exports.IconButton = IconButton;
//# sourceMappingURL=IconButton.js.map
/***/ }),
/***/ 59070:
"use strict";

var _a;
var palette = theme.palette, semanticColors = theme.semanticColors;
var iconButtonStyles = {
root: {
padding: '0 4px',
width: '32px',
height: '32px',
border: 'none',
color: semanticColors.link,
},
rootHovered: {
color: palette.themeDarkAlt,
backgroundColor: palette.neutralLighter,
color: 'Highlight',
},
_a),
},
rootHasMenu: {
width: 'auto',
},
rootPressed: {
color: palette.themeDark,
backgroundColor: palette.neutralLight,
},
rootExpanded: {
},
rootChecked: {
},
backgroundColor: palette.neutralQuaternaryAlt,
},
rootDisabled: {
color: palette.neutralTertiaryAlt,
},
};
return Styling_1.concatStyleSets(baseButtonStyles, iconButtonStyles,
splitButtonStyles, customStyles);
});
//# sourceMappingURL=IconButton.styles.js.map
/***/ }),
/***/ 28639:
"use strict";

exports.MessageBarButton = void 0;
var MessageBarButton_styles_1 = __webpack_require__(31109);
/**
* {@docCategory MessageBar}
*/
var MessageBarButton = /** @class */ (function (_super) {
tslib_1.__extends(MessageBarButton, _super);
function MessageBarButton() {
}
MessageBarButton.prototype.render = function () {
tslib_1.__assign({}, this.props, { styles:
MessageBarButton_styles_1.getStyles(theme, styles), onRenderDescription:
Utilities_1.nullRender }));
};
MessageBarButton = tslib_1.__decorate([
Utilities_1.customizable('MessageBarButton', ['theme', 'styles'], true)
], MessageBarButton);
return MessageBarButton;
exports.MessageBarButton = MessageBarButton;
//# sourceMappingURL=MessageBarButton.js.map
/***/ }),
/***/ 31109:
"use strict";

return Styling_1.concatStyleSets({
root: [
inset: 1,
highContrastStyle: {
outlineOffset: '-4px',
outline: '1px solid Window',
},
}),
{
height: 24,
},
],
}, customStyles);
});
//# sourceMappingURL=MessageBarButton.styles.js.map
/***/ }),
/***/ 18321:
"use strict";

exports.PrimaryButton = void 0;
/**
*/
var PrimaryButton = /** @class */ (function (_super) {
tslib_1.__extends(PrimaryButton, _super);
function PrimaryButton() {
}
PrimaryButton.prototype.render = function () {
tslib_1.__assign({}, this.props, { primary: true, onRenderDescription:
Utilities_1.nullRender }));
};
PrimaryButton = tslib_1.__decorate([
Utilities_1.customizable('PrimaryButton', ['theme', 'styles'], true)
], PrimaryButton);
return PrimaryButton;
exports.PrimaryButton = PrimaryButton;
//# sourceMappingURL=PrimaryButton.js.map
/***/ }),
/***/ 55531:
"use strict";

exports.getSplitButtonClassNames = void 0;
exports.getSplitButtonClassNames = Utilities_1.memoizeFunction(function (styles,
disabled, expanded, checked, primaryDisabled) {
return {
root: Styling_1.mergeStyles(styles.splitButtonMenuButton, expanded &&
[styles.splitButtonMenuButtonExpanded], disabled &&
[styles.splitButtonMenuButtonDisabled], checked && !disabled &&
[styles.splitButtonMenuButtonChecked], primaryDisabled &&
!disabled && [
{
selectors: {
':focus': styles.splitButtonMenuFocused,
},
},
]),
splitButtonContainer: Styling_1.mergeStyles(styles.splitButtonContainer, !
disabled &&
checked && [
styles.splitButtonContainerChecked,
{
selectors: {
':hover': styles.splitButtonContainerCheckedHovered,
},
},
], !disabled &&
!checked && [
{
selectors: {
':hover': styles.splitButtonContainerHovered,
':focus': styles.splitButtonContainerFocused,
},
},
], disabled && styles.splitButtonContainerDisabled),
icon: Styling_1.mergeStyles(styles.splitButtonMenuIcon, disabled &&
styles.splitButtonMenuIconDisabled, !disabled && primaryDisabled &&
styles.splitButtonMenuIcon),
flexContainer: Styling_1.mergeStyles(styles.splitButtonFlexContainer),
divider: Styling_1.mergeStyles(styles.splitButtonDivider, (primaryDisabled
|| disabled) && styles.splitButtonDividerDisabled),
};
});
//# sourceMappingURL=SplitButton.classNames.js.map
/***/ }),
/***/ 67287:
"use strict";

var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
var effects = theme.effects, palette = theme.palette, semanticColors =
theme.semanticColors;
var buttonHighContrastFocus = {
left: -2,
top: -2,
bottom: -2,
right: -2,
border: 'none',
};
var splitButtonDividerBaseStyles = {
width: 1,
right: 31,
top: 8,
bottom: 8,
};
var splitButtonStyles = {
splitButtonContainer: [
Styling_1.getFocusStyle(theme, { highContrastStyle:
buttonHighContrastFocus, inset: 2 }),
{
selectors: {
'.ms-Button--default': {
borderRight: 'none',
flexGrow: '1',
},
'.ms-Button--primary': {
border: 'none',
flexGrow: '1',
_a[Styling_1.HighContrastSelector] = tslib_1.__assign({
color: 'WindowText', backgroundColor: 'Window', border: '1px solid WindowText',
borderRightWidth: '0' }, Styling_1.getHighContrastNoAdjustStyle()),
_a),
},
'.ms-Button--primary + .ms-Button': {
border: 'none',
border: '1px solid WindowText',
borderLeftWidth: '0',
},
_b),
},
},
},
],
splitButtonContainerHovered: {
selectors: {
color: 'Window',
},
_c),
},
'.ms-Button.is-disabled': {
color: semanticColors.buttonTextDisabled,
color: 'GrayText',
},
_d),
},
},
},
splitButtonContainerChecked: {
selectors: {
_e[Styling_1.HighContrastSelector] =
tslib_1.__assign({ color: 'Window', backgroundColor: 'WindowText' },
_e),
},
},
},
splitButtonContainerCheckedHovered: {
selectors: {
_f[Styling_1.HighContrastSelector] =
tslib_1.__assign({ color: 'Window', backgroundColor: 'WindowText' },
_f),
},
},
},
splitButtonContainerFocused: {
outline: 'none!important',
},
splitButtonMenuButton: (_g = {
padding: 6,
height: 'auto',
borderRadius: 0,
borderTopRightRadius: effects.roundedCorner2,
borderBottomRightRadius: effects.roundedCorner2,
border: "1px solid " + palette.neutralSecondaryAlt,
borderLeft: 'none',
outline: 'transparent',
userSelect: 'none',
cursor: 'pointer',
verticalAlign: 'top',
width: 32,
marginLeft: -1,
marginTop: 0,
marginRight: 0,
marginBottom: 0
},
'.ms-Button-menuIcon': {
color: 'WindowText',
},
},
_g),
splitButtonDividerBaseStyles), { selectors: (_h = {},
},
_h) }),
splitButtonDividerDisabled: tslib_1.__assign(tslib_1.__assign({},
splitButtonDividerBaseStyles), { selectors: (_j = {},
backgroundColor: 'GrayText',
},
_j) }),
pointerEvents: 'none',
border: 'none',
selectors: (_k = {
':hover': {
cursor: 'default',
},
color: 'GrayText',
},
_l),
},
'.ms-Button-menuIcon': {
_m[Styling_1.HighContrastSelector] = {
color: 'GrayText',
},
_m),
}
},
color: 'GrayText',
border: '1px solid GrayText',
},
_k),
},
splitButtonFlexContainer: {
display: 'flex',
height: '100%',
flexWrap: 'nowrap',
},
splitButtonContainerDisabled: {
outline: 'none',
border: 'none',
_o[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'GrayText', borderColor: 'GrayText', backgroundColor: 'Window' },
_o),
},
splitButtonMenuFocused: tslib_1.__assign({}, Styling_1.getFocusStyle(theme,
{ highContrastStyle: buttonHighContrastFocus, inset: 2 })),
};
return Styling_1.concatStyleSets(splitButtonStyles, customStyles);
});
//# sourceMappingURL=SplitButton.styles.js.map
/***/ }),
/***/ 50675:
"use strict";

/***/ }),
/***/ 85772:
"use strict";

exports.CalendarBase = void 0;
var CalendarDay_1 = __webpack_require__(40968);
var CalendarMonth_1 = __webpack_require__(71888);
var react_hooks_1 = __webpack_require__(84682);
var defaults_1 = __webpack_require__(80520);
var MIN_SIZE_FORCE_OVERLAY = 440;
var getClassNames = utilities_1.classNamesFunction();
var defaultWorkWeekDays = [
date_time_utilities_1.DayOfWeek.Monday,
date_time_utilities_1.DayOfWeek.Tuesday,
date_time_utilities_1.DayOfWeek.Wednesday,
date_time_utilities_1.DayOfWeek.Thursday,
date_time_utilities_1.DayOfWeek.Friday,
];
var DEFAULT_PROPS = {
isMonthPickerVisible: true,
isDayPickerVisible: true,
showMonthPickerAsOverlay: false,
today: new Date(),
firstDayOfWeek: date_time_utilities_1.DayOfWeek.Sunday,
dateRangeType: date_time_utilities_1.DateRangeType.Day,
showGoToToday: true,
strings: date_time_utilities_1.DEFAULT_CALENDAR_STRINGS,
highlightCurrentMonth: false,
highlightSelectedMonth: false,
navigationIcons: defaults_1.defaultCalendarNavigationIcons,
showWeekNumbers: false,
firstWeekOfYear: date_time_utilities_1.FirstWeekOfYear.FirstDay,
dateTimeFormatter: date_time_utilities_1.DEFAULT_DATE_FORMATTING,
showSixWeeksByDefault: false,
workWeekDays: defaultWorkWeekDays,
showCloseButton: false,
allFocusable: false,
};
function useDateState(_a) {
var value = _a.value, _b = _a.today, today = _b === void 0 ? new Date() : _b,
onSelectDate = _a.onSelectDate;
/** The currently selected date in the calendar */
var _c = react_hooks_1.useControllableValue(value, today), _d = _c[0],
selectedDate = _d === void 0 ? today : _d, setSelectedDate = _c[1];
/** The currently focused date in the day picker, but not necessarily selected
*/
var _e = React.useState(value), _f = _e[0], navigatedDay = _f === void 0 ?
today : _f, setNavigatedDay = _e[1];
/** The currently focused date in the month picker, but not necessarily
selected */
var _g = React.useState(value), _h = _g[0], navigatedMonth = _h === void 0 ?
today : _h, setNavigatedMonth = _g[1];
/** If using a controlled value, when that value changes, navigate to that date
*/
var _j = React.useState(value), _k = _j[0], lastSelectedDate = _k === void 0 ?
today : _k, setLastSelectedDate = _j[1];
if (value && lastSelectedDate.valueOf() !== value.valueOf()) {
setNavigatedDay(value);
setNavigatedMonth(value);
setLastSelectedDate(value);
}
var navigateMonth = function (date) {
setNavigatedMonth(date);
};
var navigateDay = function (date) {
setNavigatedDay(date);
};
var onDateSelected = function (date, selectedDateRangeArray) {
setNavigatedDay(date);
setSelectedDate(date);
onSelectDate === null || onSelectDate === void 0 ? void 0 :
onSelectDate(date, selectedDateRangeArray);
};
return [selectedDate, navigatedDay, navigatedMonth, onDateSelected,
navigateDay, navigateMonth];
}
function useVisibilityState(props) {
/** State used to show/hide month picker */
var _a =
react_hooks_1.useControllableValue(getShowMonthPickerAsOverlay(props) ? undefined :
props.isMonthPickerVisible, false), _b = _a[0], isMonthPickerVisible = _b === void
0 ? true : _b, setIsMonthPickerVisible = _a[1];
/** State used to show/hide day picker */
var _c =
react_hooks_1.useControllableValue(getShowMonthPickerAsOverlay(props) ? undefined :
props.isDayPickerVisible, true), _d = _c[0], isDayPickerVisible = _d === void 0 ?
true : _d, setIsDayPickerVisible = _c[1];
var toggleDayMonthPickerVisibility = function () {
setIsMonthPickerVisible(!isMonthPickerVisible);
setIsDayPickerVisible(!isDayPickerVisible);
};
return [isMonthPickerVisible, isDayPickerVisible,
toggleDayMonthPickerVisibility];
}
function useFocusLogic(_a, isDayPickerVisible, isMonthPickerVisible) {
var componentRef = _a.componentRef;
var dayPicker = React.useRef(null);
var monthPicker = React.useRef(null);
var focusOnUpdate = React.useRef(false);
var focus = React.useCallback(function () {
if (isDayPickerVisible && dayPicker.current) {
utilities_1.focusAsync(dayPicker.current);
}
else if (isMonthPickerVisible && monthPicker.current) {
utilities_1.focusAsync(monthPicker.current);
}
}, [isDayPickerVisible, isMonthPickerVisible]);
React.useImperativeHandle(componentRef, function () { return ({ focus:
focus }); }, [focus]);
if (focusOnUpdate.current) {
focus();
focusOnUpdate.current = false;
}
});
var focusOnNextUpdate = function () {
focusOnUpdate.current = true;
};
return [dayPicker, monthPicker, focusOnNextUpdate];
}
exports.CalendarBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
var props = utilities_1.getPropsWithDefaults(DEFAULT_PROPS,
propsWithoutDefaults);
var _a = useDateState(props), selectedDate = _a[0], navigatedDay = _a[1],
navigatedMonth = _a[2], onDateSelected = _a[3], navigateDay = _a[4], navigateMonth
= _a[5];
var _b = useVisibilityState(props), isMonthPickerVisible = _b[0],
isDayPickerVisible = _b[1], toggleDayMonthPickerVisibility = _b[2];
var _c = useFocusLogic(props, isDayPickerVisible, isMonthPickerVisible),
dayPicker = _c[0], monthPicker = _c[1], focusOnNextUpdate = _c[2];
var renderGoToTodayButton = function () {
var goTodayEnabled = showGoToToday;
if (goTodayEnabled && today) {
goTodayEnabled =
navigatedDay.getFullYear() !== today.getFullYear() ||
navigatedDay.getMonth() !== today.getMonth() ||
navigatedMonth.getFullYear() !== today.getFullYear() ||
navigatedMonth.getMonth() !== today.getMonth();
}
return (showGoToToday && (React.createElement("button", { className:
utilities_1.css('js-goToday', classes.goTodayButton), onClick: onGotoToday,
onKeyDown: onButtonKeyDown(onGotoToday), type: "button", disabled: !
goTodayEnabled }, strings.goToToday)));
};
var onNavigateDayDate = function (date, focusOnNavigatedDay) {
navigateDay(date);
if (focusOnNavigatedDay) {
focusOnNextUpdate();
}
};
var onNavigateMonthDate = function (date, focusOnNavigatedDay) {
if (focusOnNavigatedDay) {
}
if (!focusOnNavigatedDay) {
navigateMonth(date);
return;
}
if (monthPickerOnly) {
onDateSelected(date);
}
navigateDay(date);
};
var onHeaderSelect = getShowMonthPickerAsOverlay(props)
? function () {
toggleDayMonthPickerVisibility();
}
: undefined;
var onGotoToday = function () {
navigateDay(today);
};
var onButtonKeyDown = function (callback) {
return function (ev) {
switch (ev.which) {
case utilities_1.KeyCodes.space:
callback();
break;
}
};
};
var onDatePickerPopupKeyDown = function (ev) {
var _a;
switch (ev.which) {
break;
case utilities_1.KeyCodes.backspace:
break;
case utilities_1.KeyCodes.escape:
(_a = props.onDismiss) === null || _a === void 0 ? void 0 :
_a.call(props);
break;
case utilities_1.KeyCodes.pageUp:
if (ev.ctrlKey) {
// go to next year
navigateDay(date_time_utilities_1.addYears(navigatedDay, 1));
}
else {
// go to next month
navigateDay(date_time_utilities_1.addMonths(navigatedDay, 1));
}
break;
case utilities_1.KeyCodes.pageDown:
if (ev.ctrlKey) {
// go to previous year
navigateDay(date_time_utilities_1.addYears(navigatedDay, -1));
}
else {
// go to previous month
navigateDay(date_time_utilities_1.addMonths(navigatedDay, -1));
}
break;
default:
break;
}
};
var rootClass = 'ms-DatePicker';
var firstDayOfWeek = props.firstDayOfWeek, dateRangeType = props.dateRangeType,
strings = props.strings, showGoToToday = props.showGoToToday, highlightCurrentMonth
= props.highlightCurrentMonth, highlightSelectedMonth =
props.highlightSelectedMonth, navigationIcons = props.navigationIcons, minDate =
props.minDate, maxDate = props.maxDate, restrictedDates = props.restrictedDates,
className = props.className, showCloseButton = props.showCloseButton, allFocusable
= props.allFocusable, styles = props.styles, showWeekNumbers =
props.showWeekNumbers, theme = props.theme, calendarDayProps =
props.calendarDayProps, calendarMonthProps = props.calendarMonthProps,
dateTimeFormatter = props.dateTimeFormatter, _d = props.today, today = _d === void
0 ? new Date() : _d;
var showMonthPickerAsOverlay = getShowMonthPickerAsOverlay(props);
var monthPickerOnly = !showMonthPickerAsOverlay && !isDayPickerVisible;
var overlaidWithButton = showMonthPickerAsOverlay && showGoToToday;
var classes = getClassNames(styles, {
theme: theme,
isMonthPickerVisible: isMonthPickerVisible,
isDayPickerVisible: isDayPickerVisible,
monthPickerOnly: monthPickerOnly,
showMonthPickerAsOverlay: showMonthPickerAsOverlay,
overlaidWithButton: overlaidWithButton,
overlayedWithButton: overlaidWithButton,
showGoToToday: showGoToToday,
showWeekNumbers: showWeekNumbers,
});
var todayDateString = '';
var selectedDateString = '';
if (dateTimeFormatter && strings.todayDateFormatString) {
todayDateString = utilities_1.format(strings.todayDateFormatString,
dateTimeFormatter.formatMonthDayYear(today, strings));
}
if (dateTimeFormatter && strings.selectedDateFormatString) {
selectedDateString = utilities_1.format(strings.selectedDateFormatString,
dateTimeFormatter.formatMonthDayYear(selectedDate, strings));
}
var selectionAndTodayString = selectedDateString + ', ' + todayDateString;
return (React.createElement("div", { ref: forwardedRef, role: "group", "aria-
label": selectionAndTodayString, className: utilities_1.css(rootClass,
classes.root, className, 'ms-slideDownIn10'), onKeyDown:
onDatePickerPopupKeyDown },
React.createElement("div", { className: classes.liveRegion, "aria-live":
"polite", "aria-atomic": "true" },
React.createElement("span", null, selectedDateString)),
isDayPickerVisible && (React.createElement(CalendarDay_1.CalendarDay,
tslib_1.__assign({ selectedDate: selectedDate, navigatedDate: navigatedDay, today:
props.today, onSelectDate: onDateSelected,
onNavigateDate: onNavigateDayDate, onDismiss: props.onDismiss,
firstDayOfWeek: firstDayOfWeek, dateRangeType: dateRangeType, strings: strings,
onHeaderSelect: onHeaderSelect, navigationIcons: navigationIcons,
showWeekNumbers: props.showWeekNumbers, firstWeekOfYear: props.firstWeekOfYear,
dateTimeFormatter: props.dateTimeFormatter, showSixWeeksByDefault:
props.showSixWeeksByDefault, minDate: minDate, maxDate: maxDate, restrictedDates:
restrictedDates, workWeekDays: props.workWeekDays, componentRef: dayPicker,
showCloseButton: showCloseButton, allFocusable: allFocusable },
calendarDayProps))),
isDayPickerVisible && isMonthPickerVisible && React.createElement("div",
{ className: classes.divider }),
isMonthPickerVisible ? (React.createElement("div", { className:
classes.monthPickerWrapper },
React.createElement(CalendarMonth_1.CalendarMonth,
tslib_1.__assign({ navigatedDate: navigatedMonth, selectedDate: navigatedDay,
strings: strings,
onNavigateDate: onNavigateMonthDate, today: props.today,
highlightCurrentMonth: highlightCurrentMonth, highlightSelectedMonth:
highlightSelectedMonth,
onHeaderSelect: onHeaderSelect, navigationIcons: navigationIcons,
dateTimeFormatter: props.dateTimeFormatter, minDate: minDate, maxDate: maxDate,
componentRef: monthPicker }, calendarMonthProps)),
renderGoToTodayButton())) : (renderGoToTodayButton()),
React.createElement(utilities_1.FocusRects, null)));
});
exports.CalendarBase.displayName = 'CalendarBase';
function getShowMonthPickerAsOverlay(_a) {
var showMonthPickerAsOverlay = _a.showMonthPickerAsOverlay, isDayPickerVisible
= _a.isDayPickerVisible;
return showMonthPickerAsOverlay || (isDayPickerVisible && win && win.innerWidth
<= MIN_SIZE_FORCE_OVERLAY);
}
//# sourceMappingURL=Calendar.base.js.map
/***/ }),
/***/ 71791:
"use strict";

exports.Calendar = void 0;
var Calendar_base_1 = __webpack_require__(85772);
var Calendar_styles_1 = __webpack_require__(17735);
exports.Calendar = utilities_1.styled(Calendar_base_1.CalendarBase,
Calendar_styles_1.styles, undefined, {
scope: 'Calendar',
});
//# sourceMappingURL=Calendar.js.map
/***/ }),
/***/ 17735:
"use strict";

exports.styles = void 0;
var styles = function (props) {
var className = props.className, theme = props.theme, isDayPickerVisible =
props.isDayPickerVisible, isMonthPickerVisible = props.isMonthPickerVisible,
showWeekNumbers = props.showWeekNumbers;
var palette = theme.palette;
var totalWidth = isDayPickerVisible && isMonthPickerVisible ? 440 : 220;
if (showWeekNumbers && isDayPickerVisible) {
totalWidth += 30;
}
return {
root: [
style_utilities_1.normalize,
{
display: 'flex',
width: totalWidth,
},
!isMonthPickerVisible && {
flexDirection: 'column',
},
className,
],
divider: {
top: 0,
borderRight: '1px solid',
borderColor: palette.neutralLight,
},
monthPickerWrapper: [
{
display: 'flex',
},
],
goTodayButton: [
style_utilities_1.getFocusStyle(theme, { inset: -1 }),
{
bottom: 0,
color: palette.neutralPrimary,
height: 30,
lineHeight: 30,
border: 'none',
boxSizing: 'content-box',
padding: '0 4px',
marginRight: 16,
marginTop: 3,
fontSize: style_utilities_1.FontSizes.small,
fontFamily: 'inherit',
selectors: {
'& div': {
},
'&:hover': {
color: palette.themePrimary,
cursor: 'pointer',
},
'&:active': {
},
'&:disabled': {
},
},
},
],
liveRegion: {
border: 0,
height: '1px',
margin: '-1px',
overflow: 'hidden',
padding: 0,
width: '1px',
},
};
};
exports.styles = styles;
//# sourceMappingURL=Calendar.styles.js.map
/***/ }),
/***/ 89474:
"use strict";

exports.AnimationDirection = void 0;
/**
* {@docCategory Calendar}
*/
var AnimationDirection;
(function (AnimationDirection) {
/**
* Grid will transition out and in horizontally
*/
AnimationDirection[AnimationDirection["Horizontal"] = 0] = "Horizontal";
/**
* Grid will transition out and in vertically
*/
AnimationDirection[AnimationDirection["Vertical"] = 1] = "Vertical";
})(AnimationDirection = exports.AnimationDirection || (exports.AnimationDirection =
{}));
//# sourceMappingURL=Calendar.types.js.map
/***/ }),
/***/ 25874:
"use strict";

exports.CalendarDayBase = void 0;
var CalendarDayGrid_1 = __webpack_require__(80153);
var CalendarDayBase = function (props) {
var dayGrid = React.useRef(null);
React.useImperativeHandle(props.componentRef, function () { return ({
focus: function () {
var _a, _b;
(_b = (_a = dayGrid.current) === null || _a === void 0 ? void 0 :
_a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
},
}); }, []);
var strings = props.strings, navigatedDate = props.navigatedDate,
dateTimeFormatter = props.dateTimeFormatter, styles = props.styles, theme =
props.theme, className = props.className, onHeaderSelect = props.onHeaderSelect,
showSixWeeksByDefault = props.showSixWeeksByDefault, minDate = props.minDate,
maxDate = props.maxDate, restrictedDates = props.restrictedDates, onNavigateDate =
props.onNavigateDate, showWeekNumbers = props.showWeekNumbers, dateRangeType =
props.dateRangeType, animationDirection = props.animationDirection;
var monthAndYearId = react_hooks_1.useId();
var classNames = getClassNames(styles, {
theme: theme,
headerIsClickable: !!onHeaderSelect,
animationDirection: animationDirection,
});
var monthAndYear = dateTimeFormatter.formatMonthYear(navigatedDate, strings);
var HeaderButtonComponentType = onHeaderSelect ? 'button' : 'div';
var headerAriaLabel = strings.yearPickerHeaderAriaLabel
? utilities_1.format(strings.yearPickerHeaderAriaLabel, monthAndYear)
: monthAndYear;
return (React.createElement("div", { className: classNames.root },
React.createElement("div", { className: classNames.header },
React.createElement(HeaderButtonComponentType, { "aria-label":
onHeaderSelect ? headerAriaLabel : undefined, className: classNames.monthAndYear,
onClick: onHeaderSelect, "data-is-focusable": !!onHeaderSelect, tabIndex:
onHeaderSelect ? 0 : -1, onKeyDown: onButtonKeyDown(onHeaderSelect), type: "button"
},
React.createElement("span", { id: monthAndYearId, "aria-live":
"polite", "aria-atomic": "true" }, monthAndYear)),
React.createElement(CalendarDayNavigationButtons, tslib_1.__assign({},
props, { classNames: classNames }))),
React.createElement(CalendarDayGrid_1.CalendarDayGrid, tslib_1.__assign({},
props, { styles: styles, componentRef: dayGrid, strings: strings, navigatedDate:
navigatedDate, weeksToShow: showSixWeeksByDefault ? 6 : undefined,
dateTimeFormatter: dateTimeFormatter, minDate: minDate, maxDate: maxDate,
restrictedDates: restrictedDates, onNavigateDate: onNavigateDate, labelledBy:
monthAndYearId, dateRangeType: dateRangeType }))));
};
exports.CalendarDayBase = CalendarDayBase;
exports.CalendarDayBase.displayName = 'CalendarDayBase';
var CalendarDayNavigationButtons = function (props) {
var _a, _b;
var minDate = props.minDate, maxDate = props.maxDate, navigatedDate =
props.navigatedDate, allFocusable = props.allFocusable, strings = props.strings,
navigationIcons = props.navigationIcons, showCloseButton = props.showCloseButton,
classNames = props.classNames, onNavigateDate = props.onNavigateDate, onDismiss =
props.onDismiss;
var onSelectNextMonth = function () {
onNavigateDate(date_time_utilities_1.addMonths(navigatedDate, 1), false);
};
var onSelectPrevMonth = function () {
onNavigateDate(date_time_utilities_1.addMonths(navigatedDate, -1), false);
};
var leftNavigationIcon = navigationIcons.leftNavigation;
var rightNavigationIcon = navigationIcons.rightNavigation;
var closeNavigationIcon = navigationIcons.closeIcon;
// determine if previous/next months are in bounds
var prevMonthInBounds = minDate ?
date_time_utilities_1.compareDatePart(minDate,
date_time_utilities_1.getMonthStart(navigatedDate)) < 0 : true;
var nextMonthInBounds = maxDate ?
date_time_utilities_1.compareDatePart(date_time_utilities_1.getMonthEnd(navigatedDa
te), maxDate) < 0 : true;
// use aria-disabled instead of disabled so focus is not lost
// when a prev/next button becomes disabled after being clicked
return (React.createElement("div", { className: classNames.monthComponents },
React.createElement("button", { className:
utilities_1.css(classNames.headerIconButton, (_a = {},
_a[classNames.disabledStyle] = !prevMonthInBounds,
_a)), tabIndex: prevMonthInBounds ? undefined : allFocusable ? 0 :
-1, "aria-disabled": !prevMonthInBounds, onClick: prevMonthInBounds ?
onSelectPrevMonth : undefined, onKeyDown: prevMonthInBounds ?
onButtonKeyDown(onSelectPrevMonth) : undefined, title: strings.prevMonthAriaLabel
? strings.prevMonthAriaLabel + ' ' +
strings.months[date_time_utilities_1.addMonths(navigatedDate, -1).getMonth()]
: undefined, type: "button" },
React.createElement(Icon_1.Icon, { iconName: leftNavigationIcon })),
utilities_1.css(classNames.headerIconButton, (_b = {},
_b[classNames.disabledStyle] = !nextMonthInBounds,
_b)), tabIndex: nextMonthInBounds ? undefined : allFocusable ? 0 :
-1, "aria-disabled": !nextMonthInBounds, onClick: nextMonthInBounds ?
onSelectNextMonth : undefined, onKeyDown: nextMonthInBounds ?
onButtonKeyDown(onSelectNextMonth) : undefined, title: strings.nextMonthAriaLabel
? strings.nextMonthAriaLabel + ' ' +
strings.months[date_time_utilities_1.addMonths(navigatedDate, 1).getMonth()]
React.createElement(Icon_1.Icon, { iconName: rightNavigationIcon })),
showCloseButton && (React.createElement("button", { className:
utilities_1.css(classNames.headerIconButton), onClick: onDismiss, onKeyDown:
onButtonKeyDown(onDismiss), title: strings.closeButtonAriaLabel, type: "button" },
React.createElement(Icon_1.Icon, { iconName:
closeNavigationIcon })))));
};
CalendarDayNavigationButtons.displayName = 'CalendarDayNavigationButtons';
var onButtonKeyDown = function (callback) { return function (ev) {
switch (ev.which) {
callback === null || callback === void 0 ? void 0 : callback();
break;
}
}; };
//# sourceMappingURL=CalendarDay.base.js.map
/***/ }),
/***/ 40968:
"use strict";

exports.CalendarDay = void 0;
var CalendarDay_base_1 = __webpack_require__(25874);
var CalendarDay_styles_1 = __webpack_require__(91252);
exports.CalendarDay = Utilities_1.styled(CalendarDay_base_1.CalendarDayBase,
CalendarDay_styles_1.styles, undefined, {
scope: 'CalendarDay',
});
//# sourceMappingURL=CalendarDay.js.map
/***/ }),
/***/ 91252:
"use strict";

var _a;
var className = props.className, theme = props.theme, headerIsClickable =
props.headerIsClickable, showWeekNumbers = props.showWeekNumbers;
var disabledStyle = {
selectors: (_a = {
'&, &:disabled, & button': {
}
},
_a[style_utilities_1.HighContrastSelector] = {
color: 'GrayText',
forcedColorAdjust: 'none',
},
_a),
};
return {
root: [
{
width: 196,
padding: 12,
},
showWeekNumbers && {
width: 226,
},
className,
],
header: {
height: 28,
lineHeight: 44,
width: '100%',
},
monthAndYear: [
style_utilities_1.getFocusStyle(theme, { inset: 1 }),
tslib_1.__assign(tslib_1.__assign({},
style_utilities_1.AnimationStyles.fadeIn200), { alignItems: 'center', fontSize:
style_utilities_1.FontSizes.medium, fontFamily: 'inherit', color:
palette.neutralPrimary, display: 'inline-block', flexGrow: 1, fontWeight:
style_utilities_1.FontWeights.semibold, padding: '0 4px 0 10px', border: 'none',
backgroundColor: 'transparent', borderRadius: 2, lineHeight: 28, overflow:
'hidden', whiteSpace: 'nowrap', textAlign: 'left', textOverflow: 'ellipsis' }),
headerIsClickable && {
selectors: {
'&:hover': {
cursor: 'pointer',
background: palette.neutralLight,
color: palette.black,
},
},
},
],
monthComponents: {
},
headerIconButton: [
{
width: 28,
height: 28,
display: 'block',
lineHeight: 28,
borderRadius: 2,
border: 'none',
padding: 0,
selectors: {
'&:hover': {
cursor: 'pointer',
outline: '1px solid transparent',
},
},
},
],
disabledStyle: disabledStyle,
};
};
//# sourceMappingURL=CalendarDay.styles.js.map
/***/ }),
/***/ 8662:
"use strict";

//# sourceMappingURL=CalendarDay.types.js.map
/***/ }),
/***/ 40799:
"use strict";

exports.CalendarMonthBase = void 0;
var CalendarMonth_styles_1 = __webpack_require__(61292);
var CalendarYear_1 = __webpack_require__(37423);
var MONTHS_PER_ROW = 4;
styles: CalendarMonth_styles_1.getStyles,
strings: undefined,
navigationIcons: defaults_1.defaultCalendarNavigationIcons,
yearPickerHidden: false,
};
function useAnimateBackwards(_a) {
var navigatedDate = _a.navigatedDate;
var currentYear = navigatedDate.getFullYear();
var previousYear = react_hooks_1.usePrevious(currentYear);
if (previousYear === undefined || previousYear === currentYear) {
return undefined;
}
else {
return previousYear > currentYear;
}
}
function useFocusLogic(_a) {
var componentRef = _a.componentRef;
var navigatedMonthRef = React.useRef(null);
var calendarYearRef = React.useRef(null);
var focusOnUpdate = React.useRef(false);
var focus = React.useCallback(function () {
if (calendarYearRef.current) {
calendarYearRef.current.focus();
}
else if (navigatedMonthRef.current) {
navigatedMonthRef.current.focus();
}
}, []);
React.useImperativeHandle(componentRef, function () { return ({ focus:
focus }); }, [focus]);
if (focusOnUpdate.current) {
focus();
focusOnUpdate.current = false;
}
});
var focusOnNextUpdate = function () {
focusOnUpdate.current = true;
};
return [navigatedMonthRef, calendarYearRef, focusOnNextUpdate];
}
var CalendarMonthBase = function (propsWithoutDefaults) {
var _a, _b;
var _c = useFocusLogic(props), navigatedMonthRef = _c[0], calendarYearRef =
_c[1], focusOnNextUpdate = _c[2];
var _d = React.useState(false), isYearPickerVisible = _d[0],
setIsYearPickerVisible = _d[1];
var animateBackwards = useAnimateBackwards(props);
var navigatedDate = props.navigatedDate, selectedDate = props.selectedDate,
strings = props.strings, _e = props.today, today = _e === void 0 ? new Date() : _e,
navigationIcons = props.navigationIcons, dateTimeFormatter =
props.dateTimeFormatter, minDate = props.minDate, maxDate = props.maxDate, theme =
props.theme, styles = props.styles, className = props.className, allFocusable =
props.allFocusable, highlightCurrentMonth = props.highlightCurrentMonth,
highlightSelectedMonth = props.highlightSelectedMonth, animationDirection =
props.animationDirection, yearPickerHidden = props.yearPickerHidden, onNavigateDate
= props.onNavigateDate;
var selectMonthCallback = function (newMonth) {
return function () { return onSelectMonth(newMonth); };
};
var onSelectNextYear = function () {
onNavigateDate(date_time_utilities_1.addYears(navigatedDate, 1), false);
};
var onSelectPrevYear = function () {
onNavigateDate(date_time_utilities_1.addYears(navigatedDate, -1), false);
};
var onSelectMonth = function (newMonth) {
var _a;
// If header is clickable the calendars are overlayed, switch back to day
picker when month is clicked
(_a = props.onHeaderSelect) === null || _a === void 0 ? void 0 :
_a.call(props);
onNavigateDate(date_time_utilities_1.setMonth(navigatedDate, newMonth),
true);
};
var onHeaderSelect = function () {
var _a;
if (!yearPickerHidden) {
setIsYearPickerVisible(true);
}
else {
_a.call(props);
}
};
var onSelectYear = function (selectedYear) {
var navYear = navigatedDate.getFullYear();
if (navYear !== selectedYear) {
var newNavigationDate = new Date(navigatedDate.getTime());
newNavigationDate.setFullYear(selectedYear);
// for min and max dates, adjust the new navigation date - perhaps this
should be
// checked on the master navigation date handler (i.e. in Calendar)
if (maxDate && newNavigationDate > maxDate) {
newNavigationDate =
date_time_utilities_1.setMonth(newNavigationDate, maxDate.getMonth());
}
else if (minDate && newNavigationDate < minDate) {
newNavigationDate =
date_time_utilities_1.setMonth(newNavigationDate, minDate.getMonth());
}
onNavigateDate(newNavigationDate, true);
}
setIsYearPickerVisible(false);
};
var onYearPickerHeaderSelect = function (focus) {
setIsYearPickerVisible(false);
};
// navigationIcons has a default value in defaultProps, but typescript doesn't
recognize this
var leftNavigationIcon = navigationIcons.leftNavigation;
var rightNavigationIcon = navigationIcons.rightNavigation;
var dateFormatter = dateTimeFormatter;
// determine if previous/next years are in bounds
var isPrevYearInBounds = minDate ?
date_time_utilities_1.getYearStart(navigatedDate)) < 0 : true;
var isNextYearInBounds = maxDate ?
date_time_utilities_1.compareDatePart(date_time_utilities_1.getYearEnd(navigatedDat
e), maxDate) < 0 : true;
theme: theme,
hasHeaderClickCallback: !!props.onHeaderSelect || !yearPickerHidden,
highlightCurrent: highlightCurrentMonth,
highlightSelected: highlightSelectedMonth,
animateBackwards: animateBackwards,
});
if (isYearPickerVisible) {
var _f = getYearStrings(props), onRenderYear = _f[0], yearStrings = _f[1];
// use navigated date for the year picker
return (React.createElement(CalendarYear_1.CalendarYear, { key:
'calendarYear', minYear: minDate ? minDate.getFullYear() : undefined, maxYear:
maxDate ? maxDate.getFullYear() : undefined,
onSelectYear: onSelectYear, navigationIcons: navigationIcons,
onHeaderSelect: onYearPickerHeaderSelect, selectedYear: selectedDate ?
selectedDate.getFullYear() : navigatedDate ? navigatedDate.getFullYear() :
undefined, onRenderYear: onRenderYear, strings: yearStrings, componentRef:
calendarYearRef, styles: styles, highlightCurrentYear: highlightCurrentMonth,
highlightSelectedYear: highlightSelectedMonth, animationDirection:
animationDirection }));
}
var rowIndexes = [];
for (var i = 0; i < strings.shortMonths.length / MONTHS_PER_ROW; i++) {
rowIndexes.push(i);
}
var yearString = dateFormatter.formatYear(navigatedDate);
var headerAriaLabel = strings.monthPickerHeaderAriaLabel
? utilities_1.format(strings.monthPickerHeaderAriaLabel, yearString)
: yearString;
React.createElement("div", { className: classNames.headerContainer },
classNames.currentItemButton, onClick: onHeaderSelect, onKeyDown:
onButtonKeyDown(onHeaderSelect), "aria-label": headerAriaLabel, "data-is-
focusable": !!props.onHeaderSelect || !yearPickerHidden, tabIndex: !!
props.onHeaderSelect || !yearPickerHidden ? 0 : -1, type: "button" },
React.createElement("span", { "aria-live": "polite", "aria-atomic":
"true" }, yearString)),
React.createElement("div", { className:
classNames.navigationButtonsContainer },
utilities_1.css(classNames.navigationButton, (_a = {},
_a[classNames.disabled] = !isPrevYearInBounds,
_a)), "aria-disabled": !isPrevYearInBounds, tabIndex:
isPrevYearInBounds ? undefined : allFocusable ? 0 : -1, onClick: isPrevYearInBounds
? onSelectPrevYear : undefined, onKeyDown: isPrevYearInBounds ?
onButtonKeyDown(onSelectPrevYear) : undefined, title: strings.prevYearAriaLabel
? strings.prevYearAriaLabel + ' ' +
dateFormatter.formatYear(date_time_utilities_1.addYears(navigatedDate, -1))
utilities_1.getRTL() ? rightNavigationIcon : leftNavigationIcon })),
utilities_1.css(classNames.navigationButton, (_b = {},
_b[classNames.disabled] = !isNextYearInBounds,
_b)), "aria-disabled": !isNextYearInBounds, tabIndex:
isNextYearInBounds ? undefined : allFocusable ? 0 : -1, onClick: isNextYearInBounds
? onSelectNextYear : undefined, onKeyDown: isNextYearInBounds ?
onButtonKeyDown(onSelectNextYear) : undefined, title: strings.nextYearAriaLabel
? strings.nextYearAriaLabel + ' ' +
dateFormatter.formatYear(date_time_utilities_1.addYears(navigatedDate, 1))
utilities_1.getRTL() ? leftNavigationIcon : rightNavigationIcon })))),
React.createElement(FocusZone_1.FocusZone, null,
React.createElement("div", { className: classNames.gridContainer, role:
"grid", "aria-label": yearString }, rowIndexes.map(function (rowNum) {
var monthsForRow = strings.shortMonths.slice(rowNum *
MONTHS_PER_ROW, (rowNum + 1) * MONTHS_PER_ROW);
return (React.createElement("div", { key: 'monthRow_' + rowNum +
navigatedDate.getFullYear(), role: "row", className: classNames.buttonRow },
monthsForRow.map(function (month, index) {
var _a;
var monthIndex = rowNum * MONTHS_PER_ROW + index;
var indexedMonth =
date_time_utilities_1.setMonth(navigatedDate, monthIndex);
var isNavigatedMonth = navigatedDate.getMonth() === monthIndex;
var isSelectedMonth = selectedDate.getMonth() === monthIndex;
var isSelectedYear = selectedDate.getFullYear() ===
navigatedDate.getFullYear();
var isInBounds = (minDate ?
date_time_utilities_1.getMonthEnd(indexedMonth)) < 1 : true) &&
(maxDate ?
date_time_utilities_1.compareDatePart(date_time_utilities_1.getMonthStart(indexedMo
nth), maxDate) < 1 : true);
return (React.createElement("button", { ref: isNavigatedMonth ?
navigatedMonthRef : undefined, role: 'gridcell', className:
utilities_1.css(classNames.itemButton, (_a = {},
_a[classNames.current] = highlightCurrentMonth &&
isCurrentMonth(monthIndex, navigatedDate.getFullYear(), today),
_a[classNames.selected] = highlightSelectedMonth &&
isSelectedMonth && isSelectedYear,
_a[classNames.disabled] = !isInBounds,
_a)), disabled: !allFocusable && !isInBounds, key:
monthIndex, onClick: isInBounds ? selectMonthCallback(monthIndex) : undefined,
onKeyDown: isInBounds ? onButtonKeyDown(selectMonthCallback(monthIndex)) :
undefined, "aria-label": dateFormatter.formatMonth(indexedMonth, strings), "aria-
selected": isNavigatedMonth, "data-is-focusable": isInBounds ? true : undefined,
type: "button" }, month));
})));
})))));
};
exports.CalendarMonthBase = CalendarMonthBase;
exports.CalendarMonthBase.displayName = 'CalendarMonthBase';
function getYearStrings(_a) {
var strings = _a.strings, navigatedDate = _a.navigatedDate, dateTimeFormatter =
_a.dateTimeFormatter;
var yearToString = function (year) {
if (dateTimeFormatter) {
// create a date based on the current nav date
var yearFormattingDate = new Date(navigatedDate.getTime());
yearFormattingDate.setFullYear(year);
return dateTimeFormatter.formatYear(yearFormattingDate);
}
return String(year);
};
var yearRangeToString = function (yearRange) {
return yearToString(yearRange.fromYear) + " - " +
yearToString(yearRange.toYear);
};
var yearRangeToNextDecadeLabel = function (yearRange) {
return strings.nextYearRangeAriaLabel ? strings.nextYearRangeAriaLabel + "
" + yearRangeToString(yearRange) : '';
};
var yearRangeToPrevDecadeLabel = function (yearRange) {
return strings.prevYearRangeAriaLabel ? strings.prevYearRangeAriaLabel + "
" + yearRangeToString(yearRange) : '';
};
return [
yearToString,
{
rangeAriaLabel: yearRangeToString,
prevRangeAriaLabel: yearRangeToPrevDecadeLabel,
nextRangeAriaLabel: yearRangeToNextDecadeLabel,
headerAriaLabelFormatString: strings.yearPickerHeaderAriaLabel,
},
];
}
function isCurrentMonth(month, year, today) {
return today.getFullYear() === year && today.getMonth() === month;
}
function onButtonKeyDown(callback) {
switch (ev.which) {
callback();
break;
}
};
}
//# sourceMappingURL=CalendarMonth.base.js.map
/***/ }),
/***/ 71888:
"use strict";

exports.CalendarMonth = void 0;
var CalendarMonth_base_1 = __webpack_require__(40799);
var CalendarMonth_styles_1 = __webpack_require__(61292);
exports.CalendarMonth = Utilities_1.styled(CalendarMonth_base_1.CalendarMonthBase,
CalendarMonth_styles_1.getStyles, undefined, { scope: 'CalendarMonth' });
//# sourceMappingURL=CalendarMonth.js.map
/***/ }),
/***/ 61292:
"use strict";

var CalendarPicker_styles_1 = __webpack_require__(99239);
/* Return styles from the base class.
* If this component has extra styles not in the base, apply them here i.e.:
* const myStyle: IStyle = {
* display: "block"
* }; *
* return {...getPickerStyles(props), myStyle};
*/
return CalendarPicker_styles_1.getStyles(props);
};
//# sourceMappingURL=CalendarMonth.styles.js.map
/***/ }),
/***/ 12643:
"use strict";

//# sourceMappingURL=CalendarMonth.types.js.map
/***/ }),
/***/ 99239:
"use strict";

var Calendar_types_1 = __webpack_require__(89474);
var _a, _b, _c, _d, _e, _f, _g;
var className = props.className, theme = props.theme, hasHeaderClickCallback =
props.hasHeaderClickCallback, highlightCurrent = props.highlightCurrent,
highlightSelected = props.highlightSelected, animateBackwards =
props.animateBackwards, animationDirection = props.animationDirection;
var animationStyle = {};
if (animateBackwards !== undefined) {
if (animationDirection === Calendar_types_1.AnimationDirection.Horizontal)
{
animationStyle = animateBackwards ?
style_utilities_1.AnimationStyles.slideRightIn20 :
style_utilities_1.AnimationStyles.slideLeftIn20;
}
else {
animationStyle = animateBackwards ?
style_utilities_1.AnimationStyles.slideDownIn20 :
style_utilities_1.AnimationStyles.slideUpIn20;
}
}
var headerAnimationStyle = animateBackwards !== undefined ?
style_utilities_1.AnimationStyles.fadeIn200 : {};
return {
root: [
{
width: 196,
padding: 12,
overflow: 'hidden',
},
className,
],
headerContainer: {
display: 'flex',
},
currentItemButton: [
tslib_1.__assign(tslib_1.__assign({}, headerAnimationStyle),
{ fontSize: style_utilities_1.FontSizes.medium, fontWeight:
style_utilities_1.FontWeights.semibold, fontFamily: 'inherit', textAlign: 'left',
color: 'inherit', backgroundColor: 'transparent', flexGrow: 1, padding: '0 4px 0
10px', border: 'none', overflow: 'visible' }),
hasHeaderClickCallback && {
selectors: {
'&:hover, &:active': {
cursor: !hasHeaderClickCallback ? 'default' : 'pointer',
},
},
},
],
navigationButtonsContainer: {
display: 'flex',
},
navigationButton: [
{
width: 28,
minWidth: 28,
height: 28,
minHeight: 28,
display: 'block',
lineHeight: 28,
borderRadius: 2,
border: 'none',
padding: 0,
selectors: {
'&:hover': {
cursor: 'pointer',
},
},
},
],
gridContainer: {
marginTop: 4,
},
buttonRow: tslib_1.__assign(tslib_1.__assign({}, animationStyle),
{ marginBottom: 16, selectors: {
'&:nth-child(n + 3)': {
marginBottom: 0,
},
} }),
itemButton: [
{
width: 40,
height: 40,
minWidth: 40,
minHeight: 40,
lineHeight: 40,
padding: 0,
margin: '0 12px 0 0',
border: 'none',
borderRadius: 2,
selectors: {
'&:nth-child(4n + 4)': {
marginRight: 0,
},
'&:nth-child(n + 9)': {
marginBottom: 0,
},
'& div': {
fontWeight: style_utilities_1.FontWeights.regular,
},
'&:hover': {
cursor: 'pointer',
_a[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ background: 'Window', color: 'WindowText', outline: '1px solid
Highlight' }, style_utilities_1.getHighContrastNoAdjustStyle()),
_a),
},
'&:active': {
backgroundColor: palette.themeLight,
_b[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ background: 'Window', color: 'Highlight' },
style_utilities_1.getHighContrastNoAdjustStyle()),
_b),
},
},
},
],
current: highlightCurrent
? {
backgroundColor: palette.themePrimary,
selectors: (_c = {
'& div': {
fontWeight: style_utilities_1.FontWeights.semibold,
},
'&:hover': {
_d[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ backgroundColor: 'WindowText', color: 'Window' },
_d),
}
},
_c[style_utilities_1.HighContrastSelector] = tslib_1.__assign({
backgroundColor: 'WindowText', color: 'Window' },
_c),
}
: {},
selected: highlightSelected
? {
selectors: (_e = {
'& div': {
},
'&:hover, &:active': {
_f[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ color: 'Window', background: 'Highlight' },
_f),
}
},
_e[style_utilities_1.HighContrastSelector] = tslib_1.__assign({
background: 'Highlight', color: 'Window' },
_e),
}
: {},
disabled: {
selectors: (_g = {
}
},
_g[style_utilities_1.HighContrastSelector] = {
color: 'GrayText',
},
_g),
},
};
};
//# sourceMappingURL=CalendarPicker.styles.js.map
/***/ }),
/***/ 61320:
"use strict";

//# sourceMappingURL=CalendarPicker.types.js.map
/***/ }),
/***/ 11816:
"use strict";

exports.CalendarYearBase = void 0;
var CELL_COUNT = 12;
var CELLS_PER_ROW = 4;
var DefaultCalendarYearStrings = {
prevRangeAriaLabel: undefined,
nextRangeAriaLabel: undefined,
};
var CalendarYearGridCell = function (props) {
var _a;
var _b;
var styles = props.styles, theme = props.theme, className = props.className,
highlightCurrentYear = props.highlightCurrentYear, highlightSelectedYear =
props.highlightSelectedYear, year = props.year, selected = props.selected, disabled
= props.disabled, componentRef = props.componentRef, onSelectYear =
props.onSelectYear, onRenderYear = props.onRenderYear;
var buttonRef = React.useRef(null);
React.useImperativeHandle(componentRef, function () { return ({
var _a, _b;
(_b = (_a = buttonRef.current) === null || _a === void 0 ? void 0 :
},
}); }, []);
var onClick = function () {
onSelectYear === null || onSelectYear === void 0 ? void 0 :
onSelectYear(year);
};
var onKeyDown = function (ev) {
if (ev.which === Utilities_1.KeyCodes.enter) {
onSelectYear === null || onSelectYear === void 0 ? void 0 :
onSelectYear(year);
}
};
theme: theme,
highlightCurrent: highlightCurrentYear,
highlightSelected: highlightSelectedYear,
});
return (React.createElement("button", { className:
Utilities_1.css(classNames.itemButton, (_a = {},
_a[classNames.selected] = selected,
_a[classNames.disabled] = disabled,
_a)), type: "button", role: "gridcell", onClick: !disabled ? onClick :
undefined, onKeyDown: !disabled ? onKeyDown : undefined, disabled: disabled, "aria-
selected": selected, ref: buttonRef }, (_b = onRenderYear === null || onRenderYear
=== void 0 ? void 0 : onRenderYear(year)) !== null && _b !== void 0 ? _b : year));
};
CalendarYearGridCell.displayName = 'CalendarYearGridCell';
var CalendarYearGrid = function (props) {
fromYear = props.fromYear, toYear = props.toYear, animationDirection =
props.animationDirection, animateBackwards = props.animateBackwards, minYear =
props.minYear, maxYear = props.maxYear, onSelectYear = props.onSelectYear,
selectedYear = props.selectedYear, componentRef = props.componentRef;
var selectedCellRef = React.useRef(null);
var currentCellRef = React.useRef(null);
var _a, _b;
(_b = (_a = (selectedCellRef.current || currentCellRef.current)) ===
null || _a === void 0 ? void 0 : _a.focus) === null || _b === void 0 ? void 0 :
_b.call(_a);
},
}); }, []);
var renderCell = function (yearToRender) {
var selected = yearToRender === selectedYear;
var disabled = (minYear !== undefined && yearToRender < minYear) ||
(maxYear !== undefined && yearToRender > maxYear);
var current = yearToRender === new Date().getFullYear();
return (React.createElement(CalendarYearGridCell, tslib_1.__assign({},
props, { key: yearToRender, year: yearToRender, selected: selected, current:
current, disabled: disabled, onSelectYear: onSelectYear, componentRef: selected ?
selectedCellRef : current ? currentCellRef : undefined, theme: theme })));
};
theme: theme,
});
var onRenderYear = function (value) {
var _a, _b;
return (_b = (_a = props.onRenderYear) === null || _a === void 0 ? void 0 :
_a.call(props, value)) !== null && _b !== void 0 ? _b : value;
};
var gridAriaLabel = onRenderYear(fromYear) + " - " + onRenderYear(toYear);
var year = fromYear;
var cells = [];
for (var i = 0; i < (toYear - fromYear + 1) / CELLS_PER_ROW; i++) {
cells.push([]);
for (var j = 0; j < CELLS_PER_ROW; j++) {
cells[i].push(renderCell(year));
year++;
}
}
return (React.createElement(FocusZone_1.FocusZone, null,
React.createElement("div", { className: classNames.gridContainer, role:
"grid", "aria-label": gridAriaLabel }, cells.map(function (cellRow, index) {
return (React.createElement("div", { key: 'yearPickerRow_' + index +
'_' + fromYear, role: "row", className: classNames.buttonRow }, cellRow));
}))));
};
CalendarYearGrid.displayName = 'CalendarYearGrid';
var CalendarYearNavDirection;
(function (CalendarYearNavDirection) {
CalendarYearNavDirection[CalendarYearNavDirection["Previous"] = 0] =
"Previous";
CalendarYearNavDirection[CalendarYearNavDirection["Next"] = 1] = "Next";
})(CalendarYearNavDirection || (CalendarYearNavDirection = {}));
var CalendarYearNavArrow = function (props) {
var _a;
var styles = props.styles, theme = props.theme, className = props.className, _b
= props.navigationIcons, navigationIcons = _b === void 0 ?
defaults_1.defaultCalendarNavigationIcons : _b, _c = props.strings, strings = _c
=== void 0 ? DefaultCalendarYearStrings : _c, direction = props.direction,
onSelectPrev = props.onSelectPrev, onSelectNext = props.onSelectNext, fromYear =
props.fromYear, toYear = props.toYear, maxYear = props.maxYear, minYear =
props.minYear;
theme: theme,
});
var ariaLabel = direction === CalendarYearNavDirection.Previous ?
strings.prevRangeAriaLabel : strings.nextRangeAriaLabel;
var newRangeOffset = direction === CalendarYearNavDirection.Previous ? -
CELL_COUNT : CELL_COUNT;
var newRange = { fromYear: fromYear + newRangeOffset, toYear: toYear +
newRangeOffset };
var ariaLabelString = ariaLabel ? (typeof ariaLabel === 'string' ? ariaLabel :
ariaLabel(newRange)) : undefined;
var disabled = direction === CalendarYearNavDirection.Previous
? minYear !== undefined && fromYear < minYear
: maxYear !== undefined && props.fromYear + CELL_COUNT > maxYear;
var onNavigate = function () {
direction === CalendarYearNavDirection.Previous ? onSelectPrev === null ||
onSelectPrev === void 0 ? void 0 : onSelectPrev() : onSelectNext === null ||
onSelectNext === void 0 ? void 0 : onSelectNext();
};
onNavigate();
}
};
// can be condensed, but leaving verbose for clarity due to regressions
var isLeftNavigation = Utilities_1.getRTL()
? direction === CalendarYearNavDirection.Next
: direction === CalendarYearNavDirection.Previous;
Utilities_1.css(classNames.navigationButton, (_a = {},
_a[classNames.disabled] = disabled,
_a)), onClick: !disabled ? onNavigate : undefined, onKeyDown: !disabled
? onKeyDown : undefined, type: "button", title: ariaLabelString, disabled: disabled
},
React.createElement(Icon_1.Icon, { iconName: isLeftNavigation ?
navigationIcons.leftNavigation : navigationIcons.rightNavigation })));
};
CalendarYearNavArrow.displayName = 'CalendarYearNavArrow';
var CalendarYearNav = function (props) {
var styles = props.styles, theme = props.theme, className = props.className;
theme: theme,
});
return (React.createElement("div", { className:
classNames.navigationButtonsContainer },
React.createElement(CalendarYearNavArrow, tslib_1.__assign({}, props,
{ direction: CalendarYearNavDirection.Previous })),
React.createElement(CalendarYearNavArrow, tslib_1.__assign({}, props,
{ direction: CalendarYearNavDirection.Next }))));
};
CalendarYearNav.displayName = 'CalendarYearNav';
var CalendarYearTitle = function (props) {
fromYear = props.fromYear, toYear = props.toYear, _a = props.strings, strings = _a
=== void 0 ? DefaultCalendarYearStrings : _a, animateBackwards =
props.animateBackwards, animationDirection = props.animationDirection;
var onHeaderSelect = function () {
var _a;
_a.call(props, true);
};
var onHeaderKeyDown = function (ev) {
onHeaderSelect();
}
};
var onRenderYear = function (year) {
var _a, _b;
return (_b = (_a = props.onRenderYear) === null || _a === void 0 ? void 0 :
_a.call(props, year)) !== null && _b !== void 0 ? _b : year;
};
theme: theme,
hasHeaderClickCallback: !!props.onHeaderSelect,
});
if (props.onHeaderSelect) {
var rangeAriaLabel = strings.rangeAriaLabel;
var headerAriaLabelFormatString = strings.headerAriaLabelFormatString;
var currentDateRange = rangeAriaLabel
? typeof rangeAriaLabel === 'string'
? rangeAriaLabel
: rangeAriaLabel(props)
: undefined;
var ariaLabel = headerAriaLabelFormatString
? Utilities_1.format(headerAriaLabelFormatString, currentDateRange)
: currentDateRange;
classNames.currentItemButton, onClick: onHeaderSelect, onKeyDown: onHeaderKeyDown,
"aria-label": ariaLabel, role: "button", type: "button" },
React.createElement("span", { "aria-live": "assertive", "aria-atomic":
"true" },
onRenderYear(fromYear),
" - ",
onRenderYear(toYear))));
}
return (React.createElement("div", { className: classNames.current },
onRenderYear(fromYear),
" - ",
onRenderYear(toYear)));
};
CalendarYearTitle.displayName = 'CalendarYearTitle';
var CalendarYearHeader = function (props) {
var _a;
animateBackwards = props.animateBackwards, animationDirection =
props.animationDirection, onRenderTitle = props.onRenderTitle;
theme: theme,
hasHeaderClickCallback: !!props.onHeaderSelect,
});
return (React.createElement("div", { className: classNames.headerContainer },
(_a = onRenderTitle === null || onRenderTitle === void 0 ? void 0 :
onRenderTitle(props)) !== null && _a !== void 0 ? _a :
React.createElement(CalendarYearTitle, tslib_1.__assign({}, props)),
React.createElement(CalendarYearNav, tslib_1.__assign({}, props))));
};
CalendarYearHeader.displayName = 'CalendarYearHeader';
function useAnimateBackwards(_a) {
var selectedYear = _a.selectedYear, navigatedYear = _a.navigatedYear;
var rangeYear = selectedYear || navigatedYear || new Date().getFullYear();
var fromYear = Math.floor(rangeYear / 10) * 10;
var previousFromYear = react_hooks_1.usePrevious(fromYear);
if (!previousFromYear || previousFromYear === fromYear) {
return undefined;
}
else if (previousFromYear > fromYear) {
return true;
}
else {
return false;
}
}
var NavigationDirection;
(function (NavigationDirection) {
NavigationDirection[NavigationDirection["Previous"] = 0] = "Previous";
NavigationDirection[NavigationDirection["Next"] = 1] = "Next";
})(NavigationDirection || (NavigationDirection = {}));
function useYearRangeState(_a) {
var selectedYear = _a.selectedYear, navigatedYear = _a.navigatedYear;
var _b = React.useReducer(function (state, action) {
return state + (action === NavigationDirection.Next ? CELL_COUNT : -
CELL_COUNT);
}, undefined, function () {
var rangeYear = selectedYear || navigatedYear || new Date().getFullYear();
return Math.floor(rangeYear / 10) * 10;
}), fromYear = _b[0], navigate = _b[1];
var toYear = fromYear + CELL_COUNT - 1;
var onNavNext = function () { return navigate(NavigationDirection.Next); };
var onNavPrevious = function () { return
navigate(NavigationDirection.Previous); };
return [fromYear, toYear, onNavNext, onNavPrevious];
}
var CalendarYearBase = function (props) {
var animateBackwards = useAnimateBackwards(props);
var _a = useYearRangeState(props), fromYear = _a[0], toYear = _a[1], onNavNext
= _a[2], onNavPrevious = _a[3];
var gridRef = React.useRef(null);
var _a, _b;
(_b = (_a = gridRef.current) === null || _a === void 0 ? void 0 :
},
}); });
var styles = props.styles, theme = props.theme, className = props.className;
theme: theme,
});
React.createElement(CalendarYearHeader, tslib_1.__assign({}, props,
{ fromYear: fromYear, toYear: toYear, onSelectPrev: onNavPrevious, onSelectNext:
onNavNext, animateBackwards: animateBackwards })),
React.createElement(CalendarYearGrid, tslib_1.__assign({}, props,
{ fromYear: fromYear, toYear: toYear, animateBackwards: animateBackwards,
componentRef: gridRef }))));
};
exports.CalendarYearBase = CalendarYearBase;
exports.CalendarYearBase.displayName = 'CalendarYearBase';
//# sourceMappingURL=CalendarYear.base.js.map
/***/ }),
/***/ 37423:
"use strict";

exports.CalendarYear = void 0;
var CalendarYear_styles_1 = __webpack_require__(57067);
var CalendarYear_base_1 = __webpack_require__(11816);
exports.CalendarYear = Utilities_1.styled(CalendarYear_base_1.CalendarYearBase,
CalendarYear_styles_1.getStyles, undefined, { scope: 'CalendarYear' });
//# sourceMappingURL=CalendarYear.js.map
/***/ }),
/***/ 57067:
"use strict";

var CalendarPicker_styles_1 = __webpack_require__(99239);
/* Return styles from the base class.
* If this component has extra styles not in the base, apply them here i.e.:
* const myStyle: IStyle = {
* display: "block"
* };
* return {...getPickerStyles(props), myStyle};
*/
return CalendarPicker_styles_1.getStyles(props);
};
//# sourceMappingURL=CalendarYear.styles.js.map
/***/ }),
/***/ 42072:
"use strict";

//# sourceMappingURL=CalendarYear.types.js.map
/***/ }),
/***/ 80520:
"use strict";

exports.defaultCalendarNavigationIcons = exports.defaultDayPickerStrings =
exports.defaultCalendarStrings = void 0;
exports.defaultCalendarStrings = date_time_utilities_1.DEFAULT_CALENDAR_STRINGS;
/**
* @deprecated Use `defaultCalendarStrings`
*/
exports.defaultDayPickerStrings = exports.defaultCalendarStrings;
exports.defaultCalendarNavigationIcons = {
leftNavigation: 'Up',
rightNavigation: 'Down',
closeIcon: 'CalculatorMultiply',
};
//# sourceMappingURL=defaults.js.map
/***/ }),
/***/ 93073:
"use strict";

exports.FirstWeekOfYear = exports.DateRangeType = exports.DayOfWeek = void 0;
Object.defineProperty(exports, "DayOfWeek", ({ enumerable: true, get: function () {
return date_time_utilities_1.DayOfWeek; } }));
Object.defineProperty(exports, "DateRangeType", ({ enumerable: true, get: function
() { return date_time_utilities_1.DateRangeType; } }));
Object.defineProperty(exports, "FirstWeekOfYear", ({ enumerable: true, get:
function () { return date_time_utilities_1.FirstWeekOfYear; } }));
/***/ }),
/***/ 18116:
"use strict";

exports.CalendarDayGridBase = void 0;
var CalendarMonthHeaderRow_1 = __webpack_require__(79565);
var CalendarGridRow_1 = __webpack_require__(12579);
function useDayRefs() {
var daysRef = React.useRef({});
var getSetRefCallback = function (dayKey) { return function (element) {
if (element === null) {
delete daysRef.current[dayKey];
}
else {
daysRef.current[dayKey] = element;
}
}; };
return [daysRef, getSetRefCallback];
}
function useWeeks(props, onSelectDate, getSetRefCallback) {
/**
* Initial parsing of the given props to generate IDayInfo two dimensional
array, which contains a representation
* of every day in the grid. Convenient for helping with conversions between
day refs and Date objects in callbacks.
*/
var weeks = React.useMemo(function () {
var _a;
var weeksGrid = date_time_utilities_1.getDayGrid(props);
var firstVisibleDay = weeksGrid[1][0].originalDate;
var lastVisibleDay = weeksGrid[weeksGrid.length - 1][6].originalDate;
var markedDays = ((_a = props.getMarkedDays) === null || _a === void 0 ?
void 0 : _a.call(props, firstVisibleDay, lastVisibleDay)) || [];
/**
* Weeks is a 2D array. Weeks[0] contains the last week of the prior range,
* Weeks[weeks.length - 1] contains first week of next range. These are for
transition states.
*
* Weeks[1... weeks.length - 2] contains the actual visible data
*/
var returnValue = [];
for (var weekIndex = 0; weekIndex < weeksGrid.length; weekIndex++) {
var week = [];
var _loop_1 = function (dayIndex) {
var day = weeksGrid[weekIndex][dayIndex];
var dayInfo = tslib_1.__assign(tslib_1.__assign({ onSelected:
function () { return onSelectDate(day.originalDate); }, setRef:
getSetRefCallback(day.key) }, day), { isMarked: day.isMarked || (markedDays ===
null || markedDays === void 0 ? void 0 : markedDays.some(function (markedDay)
{ return date_time_utilities_1.compareDates(day.originalDate, markedDay); })) });
week.push(dayInfo);
};
for (var dayIndex = 0; dayIndex < date_time_utilities_1.DAYS_IN_WEEK;
dayIndex++) {
_loop_1(dayIndex);
}
returnValue.push(week);
}
return returnValue;
// TODO: this is missing deps on getSetRefCallback and onSelectDate (and
depending on the entire
// props object may not be a good idea due to likely frequent mutation). It
would be easy to
// fix getSetRefCallback to not mutate every render, but onSelectDate is
passed down from
// Calendar and trying to fix it requires a huge cascade of changes.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [props]);
return weeks;
}
/**
* Hook to determine whether to animate the CalendarDayGrid forwards or backwards
* @returns true if the grid should animate backwards; false otherwise
*/
function useAnimateBackwards(weeks) {
var previousNavigatedDate = react_hooks_1.usePrevious(weeks[0]
[0].originalDate);
if (!previousNavigatedDate || previousNavigatedDate.getTime() === weeks[0]
[0].originalDate.getTime()) {
return undefined;
}
else if (previousNavigatedDate <= weeks[0][0].originalDate) {
return false;
}
else {
return true;
}
}
function useWeekCornerStyles(props) {
/**
*
* Section for setting the rounded corner styles on individual day cells.
Individual day cells need different
* corners to be rounded depending on which date range type and where the cell
is located in the current grid.
* If we just round all of the corners, there isn't a good overlap and we get
gaps between contiguous day boxes
* in Edge browser.
*
*/
var getWeekCornerStyles = function (classNames, initialWeeks) {
var weekCornersStyled = {};
/* need to handle setting all of the corners on arbitrarily shaped blobs
__
__|A |
|B |C |__
|D |E |F |
in this case, A needs top left rounded, top right rounded

B needs top left rounded
C doesn't need any rounding
D needs bottom left rounded
E doesn't need any rounding
F needs top right rounding
*/
// cut off the animation transition weeks
var weeks = initialWeeks.slice(1, initialWeeks.length - 1);
// if there's an item above, lose both top corners. Item below, lose both
bottom corners, etc.
weeks.forEach(function (week, weekIndex) {
week.forEach(function (day, dayIndex) {
var above = weeks[weekIndex - 1] &&
weeks[weekIndex - 1][dayIndex] &&
isInSameHoverRange(weeks[weekIndex - 1][dayIndex].originalDate,
day.originalDate, weeks[weekIndex - 1][dayIndex].isSelected, day.isSelected);
var below = weeks[weekIndex + 1] &&
weeks[weekIndex + 1][dayIndex] &&
isInSameHoverRange(weeks[weekIndex + 1][dayIndex].originalDate,
day.originalDate, weeks[weekIndex + 1][dayIndex].isSelected, day.isSelected);
var left = weeks[weekIndex][dayIndex - 1] &&
isInSameHoverRange(weeks[weekIndex][dayIndex - 1].originalDate,
day.originalDate, weeks[weekIndex][dayIndex - 1].isSelected, day.isSelected);
var right = weeks[weekIndex][dayIndex + 1] &&
isInSameHoverRange(weeks[weekIndex][dayIndex + 1].originalDate,
day.originalDate, weeks[weekIndex][dayIndex + 1].isSelected, day.isSelected);
var style = [];
style.push(calculateRoundedStyles(classNames, above, below, left,
right));
style.push(calculateBorderStyles(classNames, above, below, left,
right));
weekCornersStyled[weekIndex + '_' + dayIndex] = style.join(' ');
});
});
return weekCornersStyled;
};
var calculateRoundedStyles = function (classNames, above, below, left, right) {
var style = [];
var roundedTopLeft = !above && !left;
var roundedTopRight = !above && !right;
var roundedBottomLeft = !below && !left;
var roundedBottomRight = !below && !right;
if (roundedTopLeft) {
style.push(utilities_1.getRTL() ? classNames.topRightCornerDate :
classNames.topLeftCornerDate);
}
if (roundedTopRight) {
style.push(utilities_1.getRTL() ? classNames.topLeftCornerDate :
classNames.topRightCornerDate);
}
if (roundedBottomLeft) {
style.push(utilities_1.getRTL() ? classNames.bottomRightCornerDate :
classNames.bottomLeftCornerDate);
}
if (roundedBottomRight) {
style.push(utilities_1.getRTL() ? classNames.bottomLeftCornerDate :
classNames.bottomRightCornerDate);
}
return style.join(' ');
};
var calculateBorderStyles = function (classNames, above, below, left, right) {
var style = [];
if (!above) {
style.push(classNames.datesAbove);
}
if (!below) {
style.push(classNames.datesBelow);
}
if (!left) {
style.push(utilities_1.getRTL() ? classNames.datesRight :
classNames.datesLeft);
}
if (!right) {
style.push(utilities_1.getRTL() ? classNames.datesLeft :
classNames.datesRight);
}
return style.join(' ');
};
var isInSameHoverRange = function (date1, date2, date1Selected, date2Selected)
{
var dateRangeType = props.dateRangeType, firstDayOfWeek =
props.firstDayOfWeek, workWeekDays = props.workWeekDays;
// The hover state looks weird with non-contiguous days in work week view.
In work week, show week hover state
var dateRangeHoverType = dateRangeType ===
date_time_utilities_1.DateRangeType.WorkWeek ?
date_time_utilities_1.DateRangeType.Week : dateRangeType;
// we do not pass daysToSelectInDayView because we handle setting those
styles dyanamically in onMouseOver
var dateRange = date_time_utilities_1.getDateRangeArray(date1,
dateRangeHoverType, firstDayOfWeek, workWeekDays);
if (date1Selected !== date2Selected) {
// if one is selected and the other is not, they can't be in the same
range
return false;
}
else if (date1Selected && date2Selected) {
// if they're both selected at the same time they must be in the same
range
return true;
}
// otherwise, both must be unselected, so check the dateRange
return dateRange.filter(function (date) { return date.getTime() ===
date2.getTime(); }).length > 0;
};
return [getWeekCornerStyles, calculateRoundedStyles];
}
var CalendarDayGridBase = function (props) {
var navigatedDayRef = React.useRef(null);
var activeDescendantId = react_hooks_1.useId();
var onSelectDate = function (selectedDate) {
var _a, _b;
var firstDayOfWeek = props.firstDayOfWeek, minDate = props.minDate, maxDate
= props.maxDate, workWeekDays = props.workWeekDays, daysToSelectInDayView =
props.daysToSelectInDayView, restrictedDates = props.restrictedDates;
var restrictedDatesOptions = { minDate: minDate, maxDate: maxDate,
restrictedDates: restrictedDates };
var dateRange = date_time_utilities_1.getDateRangeArray(selectedDate,
dateRangeType, firstDayOfWeek, workWeekDays, daysToSelectInDayView);
dateRange = date_time_utilities_1.getBoundedDateRange(dateRange, minDate,
maxDate);
dateRange = dateRange.filter(function (d) {
return !date_time_utilities_1.isRestrictedDate(d,
restrictedDatesOptions);
});
(_a = props.onSelectDate) === null || _a === void 0 ? void 0 :
_a.call(props, selectedDate, dateRange);
(_b = props.onNavigateDate) === null || _b === void 0 ? void 0 :
_b.call(props, selectedDate, true);
};
var _a = useDayRefs(), daysRef = _a[0], getSetRefCallback = _a[1];
var weeks = useWeeks(props, onSelectDate, getSetRefCallback);
var animateBackwards = useAnimateBackwards(weeks);
var _b = useWeekCornerStyles(props), getWeekCornerStyles = _b[0],
calculateRoundedStyles = _b[1];
var _a, _b;
(_b = (_a = navigatedDayRef.current) === null || _a === void 0 ? void 0
: _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
},
}); }, []);
/**
*
* Section for setting hover/pressed styles. Because we want arbitrary blobs of
days to be selectable, to support
* highlighting every day in the month for month view, css :hover style isn't
enough, so we need mouse callbacks
* to set classnames on all relevant child refs to apply the styling
*
*/
var getDayInfosInRangeOfDay = function (dayToCompare) {
// The hover state looks weird with non-contiguous days in work week view.
In work week, show week hover state
var dateRangeHoverType = getDateRangeTypeToUse(props.dateRangeType,
props.workWeekDays);
// gets all the dates for the given date range type that are in the same
date range as the given day
var dateRange =
date_time_utilities_1.getDateRangeArray(dayToCompare.originalDate,
dateRangeHoverType, props.firstDayOfWeek, props.workWeekDays,
props.daysToSelectInDayView).map(function (date) { return date.getTime(); });
// gets all the day refs for the given dates
var dayInfosInRange = weeks.reduce(function (accumulatedValue, currentWeek)
{
return accumulatedValue.concat(currentWeek.filter(function (weekDay)
{ return dateRange.indexOf(weekDay.originalDate.getTime()) !== -1; }));
}, []);
return dayInfosInRange;
};
var getRefsFromDayInfos = function (dayInfosInRange) {
var dayRefs = [];
dayRefs = dayInfosInRange.map(function (dayInfo) { return
daysRef.current[dayInfo.key]; });
return dayRefs;
};
dateRangeType = props.dateRangeType, showWeekNumbers = props.showWeekNumbers,
labelledBy = props.labelledBy, lightenDaysOutsideNavigatedMonth =
props.lightenDaysOutsideNavigatedMonth, animationDirection =
props.animationDirection;
theme: theme,
dateRangeType: dateRangeType,
lightenDaysOutsideNavigatedMonth: lightenDaysOutsideNavigatedMonth ===
undefined ? true : lightenDaysOutsideNavigatedMonth,
});
// When the month is highlighted get the corner dates so that styles can be
added to them
var weekCorners = getWeekCornerStyles(classNames, weeks);
var partialWeekProps = {
weeks: weeks,
navigatedDayRef: navigatedDayRef,
calculateRoundedStyles: calculateRoundedStyles,
activeDescendantId: activeDescendantId,
classNames: classNames,
weekCorners: weekCorners,
getDayInfosInRangeOfDay: getDayInfosInRangeOfDay,
getRefsFromDayInfos: getRefsFromDayInfos,
};
return (React.createElement(FocusZone_1.FocusZone, { className:
classNames.wrapper, preventDefaultWhenHandled: true },
React.createElement("table", { className: classNames.table, "aria-
multiselectable": "false", "aria-labelledby": labelledBy, "aria-activedescendant":
activeDescendantId, role: "grid" },
React.createElement("tbody", null,
React.createElement(CalendarMonthHeaderRow_1.CalendarMonthHeaderRow,
tslib_1.__assign({}, props, { classNames: classNames, weeks: weeks })),
React.createElement(CalendarGridRow_1.CalendarGridRow,
tslib_1.__assign({}, props, partialWeekProps, { week: weeks[0], weekIndex: -1,
rowClassName: classNames.firstTransitionWeek, ariaRole: "presentation", ariaHidden:
true })),
weeks.slice(1, weeks.length - 1).map(function (week, weekIndex)
{ return (React.createElement(CalendarGridRow_1.CalendarGridRow,
tslib_1.__assign({}, props, partialWeekProps, { key: weekIndex, week: week,
weekIndex: weekIndex, rowClassName: classNames.weekRow }))); }),
React.createElement(CalendarGridRow_1.CalendarGridRow,
tslib_1.__assign({}, props, partialWeekProps, { week: weeks[weeks.length - 1],
weekIndex: -2, rowClassName: classNames.lastTransitionWeek, ariaRole:
"presentation", ariaHidden: true }))))));
};
exports.CalendarDayGridBase = CalendarDayGridBase;
exports.CalendarDayGridBase.displayName = 'CalendarDayGridBase';
/**
* When given work week, if the days are non-contiguous, the hover states look
really weird. So for non-contiguous
* work weeks, we'll just show week view instead.
*/
function getDateRangeTypeToUse(dateRangeType, workWeekDays) {
if (workWeekDays && dateRangeType ===
date_time_utilities_1.DateRangeType.WorkWeek) {
var sortedWWDays = workWeekDays.slice().sort();
var isContiguous = true;
for (var i = 1; i < sortedWWDays.length; i++) {
if (sortedWWDays[i] !== sortedWWDays[i - 1] + 1) {
isContiguous = false;
break;
}
}
if (!isContiguous || workWeekDays.length === 0) {
return date_time_utilities_1.DateRangeType.Week;
}
}
return dateRangeType;
}
//# sourceMappingURL=CalendarDayGrid.base.js.map
/***/ }),
/***/ 80153:
"use strict";

exports.CalendarDayGrid = void 0;
var CalendarDayGrid_base_1 = __webpack_require__(18116);
var CalendarDayGrid_styles_1 = __webpack_require__(19648);
exports.CalendarDayGrid =
Utilities_1.styled(CalendarDayGrid_base_1.CalendarDayGridBase,
CalendarDayGrid_styles_1.styles, undefined, { scope: 'CalendarDayGrid' });
//# sourceMappingURL=CalendarDayGrid.js.map
/***/ }),
/***/ 19648:
"use strict";

hoverStyle: 'ms-CalendarDay-hoverStyle',
pressedStyle: 'ms-CalendarDay-pressedStyle',
dayIsTodayStyle: 'ms-CalendarDay-dayIsToday',
daySelectedStyle: 'ms-CalendarDay-daySelected',
};
var transitionRowDisappearance = style_utilities_1.keyframes({
'100%': {
width: 0,
height: 0,
overflow: 'hidden',
},
'99.9%': {
width: '100%',
height: 28,
},
'0%': {
width: '100%',
height: 28,
},
});
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
var theme = props.theme, dateRangeType = props.dateRangeType, showWeekNumbers =
props.showWeekNumbers, lightenDaysOutsideNavigatedMonth =
props.lightenDaysOutsideNavigatedMonth, animateBackwards = props.animateBackwards,
animationDirection = props.animationDirection;
var classNames = style_utilities_1.getGlobalClassNames(GlobalClassNames,
theme);
var rowAnimationStyle = {};
if (animationDirection === Calendar_types_1.AnimationDirection.Horizontal)
{
rowAnimationStyle = animateBackwards ?
style_utilities_1.AnimationStyles.slideRightIn20 :
style_utilities_1.AnimationStyles.slideLeftIn20;
}
else {
rowAnimationStyle = animateBackwards ?
style_utilities_1.AnimationStyles.slideDownIn20 :
style_utilities_1.AnimationStyles.slideUpIn20;
}
}
var firstTransitionRowAnimationStyle = {};
var lastTransitionRowAnimationStyle = {};
if (animationDirection !== Calendar_types_1.AnimationDirection.Horizontal)
{
firstTransitionRowAnimationStyle = animateBackwards ? { animationName:
'' } : style_utilities_1.AnimationStyles.slideUpOut20;
lastTransitionRowAnimationStyle = animateBackwards ?
style_utilities_1.AnimationStyles.slideDownOut20 : { animationName: '' };
}
}
var disabledStyle = {
selectors: {
},
},
};
return {
wrapper: {
paddingBottom: 10,
},
table: [
{
borderCollapse: 'collapse',
borderSpacing: '0',
tableLayout: 'fixed',
fontSize: 'inherit',
marginTop: 4,
width: 196,
paddingBottom: 10,
},
showWeekNumbers && {
width: 226,
},
],
dayCell: [
{
margin: 0,
padding: 0,
width: 28,
height: 28,
lineHeight: 28,
cursor: 'pointer',
_a[style_utilities_1.HighContrastSelector] = tslib_1.__assign({
color: 'WindowText', backgroundColor: 'Window', zIndex: 0 },
_a['&.' + classNames.hoverStyle] = {
_b[style_utilities_1.HighContrastSelector] = {
zIndex: 3,
outline: '1px solid Highlight',
},
_b),
},
_a['&.' + classNames.pressedStyle] = {
_c[style_utilities_1.HighContrastSelector] = {
color: 'Highlight',
},
_c),
},
_a['&.' + classNames.pressedStyle + '.' +
classNames.hoverStyle] = {
_d[style_utilities_1.HighContrastSelector] = {
},
_d),
},
_a),
},
],
daySelected: [
dateRangeType !== date_time_utilities_1.DateRangeType.Month && {
backgroundColor: palette.neutralLight + '!important',
selectors: (_e = {
'&::before': {
content: '""',
top: 0,
bottom: 0,
left: 0,
right: 0,
}
},
_e['&:hover, &.' + classNames.hoverStyle + ', &.' +
classNames.pressedStyle] = (_f = {
backgroundColor: palette.neutralLight + '!important'
},
_f[style_utilities_1.HighContrastSelector] = {
color: 'HighlightText!important',
background: 'Highlight!important',
},
_f),
_e[style_utilities_1.HighContrastSelector] = tslib_1.__assign({
background: 'Highlight!important', color: 'HighlightText!important', borderColor:
'Highlight!important' }, style_utilities_1.getHighContrastNoAdjustStyle()),
_e),
},
],
weekRow: rowAnimationStyle,
weekDayLabelCell: style_utilities_1.AnimationStyles.fadeIn200,
weekNumberCell: {
margin: 0,
padding: 0,
borderRight: '1px solid',
borderColor: palette.neutralLight,
backgroundColor: palette.neutralLighterAlt,
width: 28,
height: 28,
},
dayOutsideBounds: disabledStyle,
dayOutsideNavigatedMonth: lightenDaysOutsideNavigatedMonth && {
},
dayButton: {
width: 24,
height: 24,
lineHeight: 24,
fontWeight: 'inherit',
borderRadius: 2,
border: 'none',
padding: 0,
color: 'inherit',
cursor: 'pointer',
selectors: {
span: {
height: 'inherit',
lineHeight: 'inherit',
},
},
},
dayIsToday: {
backgroundColor: palette.themePrimary + '!important',
color: palette.white + '!important',
fontWeight: (style_utilities_1.FontWeights.semibold + '!important'),
_g[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ background: 'WindowText!important', color: 'Window!important',
borderColor: 'WindowText!important' },
_g),
},
firstTransitionWeek: tslib_1.__assign(tslib_1.__assign({ position:
'absolute', opacity: 0, width: 0, height: 0, overflow: 'hidden' },
firstTransitionRowAnimationStyle), { animationName:
firstTransitionRowAnimationStyle.animationName + ',' +
transitionRowDisappearance }),
lastTransitionWeek: tslib_1.__assign(tslib_1.__assign({ position:
'absolute', opacity: 0, width: 0, height: 0, overflow: 'hidden', marginTop: -28 },
lastTransitionRowAnimationStyle), { animationName:
lastTransitionRowAnimationStyle.animationName + ',' +
transitionRowDisappearance }),
dayMarker: {
width: 4,
height: 4,
backgroundColor: palette.neutralSecondary,
bottom: 1,
left: 0,
right: 0,
margin: 'auto',
_h['.' + classNames.dayIsTodayStyle + ' &'] = {
backgroundColor: palette.white,
_j[style_utilities_1.HighContrastSelector] = {
},
_j),
},
_h['.' + classNames.daySelectedStyle + ' &'] = {
_k[style_utilities_1.HighContrastSelector] = {
backgroundColor: 'HighlightText',
},
_k),
},
_h[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ backgroundColor: 'WindowText' },
_h),
},
topRightCornerDate: {
borderTopRightRadius: '2px',
},
topLeftCornerDate: {
borderTopLeftRadius: '2px',
},
bottomRightCornerDate: {
borderBottomRightRadius: '2px',
},
bottomLeftCornerDate: {
borderBottomLeftRadius: '2px',
},
datesAbove: {
'&::before': {
borderTop: "1px solid " + palette.neutralSecondary,
},
},
datesBelow: {
'&::before': {
borderBottom: "1px solid " + palette.neutralSecondary,
},
},
datesLeft: {
'&::before': {
borderLeft: "1px solid " + palette.neutralSecondary,
},
},
datesRight: {
'&::before': {
borderRight: "1px solid " + palette.neutralSecondary,
},
},
};
};
//# sourceMappingURL=CalendarDayGrid.styles.js.map
/***/ }),
/***/ 20340:
"use strict";

//# sourceMappingURL=CalendarDayGrid.types.js.map
/***/ }),
/***/ 9993:
"use strict";

exports.CalendarGridDayCell = void 0;
var CalendarGridDayCell = function (props) {
var _a;
var navigatedDate = props.navigatedDate, dateTimeFormatter =
props.dateTimeFormatter, allFocusable = props.allFocusable, strings =
props.strings, activeDescendantId = props.activeDescendantId, navigatedDayRef =
props.navigatedDayRef, calculateRoundedStyles = props.calculateRoundedStyles, weeks
= props.weeks, classNames = props.classNames, day = props.day, dayIndex =
props.dayIndex, weekIndex = props.weekIndex, weekCorners = props.weekCorners,
ariaHidden = props.ariaHidden, customDayCellRef = props.customDayCellRef,
dateRangeType = props.dateRangeType, daysToSelectInDayView =
props.daysToSelectInDayView, onSelectDate = props.onSelectDate, restrictedDates =
props.restrictedDates, minDate = props.minDate, maxDate = props.maxDate,
onNavigateDate = props.onNavigateDate, getDayInfosInRangeOfDay =
props.getDayInfosInRangeOfDay, getRefsFromDayInfos = props.getRefsFromDayInfos;
var cornerStyle = (_a = weekCorners === null || weekCorners === void 0 ? void 0
: weekCorners[weekIndex + '_' + dayIndex]) !== null && _a !== void 0 ? _a : '';
var isNavigatedDate = date_time_utilities_1.compareDates(navigatedDate,
day.originalDate);
var navigateMonthEdge = function (ev, date) {
var targetDate = undefined;
var direction = 1; // by default search forward
if (ev.which === utilities_1.KeyCodes.up) {
targetDate = date_time_utilities_1.addWeeks(date, -1);
direction = -1;
}
else if (ev.which === utilities_1.KeyCodes.down) {
targetDate = date_time_utilities_1.addWeeks(date, 1);
}
else if (ev.which ===
utilities_1.getRTLSafeKeyCode(utilities_1.KeyCodes.left)) {
targetDate = date_time_utilities_1.addDays(date, -1);
direction = -1;
}
else if (ev.which ===
utilities_1.getRTLSafeKeyCode(utilities_1.KeyCodes.right)) {
targetDate = date_time_utilities_1.addDays(date, 1);
}
if (!targetDate) {
// if we couldn't find a target date at all, do nothing
return;
}
var findAvailableDateOptions = {
initialDate: date,
targetDate: targetDate,
direction: direction,
restrictedDates: restrictedDates,
minDate: minDate,
maxDate: maxDate,
};
// target date is restricted, search in whatever direction until finding
the next possible date,
// stopping at boundaries
var nextDate =
date_time_utilities_1.findAvailableDate(findAvailableDateOptions);
if (!nextDate) {
// if no dates available in initial direction, try going backwards
findAvailableDateOptions.direction = -direction;
nextDate =
date_time_utilities_1.findAvailableDate(findAvailableDateOptions);
}
// if the nextDate is still inside the same focusZone area, let the
focusZone handle setting the focus so we
// don't jump the view unnecessarily
var isInCurrentView = weeks &&
nextDate &&
weeks.slice(1, weeks.length - 1).some(function (week) {
return week.some(function (dayToCompare) {
return
date_time_utilities_1.compareDates(dayToCompare.originalDate, nextDate);
});
});
if (isInCurrentView) {
return;
}
// else, fire navigation on the date to change the view to show it
if (nextDate) {
onNavigateDate(nextDate, true);
}
};
var onMouseOverDay = function (ev) {
var dayInfos = getDayInfosInRangeOfDay(day);
var dayRefs = getRefsFromDayInfos(dayInfos);
dayRefs.forEach(function (dayRef, index) {
var _a;
if (dayRef) {
dayRef.classList.add('ms-CalendarDay-hoverStyle');
if (!dayInfos[index].isSelected &&
dateRangeType === date_time_utilities_1.DateRangeType.Day &&
daysToSelectInDayView &&
daysToSelectInDayView > 1) {
// remove the static classes first to overwrite them
dayRef.classList.remove(classNames.bottomLeftCornerDate,
classNames.bottomRightCornerDate, classNames.topLeftCornerDate,
classNames.topRightCornerDate);
var classNamesToAdd = calculateRoundedStyles(classNames, false,
false, index > 0, index < dayRefs.length - 1).trim();
if (classNamesToAdd) {
(_a = dayRef.classList).add.apply(_a,
classNamesToAdd.split(' '));
}
}
}
});
};
var onMouseDownDay = function (ev) {
dayRefs.forEach(function (dayRef) {
if (dayRef) {
dayRef.classList.add('ms-CalendarDay-pressedStyle');
}
});
};
var onMouseUpDay = function (ev) {
dayRefs.forEach(function (dayRef) {
if (dayRef) {
dayRef.classList.remove('ms-CalendarDay-pressedStyle');
}
});
};
var onMouseOutDay = function (ev) {
dayRefs.forEach(function (dayRef, index) {
var _a;
if (dayRef) {
dayRef.classList.remove('ms-CalendarDay-hoverStyle');
dayRef.classList.remove('ms-CalendarDay-pressedStyle');
if (!dayInfos[index].isSelected &&
dateRangeType === date_time_utilities_1.DateRangeType.Day &&
daysToSelectInDayView &&
daysToSelectInDayView > 1) {
var classNamesToAdd = calculateRoundedStyles(classNames, false,
false, index > 0, index < dayRefs.length - 1).trim();
if (classNamesToAdd) {
(_a = dayRef.classList).remove.apply(_a,
classNamesToAdd.split(' '));
}
}
}
});
};
var onDayKeyDown = function (ev) {
if (ev.which === utilities_1.KeyCodes.enter) {
onSelectDate(day.originalDate);
}
else {
navigateMonthEdge(ev, day.originalDate);
}
};
var ariaLabel = day.originalDate.getDate() +
', ' +
strings.months[day.originalDate.getMonth()] +
', ' +
day.originalDate.getFullYear();
if (day.isMarked) {
ariaLabel = ariaLabel + ', ' + strings.dayMarkedAriaLabel;
}
return (React.createElement("td", { className:
utilities_1.css(classNames.dayCell, weekCorners && cornerStyle, day.isSelected &&
classNames.daySelected, day.isSelected && 'ms-CalendarDay-daySelected', !
day.isInBounds && classNames.dayOutsideBounds, !day.isInMonth &&
classNames.dayOutsideNavigatedMonth), ref: function (element) {
customDayCellRef === null || customDayCellRef === void 0 ? void 0 :
customDayCellRef(element, day.originalDate, classNames);
day.setRef(element);
isNavigatedDate && (navigatedDayRef.current = element);
}, "aria-hidden": ariaHidden, "aria-disabled": !ariaHidden && !
day.isInBounds, onClick: day.isInBounds && !ariaHidden ? day.onSelected :
undefined, onMouseOver: !ariaHidden ? onMouseOverDay : undefined, onMouseDown: !
ariaHidden ? onMouseDownDay : undefined, onMouseUp: !ariaHidden ? onMouseUpDay :
undefined, onMouseOut: !ariaHidden ? onMouseOutDay : undefined, onKeyDown: !
ariaHidden ? onDayKeyDown : undefined, role: "gridcell", tabIndex:
isNavigatedDate ? 0 : undefined, "aria-current": day.isSelected ? 'date' :
undefined, "aria-selected": day.isInBounds ? day.isSelected : undefined, "data-is-
focusable": !ariaHidden && (allFocusable || (day.isInBounds ? true : undefined)) },
React.createElement("button", { key: day.key + 'button', "aria-hidden":
ariaHidden, className: utilities_1.css(classNames.dayButton, day.isToday &&
classNames.dayIsToday, day.isToday && 'ms-CalendarDay-dayIsToday'), "aria-label":
ariaLabel, id: isNavigatedDate ? activeDescendantId : undefined, disabled: !
ariaHidden && !day.isInBounds, type: "button", tabIndex: -1, "data-is-focusable":
"false" },
React.createElement("span", { "aria-hidden": "true" },
dateTimeFormatter.formatDay(day.originalDate)),
day.isMarked && React.createElement("div", { "aria-hidden": "true",
className: classNames.dayMarker }))));
};
exports.CalendarGridDayCell = CalendarGridDayCell;
//# sourceMappingURL=CalendarGridDayCell.js.map
/***/ }),
/***/ 12579:
"use strict";

exports.CalendarGridRow = void 0;
var CalendarGridDayCell_1 = __webpack_require__(9993);
var CalendarGridRow = function (props) {
var classNames = props.classNames, week = props.week, weeks = props.weeks,
weekIndex = props.weekIndex, rowClassName = props.rowClassName, ariaRole =
props.ariaRole, showWeekNumbers = props.showWeekNumbers, firstDayOfWeek =
props.firstDayOfWeek, firstWeekOfYear = props.firstWeekOfYear, navigatedDate =
props.navigatedDate, strings = props.strings;
var weekNumbers = showWeekNumbers
? date_time_utilities_1.getWeekNumbersInMonth(weeks.length, firstDayOfWeek,
firstWeekOfYear, navigatedDate)
: null;
var titleString = weekNumbers
? strings.weekNumberFormatString &&
utilities_1.format(strings.weekNumberFormatString, weekNumbers[weekIndex])
: '';
return (React.createElement("tr", { role: ariaRole, className: rowClassName,
key: weekIndex + '_' + week[0].key },
showWeekNumbers && weekNumbers && (React.createElement("th", { className:
classNames.weekNumberCell, key: weekIndex, title: titleString, "aria-label":
titleString, scope: "row" },
React.createElement("span", null, weekNumbers[weekIndex]))),
week.map(function (day, dayIndex) { return
(React.createElement(CalendarGridDayCell_1.CalendarGridDayCell,
tslib_1.__assign({}, props, { key: day.key, day: day, dayIndex:
dayIndex }))); })));
};
exports.CalendarGridRow = CalendarGridRow;
//# sourceMappingURL=CalendarGridRow.js.map
/***/ }),
/***/ 79565:
"use strict";

exports.CalendarMonthHeaderRow = void 0;
var CalendarMonthHeaderRow = function (props) {
var showWeekNumbers = props.showWeekNumbers, strings = props.strings,
firstDayOfWeek = props.firstDayOfWeek, allFocusable = props.allFocusable,
weeksToShow = props.weeksToShow, weeks = props.weeks, classNames =
props.classNames;
var dayLabels = strings.shortDays.slice();
var firstOfMonthIndex = utilities_1.findIndex(weeks[1], function (day) { return
day.originalDate.getDate() === 1; });
if (weeksToShow === 1 && firstOfMonthIndex >= 0) {
// if we only show one week, replace the header with short month name
var firstOfMonthIndexOffset = (firstOfMonthIndex + firstDayOfWeek) %
date_time_utilities_1.DAYS_IN_WEEK;
dayLabels[firstOfMonthIndexOffset] = strings.shortMonths[weeks[1]
[firstOfMonthIndex].originalDate.getMonth()];
}
return (React.createElement("tr", null,
showWeekNumbers && React.createElement("th", { className:
classNames.dayCell }),
dayLabels.map(function (val, index) {
var i = (index + firstDayOfWeek) % date_time_utilities_1.DAYS_IN_WEEK;
var label = index === firstOfMonthIndex ? strings.days[i] + ' ' +
dayLabels[i] : strings.days[i];
return (React.createElement("th", { className:
utilities_1.css(classNames.dayCell, classNames.weekDayLabelCell), scope: "col",
key: dayLabels[i] + ' ' + index, title: label, "aria-label": label, "data-is-
focusable": allFocusable ? true : undefined }, dayLabels[i]));
})));
};
exports.CalendarMonthHeaderRow = CalendarMonthHeaderRow;
//# sourceMappingURL=CalendarMonthHeaderRow.js.map
/***/ }),
/***/ 27435:
"use strict";

exports.Callout = void 0;
var CalloutContent_1 = __webpack_require__(86782);
var Layer_1 = __webpack_require__(16276);
exports.Callout = React.forwardRef(function (_a, forwardedRef) {
var layerProps = _a.layerProps, doNotLayer = _a.doNotLayer, rest =
tslib_1.__rest(_a, ["layerProps", "doNotLayer"]);
var content = React.createElement(CalloutContent_1.CalloutContent,
tslib_1.__assign({}, rest, { doNotLayer: doNotLayer, ref: forwardedRef }));
return doNotLayer ? content : React.createElement(Layer_1.Layer,
tslib_1.__assign({}, layerProps), content);
});
exports.Callout.displayName = 'Callout';
//# sourceMappingURL=Callout.js.map
/***/ }),
/***/ 6022:
"use strict";

//# sourceMappingURL=Callout.types.js.map
/***/ }),
/***/ 65816:
"use strict";
var _a;
exports.CalloutContentBase = void 0;
var Positioning_1 = __webpack_require__(38669);
var Popup_1 = __webpack_require__(39612);
var COMPONENT_NAME = 'CalloutContentBase';
var ANIMATIONS = (_a = {},
_a[Positioning_1.RectangleEdge.top] =
Styling_1.AnimationClassNames.slideUpIn10,
_a[Positioning_1.RectangleEdge.bottom] =
Styling_1.AnimationClassNames.slideDownIn10,
_a[Positioning_1.RectangleEdge.left] =
Styling_1.AnimationClassNames.slideLeftIn10,
_a[Positioning_1.RectangleEdge.right] =
Styling_1.AnimationClassNames.slideRightIn10,
_a);
var BEAK_ORIGIN_POSITION = { top: 0, left: 0 };
// Microsoft Edge will overwrite inline styles if there is an animation pertaining
to that style.
// To help ensure that edge will respect the offscreen style opacity
// filter needs to be added as an additional way to set opacity.
// Also set pointer-events: none so that the callout will not occlude the element
it is
// going to be positioned against
var OFF_SCREEN_STYLE = {
opacity: 0,
filter: 'opacity(0)',
};
// role and role description go hand-in-hand. Both would be included by spreading
getNativeProps for a basic element
// This constant array can be used to filter these out of native props spread on
callout root and apply them together on
// calloutMain (the Popup component within the callout)
var ARIA_ROLE_ATTRIBUTES = ['role', 'aria-roledescription'];
preventDismissOnLostFocus: false,
preventDismissOnScroll: false,
preventDismissOnResize: false,
isBeakVisible: true,
beakWidth: 16,
gapSpace: 0,
minPagePadding: 8,
directionalHint: DirectionalHint_1.DirectionalHint.bottomAutoEdge,
};
var getClassNames = Utilities_2.classNamesFunction({
disableCaching: true, // disabling caching because stylesProp.position mutates
often
});
/**
* (Hook) to return a function to lazily fetch the bounds of the target element for
the callout.
*/
function useBounds(_a, targetRef, targetWindow) {
var bounds = _a.bounds, _b = _a.minPagePadding, minPagePadding = _b === void
0 ? DEFAULT_PROPS.minPagePadding : _b, target = _a.target;
var _c = React.useState(false), targetWindowResized = _c[0],
setTargetWindowResized = _c[1];
var cachedBounds = React.useRef();
var getBounds = React.useCallback(function () {
if (!cachedBounds.current || targetWindowResized) {
var currentBounds = typeof bounds === 'function' ? (targetWindow ?
bounds(target, targetWindow) : undefined) : bounds;
if (!currentBounds && targetWindow) {
currentBounds =
Positioning_1.getBoundsFromTargetWindow(targetRef.current, targetWindow);
currentBounds = {
top: currentBounds.top + minPagePadding,
left: currentBounds.left + minPagePadding,
right: currentBounds.right - minPagePadding,
bottom: currentBounds.bottom - minPagePadding,
width: currentBounds.width - minPagePadding * 2,
height: currentBounds.height - minPagePadding * 2,
};
}
cachedBounds.current = currentBounds;
targetWindowResized && setTargetWindowResized(false);
}
return cachedBounds.current;
}, [bounds, minPagePadding, target, targetRef, targetWindow,
targetWindowResized]);
var async = react_hooks_1.useAsync();
react_hooks_1.useOnEvent(targetWindow, 'resize', async.debounce(function () {
setTargetWindowResized(true);
}, 500, { leading: true }));
return getBounds;
}
/**
* (Hook) to return the maximum available height for the Callout to render into.
*/
function useMaxHeight(_a, getBounds, positions) {
var _b;
var calloutMaxHeight = _a.calloutMaxHeight, finalHeight = _a.finalHeight,
directionalHint = _a.directionalHint, directionalHintFixed =
_a.directionalHintFixed, hidden = _a.hidden;
var _c = React.useState(), maxHeight = _c[0], setMaxHeight = _c[1];
var _d = (_b = positions === null || positions === void 0 ? void 0 :
positions.elementPosition) !== null && _b !== void 0 ? _b : {}, top = _d.top,
bottom = _d.bottom;
var _a;
var _b = (_a = getBounds()) !== null && _a !== void 0 ? _a : {}, topBounds
= _b.top, bottomBounds = _b.bottom;
if (!calloutMaxHeight && !hidden) {
if (typeof top === 'number' && bottomBounds) {
setMaxHeight(bottomBounds - top);
}
else if (typeof bottom === 'number' && typeof topBounds === 'number' &&
bottomBounds) {
setMaxHeight(bottomBounds - topBounds - bottom);
}
}
else if (calloutMaxHeight) {
setMaxHeight(calloutMaxHeight);
}
else {
setMaxHeight(undefined);
}
}, [bottom, calloutMaxHeight, finalHeight, directionalHint,
directionalHintFixed, getBounds, hidden, positions, top]);
return maxHeight;
}
/**
* (Hook) to find the current position of Callout. If Callout is resized then a new
position is calculated.
*/
function usePositions(props, hostElement, calloutElement, targetRef, getBounds) {
var _a = React.useState(), positions = _a[0], setPositions = _a[1];
var positionAttempts = React.useRef(0);
var previousTarget = React.useRef();
var hidden = props.hidden, target = props.target, finalHeight =
props.finalHeight, calloutMaxHeight = props.calloutMaxHeight, onPositioned =
props.onPositioned, directionalHint = props.directionalHint;
if (!hidden) {
var timerId_1 = async.requestAnimationFrame(function () {
var _a, _b;
if (hostElement.current && calloutElement) {
var currentProps = tslib_1.__assign(tslib_1.__assign({},
props), { target: targetRef.current, bounds: getBounds() });
// duplicate calloutElement & remove useMaxHeight's maxHeight
for position calc
var dupeCalloutElement = calloutElement.cloneNode(true);
dupeCalloutElement.style.maxHeight = calloutMaxHeight ? "" +
calloutMaxHeight : '';
dupeCalloutElement.style.visibility = 'hidden';
(_a = calloutElement.parentElement) === null || _a === void 0 ?
void 0 : _a.appendChild(dupeCalloutElement);
var previousPositions = previousTarget.current === target ?
positions : undefined;
// If there is a finalHeight given then we assume that the user
knows and will handle
// additional positioning adjustments so we should call
positionCard
var newPositions = finalHeight
? Positioning_1.positionCard(currentProps,
hostElement.current, dupeCalloutElement, previousPositions)
: Positioning_1.positionCallout(currentProps,
hostElement.current, dupeCalloutElement, previousPositions);
// clean up duplicate calloutElement
(_b = calloutElement.parentElement) === null || _b === void 0 ?
void 0 : _b.removeChild(dupeCalloutElement);
// Set the new position only when the positions do not exist or
one of the new callout positions
// is different. The position should not change if the position
is within 2 decimal places.
if ((!positions && newPositions) ||
(positions && newPositions && !arePositionsEqual(positions,
newPositions) && positionAttempts.current < 5)) {
// We should not reposition the callout more than a few
times, if it is then the content is likely resizing
// and we should stop trying to reposition to prevent a
stack overflow.
positionAttempts.current++;
setPositions(newPositions);
}
else if (positionAttempts.current > 0) {
// Only call the onPositioned callback if the callout has
been re-positioned at least once.
positionAttempts.current = 0;
onPositioned === null || onPositioned === void 0 ? void 0 :
onPositioned(positions);
}
}
}, calloutElement);
previousTarget.current = target;
async.cancelAnimationFrame(timerId_1);
previousTarget.current = undefined;
};
}
else {
// When the callout is hidden, clear position state so that it is not
accidentally used next render.
setPositions(undefined);
}
}, [
hidden,
directionalHint,
async,
calloutElement,
calloutMaxHeight,
hostElement,
targetRef,
finalHeight,
getBounds,
onPositioned,
positions,
props,
target,
]);
return positions;
}
/**
* (Hook) to set up behavior to automatically focus the callout when it appears, if
indicated by props.
*/
function useAutoFocus(_a, positions, calloutElement) {
var hidden = _a.hidden, setInitialFocus = _a.setInitialFocus;
var hasPositions = !!positions;
if (!hidden && setInitialFocus && hasPositions && calloutElement) {
var timerId_2 = async.requestAnimationFrame(function () { return
Utilities_1.focusFirstChild(calloutElement); }, calloutElement);
return function () { return async.cancelAnimationFrame(timerId_2); };
}
}, [hidden, hasPositions, async, calloutElement, setInitialFocus]);
}
/**
* (Hook) to set up various handlers to dismiss the popup when it loses focus or
the window scrolls or similar cases.
*/
function useDismissHandlers(_a, positions, hostElement, targetRef, targetWindow) {
var hidden = _a.hidden, onDismiss = _a.onDismiss,
preventDismissOnScroll = _a.preventDismissOnScroll,
preventDismissOnResize = _a.preventDismissOnResize,
preventDismissOnLostFocus = _a.preventDismissOnLostFocus, dismissOnTargetClick
= _a.dismissOnTargetClick, shouldDismissOnWindowFocus =
_a.shouldDismissOnWindowFocus, preventDismissOnEvent = _a.preventDismissOnEvent;
var isMouseDownOnPopup = React.useRef(false);
var mouseDownHandlers = react_hooks_1.useConst([
function () {
isMouseDownOnPopup.current = true;
},
function () {
isMouseDownOnPopup.current = false;
},
]);
var positionsExists = !!positions;
var dismissOnScroll = function (ev) {
if (positionsExists && !preventDismissOnScroll) {
dismissOnClickOrScroll(ev);
}
};
var dismissOnResize = function (ev) {
if (!preventDismissOnResize && !(preventDismissOnEvent &&
preventDismissOnEvent(ev))) {
onDismiss === null || onDismiss === void 0 ? void 0 :
onDismiss(ev);
}
};
var dismissOnLostFocus = function (ev) {
if (!preventDismissOnLostFocus) {
dismissOnClickOrScroll(ev);
}
};
var dismissOnClickOrScroll = function (ev) {
var eventPaths = ev.composedPath ? ev.composedPath() : [];
var target = eventPaths.length > 0 ? eventPaths[0] : ev.target;
var isEventTargetOutsideCallout = hostElement.current && !
Utilities_1.elementContains(hostElement.current, target);
// If mouse is pressed down on callout but moved outside then released,
don't dismiss the callout.
if (isEventTargetOutsideCallout && isMouseDownOnPopup.current) {
isMouseDownOnPopup.current = false;
return;
}
if ((!targetRef.current && isEventTargetOutsideCallout) ||
(ev.target !== targetWindow &&
isEventTargetOutsideCallout &&
(!targetRef.current ||
'stopPropagation' in targetRef.current ||
dismissOnTargetClick ||
(target !== targetRef.current && !
Utilities_1.elementContains(targetRef.current, target))))) {
if (preventDismissOnEvent && preventDismissOnEvent(ev)) {
return;
}
onDismiss(ev);
}
};
var dismissOnTargetWindowBlur = function (ev) {
// Do nothing
if (!shouldDismissOnWindowFocus) {
return;
}
if (((preventDismissOnEvent && !preventDismissOnEvent(ev)) ||
(!preventDismissOnEvent && !preventDismissOnLostFocus)) &&
!(targetWindow === null || targetWindow === void 0 ? void 0 :
targetWindow.document.hasFocus()) &&
ev.relatedTarget === null) {
onDismiss(ev);
}
};
// This is added so the callout will dismiss when the window is scrolled
// but not when something inside the callout is scrolled. The delay seems
// to be required to avoid React firing an async focus event in IE from
// the target changing focus quickly prior to rendering the callout.
var disposablesPromise = new Promise(function (resolve) {
async.setTimeout(function () {
if (!hidden && targetWindow) {
var disposables_1 = [
Utilities_1.on(targetWindow, 'scroll', dismissOnScroll,
true),
Utilities_1.on(targetWindow, 'resize', dismissOnResize,
true),
Utilities_1.on(targetWindow.document.documentElement,
'focus', dismissOnLostFocus, true),
Utilities_1.on(targetWindow.document.documentElement,
'click', dismissOnLostFocus, true),
Utilities_1.on(targetWindow, 'blur',
dismissOnTargetWindowBlur, true),
];
resolve(function () {
disposables_1.forEach(function (dispose) { return
dispose(); });
});
}
}, 0);
});
disposablesPromise.then(function (dispose) { return dispose(); });
};
}, [
hidden,
async,
hostElement,
targetRef,
targetWindow,
onDismiss,
shouldDismissOnWindowFocus,
dismissOnTargetClick,
preventDismissOnLostFocus,
preventDismissOnResize,
preventDismissOnScroll,
positionsExists,
preventDismissOnEvent,
]);
return mouseDownHandlers;
}
exports.CalloutContentBase = React.memo(React.forwardRef(function
(propsWithoutDefaults, forwardedRef) {
var props = Utilities_1.getPropsWithDefaults(DEFAULT_PROPS,
var styles = props.styles, style = props.style, ariaLabel = props.ariaLabel,
ariaDescribedBy = props.ariaDescribedBy, ariaLabelledBy = props.ariaLabelledBy,
className = props.className, isBeakVisible = props.isBeakVisible, children =
props.children, beakWidth = props.beakWidth, calloutWidth = props.calloutWidth,
calloutMaxWidth = props.calloutMaxWidth, calloutMinWidth = props.calloutMinWidth,
doNotLayer = props.doNotLayer, finalHeight = props.finalHeight, _a =
props.hideOverflow, hideOverflow = _a === void 0 ? !!finalHeight : _a,
backgroundColor = props.backgroundColor, calloutMaxHeight = props.calloutMaxHeight,
onScroll = props.onScroll,
_b = props.shouldRestoreFocus,
shouldRestoreFocus = _b === void 0 ? true : _b, target = props.target, hidden =
props.hidden, onLayerMounted = props.onLayerMounted;
var hostElement = React.useRef(null);
var _c = React.useState(null), calloutElement = _c[0], setCalloutElement =
_c[1];
var calloutCallback = React.useCallback(function (calloutEl) {
setCalloutElement(calloutEl);
}, []);
var rootRef = react_hooks_1.useMergedRefs(hostElement, forwardedRef);
var _d = react_hooks_1.useTarget(props.target, {
current: calloutElement,
}), targetRef = _d[0], targetWindow = _d[1];
var getBounds = useBounds(props, targetRef, targetWindow);
var positions = usePositions(props, hostElement, calloutElement, targetRef,
getBounds);
var maxHeight = useMaxHeight(props, getBounds, positions);
var _e = useDismissHandlers(props, positions, hostElement, targetRef,
targetWindow), mouseDownOnPopup = _e[0], mouseUpOnPopup = _e[1];
// do not set both top and bottom css props from positions
// instead, use maxHeight
var isForcedInBounds = (positions === null || positions === void 0 ? void 0 :
positions.elementPosition.top) && (positions === null || positions === void 0 ?
void 0 : positions.elementPosition.bottom);
var cssPositions = tslib_1.__assign(tslib_1.__assign({}, positions === null ||
positions === void 0 ? void 0 : positions.elementPosition), { maxHeight:
maxHeight });
if (isForcedInBounds) {
cssPositions.bottom = undefined;
}
useAutoFocus(props, positions, calloutElement);
if (!hidden) {
onLayerMounted === null || onLayerMounted === void 0 ? void 0 :
onLayerMounted();
}
// eslint-disable-next-line react-hooks/exhaustive-deps -- should only run
if hidden changes
}, [hidden]);
// If there is no target window then we are likely in server side rendering and
we should not render anything.
if (!targetWindow) {
return null;
}
var overflowYHidden = hideOverflow;
var beakVisible = isBeakVisible && !!target;
theme: props.theme,
overflowYHidden: overflowYHidden,
calloutWidth: calloutWidth,
positions: positions,
beakWidth: beakWidth,
backgroundColor: backgroundColor,
calloutMaxWidth: calloutMaxWidth,
calloutMinWidth: calloutMinWidth,
doNotLayer: doNotLayer,
});
var overflowStyle = tslib_1.__assign(tslib_1.__assign({ maxHeight:
calloutMaxHeight ? calloutMaxHeight : '100%' }, style), (overflowYHidden &&
{ overflowY: 'hidden' }));
var visibilityStyle = props.hidden ? { visibility: 'hidden' } : undefined;
// React.CSSProperties does not understand IRawStyle, so the inline animations
will need to be cast as any for now.
return (React.createElement("div", { ref: rootRef, className:
classNames.container, style: visibilityStyle },
React.createElement("div", tslib_1.__assign({},
Utilities_1.getNativeProps(props, Utilities_1.divProperties, ARIA_ROLE_ATTRIBUTES),
{ className: Utilities_1.css(classNames.root, positions && positions.targetEdge &&
ANIMATIONS[positions.targetEdge]), style: positions ? tslib_1.__assign({},
cssPositions) : OFF_SCREEN_STYLE,
// Safari and Firefox on Mac OS requires this to back-stop click events
so focus remains in the Callout.
// See
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
tabIndex: -1, ref: calloutCallback }),
beakVisible && React.createElement("div", { className: classNames.beak,
style: getBeakPosition(positions) }),
beakVisible && React.createElement("div", { className:
classNames.beakCurtain }),
React.createElement(Popup_1.Popup
// don't use getNativeElementProps for role and roledescription because
it will also
// pass through data-* props (resulting in them being used in two
places)
, {
// don't use getNativeElementProps for role and roledescription
because it will also
// pass through data-* props (resulting in them being used in two
places)
role: props.role, "aria-roledescription": props['aria-
roledescription'], ariaDescribedBy: ariaDescribedBy, ariaLabel: ariaLabel,
ariaLabelledBy: ariaLabelledBy, className: classNames.calloutMain, onDismiss:
props.onDismiss, onMouseDown: mouseDownOnPopup, onMouseUp: mouseUpOnPopup,
onRestoreFocus: props.onRestoreFocus, onScroll: onScroll, shouldRestoreFocus:
shouldRestoreFocus, style: overflowStyle }, children))));
}), function (previousProps, nextProps) {
if (!nextProps.shouldUpdateWhenHidden && previousProps.hidden &&
nextProps.hidden) {
// Do not update when hidden.
return true;
}
return Utilities_1.shallowCompare(previousProps, nextProps);
});
/**
* (Utility) to find and return the current `Callout` Beak position.
*
* @param positions
*/
function getBeakPosition(positions) {
var _a, _b;
var beakPositionStyle = tslib_1.__assign(tslib_1.__assign({}, (_a = positions
=== null || positions === void 0 ? void 0 : positions.beakPosition) === null || _a
=== void 0 ? void 0 : _a.elementPosition), { display: ((_b = positions === null ||
positions === void 0 ? void 0 : positions.beakPosition) === null || _b === void 0 ?
void 0 : _b.hideBeak) ? 'none' : undefined });
if (!beakPositionStyle.top && !beakPositionStyle.bottom && !
beakPositionStyle.left && !beakPositionStyle.right) {
beakPositionStyle.left = BEAK_ORIGIN_POSITION.left;
beakPositionStyle.top = BEAK_ORIGIN_POSITION.top;
}
return beakPositionStyle;
}
/**
* (Utility) used to compare two different elementPositions to determine whether
they are equal.
*
* @param prevElementPositions
* @param newElementPosition
*/
function arePositionsEqual(prevElementPositions, newElementPosition) {
return (comparePositions(prevElementPositions.elementPosition,
newElementPosition.elementPosition) &&
comparePositions(prevElementPositions.beakPosition.elementPosition,
newElementPosition.beakPosition.elementPosition));
}
/**
* (Utility) used in **arePositionsEqual** to compare two different
elementPositions.
*
* @param prevElementPositions
* @param newElementPositions
*/
function comparePositions(prevElementPositions, newElementPositions) {
for (var key in newElementPositions) {
if (newElementPositions.hasOwnProperty(key)) {
var oldPositionEdge = prevElementPositions[key];
var newPositionEdge = newElementPositions[key];
if (oldPositionEdge !== undefined && newPositionEdge !== undefined) {
if (oldPositionEdge.toFixed(2) !== newPositionEdge.toFixed(2)) {
return false;
}
}
else {
return false;
}
}
}
return true;
}
exports.CalloutContentBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=CalloutContent.base.js.map
/***/ }),
/***/ 86782:
"use strict";

exports.CalloutContent = void 0;
var CalloutContent_base_1 = __webpack_require__(65816);
var CalloutContent_styles_1 = __webpack_require__(13914);
exports.CalloutContent =
Utilities_1.styled(CalloutContent_base_1.CalloutContentBase,
CalloutContent_styles_1.getStyles, undefined, {
scope: 'CalloutContent',
});
//# sourceMappingURL=CalloutContent.js.map
/***/ }),
/***/ 13914:
"use strict";

function getBeakStyle(beakWidth) {
return {
height: beakWidth,
width: beakWidth,
};
}
container: 'ms-Callout-container',
root: 'ms-Callout',
beak: 'ms-Callout-beak',
beakCurtain: 'ms-Callout-beakCurtain',
calloutMain: 'ms-Callout-main',
};
var _a;
var theme = props.theme, className = props.className, overflowYHidden =
props.overflowYHidden, calloutWidth = props.calloutWidth, beakWidth =
props.beakWidth, backgroundColor = props.backgroundColor, calloutMaxWidth =
props.calloutMaxWidth, calloutMinWidth = props.calloutMinWidth, doNotLayer =
props.doNotLayer;
var semanticColors = theme.semanticColors, effects = theme.effects;
return {
container: [
classNames.container,
{
},
],
root: [
classNames.root,
theme.fonts.medium,
{
display: 'flex',
zIndex: doNotLayer ? Styling_1.ZIndexes.Layer : undefined,
boxShadow: effects.elevation16,
borderWidth: 1,
borderColor: 'WindowText',
},
_a),
},
Styling_1.focusClear(),
className,
!!calloutWidth && { width: calloutWidth },
!!calloutMaxWidth && { maxWidth: calloutMaxWidth },
!!calloutMinWidth && { minWidth: calloutMinWidth },
],
beak: [
classNames.beak,
{
backgroundColor: semanticColors.menuBackground,
boxShadow: 'inherit',
border: 'inherit',
transform: 'rotate(45deg)',
},
getBeakStyle(beakWidth),
backgroundColor && {
},
],
beakCurtain: [
classNames.beakCurtain,
{
top: 0,
right: 0,
bottom: 0,
left: 0,
},
],
calloutMain: [
classNames.calloutMain,
{
overflowY: 'auto',
width: '100%',
},
overflowYHidden && {
overflowY: 'hidden',
},
backgroundColor && {
},
],
};
};
//# sourceMappingURL=CalloutContent.styles.js.map
/***/ }),
/***/ 42349:
"use strict";

exports.FocusTrapCallout = void 0;
var Callout_1 = __webpack_require__(27435);
var FocusTrapZone_1 = __webpack_require__(38136);
/**
* A special Callout that uses FocusTrapZone to trap focus
* @param props - Props for the component
*/
var FocusTrapCallout = function (props) {
return (React.createElement(Callout_1.Callout, tslib_1.__assign({}, props),
React.createElement(FocusTrapZone_1.FocusTrapZone,
tslib_1.__assign({ disabled: props.hidden }, props.focusTrapProps),
props.children)));
};
exports.FocusTrapCallout = FocusTrapCallout;
//# sourceMappingURL=FocusTrapCallout.js.map
/***/ }),
/***/ 6880:
"use strict";

//# sourceMappingURL=FocusTrapCallout.types.js.map
/***/ }),
/***/ 93164:
"use strict";

/***/ }),
/***/ 65963:
"use strict";

exports.CheckBase = void 0;
exports.CheckBase = React.forwardRef(function (props, ref) {
var _a = props.checked, checked = _a === void 0 ? false : _a, className =
props.className, theme = props.theme, styles = props.styles, _b =
props.useFastIcons, useFastIcons = _b === void 0 ? true : _b;
var classNames = getClassNames(styles, { theme: theme, className: className,
checked: checked });
var IconComponent = useFastIcons ? Icon_1.FontIcon : Icon_1.Icon;
return (React.createElement("div", { className: classNames.root, ref: ref },
React.createElement(IconComponent, { iconName: "CircleRing", className:
classNames.circle }),
React.createElement(IconComponent, { iconName: "StatusCircleCheckmark",
className: classNames.check })));
});
exports.CheckBase.displayName = 'CheckBase';
//# sourceMappingURL=Check.base.js.map
/***/ }),
/***/ 32565:
"use strict";

exports.Check = void 0;
var Check_base_1 = __webpack_require__(65963);
var Check_styles_1 = __webpack_require__(98874);
exports.Check = Utilities_1.styled(Check_base_1.CheckBase,
Check_styles_1.getStyles, undefined, {
scope: 'Check',
}, true);
//# sourceMappingURL=Check.js.map
/***/ }),
/***/ 98874:
"use strict";

exports.getStyles = exports.CheckGlobalClassNames = void 0;
exports.CheckGlobalClassNames = {
root: 'ms-Check',
circle: 'ms-Check-circle',
check: 'ms-Check-check',
/** Must be manually applied to the parent element of the check. */
checkHost: 'ms-Check-checkHost',
};
var _a, _b, _c, _d, _e;
var _f = props.height, height = _f === void 0 ? props.checkBoxHeight ||
'18px' : _f, checked = props.checked, className = props.className, theme =
props.theme;
theme.fonts;
var isRTL = Utilities_1.getRTL(theme);
var classNames = Styling_1.getGlobalClassNames(exports.CheckGlobalClassNames,
theme);
var sharedCircleCheck = {
fontSize: height,
left: 0,
top: 0,
width: height,
height: height,
// inline-flex prevents the check from shifting with custom line height
styles
verticalAlign: 'middle',
};
return {
root: [
classNames.root,
fonts.medium,
{
// lineHeight currently needs to be a string to output without 'px'
lineHeight: '1',
width: height,
height: height,
userSelect: 'none',
selectors: (_a = {
':before': {
content: '""',
top: '1px',
right: '1px',
bottom: '1px',
left: '1px',
opacity: 1,
background: semanticColors.bodyBackground,
}
},
_a["." + classNames.checkHost + ":hover &, ." +
classNames.checkHost + ":focus &, &:hover, &:focus"] = {
opacity: 1,
},
_a),
},
checked && [
'is-checked',
{
selectors: {
':before': {
background: palette.themePrimary,
opacity: 1,
background: 'Window',
},
_b),
},
},
},
],
className,
],
circle: [
classNames.circle,
sharedCircleCheck,
{
},
_c),
},
checked && {
},
],
check: [
classNames.check,
sharedCircleCheck,
{
opacity: 0,
fontSize: Styling_1.IconFontSizes.medium,
left: isRTL ? '-0.5px' : '.5px',
top: '-1px',
selectors: (_d = {
':hover': {
opacity: 1,
}
},
_d[Styling_1.HighContrastSelector] = tslib_1.__assign({},
_d),
},
checked && {
opacity: 1,
fontWeight: 900,
border: 'none',
},
_e),
},
],
checkHost: classNames.checkHost,
};
};
//# sourceMappingURL=Check.styles.js.map
/***/ }),
/***/ 67571:
"use strict";

//# sourceMappingURL=Check.types.js.map
/***/ }),
/***/ 69653:
"use strict";

/***/ }),
/***/ 57720:
"use strict";

exports.CheckboxBase = void 0;
exports.CheckboxBase = React.forwardRef(function (props, forwardedRef) {
var disabled = props.disabled, required = props.required, inputProps =
props.inputProps, name = props.name, ariaLabel = props.ariaLabel, ariaLabelledBy =
props.ariaLabelledBy, ariaDescribedBy = props.ariaDescribedBy, ariaPositionInSet =
props.ariaPositionInSet, ariaSetSize = props.ariaSetSize, title = props.title,
checkmarkIconProps = props.checkmarkIconProps, styles = props.styles, theme =
props.theme, className = props.className, _a = props.boxSide, boxSide = _a === void
0 ? 'start' : _a;
var id = react_hooks_1.useId('checkbox-', props.id);
var rootRef = React.useRef(null);
var mergedRootRefs = react_hooks_1.useMergedRefs(rootRef, forwardedRef);
var inputRef = React.useRef(null);
var _b = react_hooks_1.useControllableValue(props.checked,
props.defaultChecked, props.onChange), isChecked = _b[0], setIsChecked = _b[1];
var _c = react_hooks_1.useControllableValue(props.indeterminate,
props.defaultIndeterminate), isIndeterminate = _c[0], setIsIndeterminate = _c[1];
utilities_1.useFocusRects(rootRef);
useDebugWarning(props);
useComponentRef(props, isChecked, isIndeterminate, inputRef);
theme: theme,
disabled: disabled,
indeterminate: isIndeterminate,
checked: isChecked,
reversed: boxSide !== 'start',
isUsingCustomLabelRender: !!props.onRenderLabel,
});
var onChange = function (ev) {
if (isIndeterminate) {
// If indeterminate, clicking the checkbox *only* removes the
indeterminate state (or if
// controlled, lets the consumer know to change it by calling
onChange). It doesn't
// change the checked state.
setIsChecked(!!isChecked, ev);
setIsIndeterminate(false);
}
else {
setIsChecked(!isChecked, ev);
}
};
var defaultLabelRenderer = React.useCallback(function (checkboxProps) {
if (!checkboxProps) {
return null;
}
return checkboxProps.label ? (React.createElement("span", { className:
classNames.text, title: checkboxProps.title }, checkboxProps.label)) : null;
}, [classNames.text]);
var onRenderLabel = props.onRenderLabel || defaultLabelRenderer;
var ariaChecked = isIndeterminate
? 'mixed'
: undefined;
var mergedInputProps = tslib_1.__assign(tslib_1.__assign({ className:
classNames.input, type: 'checkbox' }, inputProps), { checked: !!isChecked,
disabled: disabled, required: required, name: name, id: id, title: title, onChange:
onChange, 'aria-disabled': disabled, 'aria-label': ariaLabel, 'aria-labelledby':
ariaLabelledBy, 'aria-describedby': ariaDescribedBy, 'aria-posinset':
ariaPositionInSet, 'aria-setsize': ariaSetSize, 'aria-checked': ariaChecked });
return (React.createElement("div", { className: classNames.root, title: title,
ref: mergedRootRefs },
React.createElement("input", tslib_1.__assign({}, mergedInputProps, { ref:
inputRef, title: title, "data-ktp-execute-target": true })),
React.createElement("label", { className: classNames.label, htmlFor: id },
React.createElement("div", { className: classNames.checkbox, "data-ktp-
target": true },
React.createElement(Icon_1.Icon, tslib_1.__assign({ iconName:
"CheckMark" }, checkmarkIconProps, { className: classNames.checkmark }))),
onRenderLabel(props, defaultLabelRenderer))));
});
exports.CheckboxBase.displayName = 'CheckboxBase';
function useDebugWarning(props) {
if (false) {}
}
function useComponentRef(props, isChecked, isIndeterminate, checkBoxRef) {
get checked() {
return !!isChecked;
},
get indeterminate() {
return !!isIndeterminate;
},
if (checkBoxRef.current) {
checkBoxRef.current.focus();
}
},
}); }, [checkBoxRef, isChecked, isIndeterminate]);
}
//# sourceMappingURL=Checkbox.base.js.map
/***/ }),
/***/ 12879:
"use strict";

exports.Checkbox = void 0;
var Checkbox_base_1 = __webpack_require__(57720);
var Checkbox_styles_1 = __webpack_require__(81479);
exports.Checkbox = utilities_1.styled(Checkbox_base_1.CheckboxBase,
Checkbox_styles_1.getStyles, undefined, { scope: 'Checkbox' });
//# sourceMappingURL=Checkbox.js.map
/***/ }),
/***/ 81479:
"use strict";

root: 'ms-Checkbox',
label: 'ms-Checkbox-label',
checkbox: 'ms-Checkbox-checkbox',
checkmark: 'ms-Checkbox-checkmark',
text: 'ms-Checkbox-text',
};
var MS_CHECKBOX_LABEL_SIZE = '20px';
var MS_CHECKBOX_TRANSITION_DURATION = '200ms';
var MS_CHECKBOX_TRANSITION_TIMING = 'cubic-bezier(.4, 0, .23, 1)';
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
var className = props.className, theme = props.theme, reversed =
props.reversed, checked = props.checked, disabled = props.disabled,
isUsingCustomLabelRender = props.isUsingCustomLabelRender, indeterminate =
props.indeterminate;
var semanticColors = theme.semanticColors, effects = theme.effects, palette =
theme.palette, fonts = theme.fonts;
theme);
var checkmarkFontColor = semanticColors.inputForegroundChecked;
// TODO: after updating the semanticColors slots mapping this needs to be
semanticColors.inputBorder
var checkmarkFontColorHovered = palette.neutralSecondary;
semanticColors.smallInputBorder
var checkboxBorderColor = palette.neutralPrimary;
var checkboxBorderIndeterminateColor = semanticColors.inputBackgroundChecked;
var checkboxBorderColorChecked = semanticColors.inputBackgroundChecked;
var checkboxBorderColorDisabled = semanticColors.disabledBodySubtext;
var checkboxBorderHoveredColor = semanticColors.inputBorderHovered;
var checkboxBorderIndeterminateHoveredColor =
semanticColors.inputBackgroundCheckedHovered;
var checkboxBackgroundChecked = semanticColors.inputBackgroundChecked;
// TODO: after updating the semanticColors slots mapping the following 2 tokens
need to be
// semanticColors.inputBackgroundCheckedHovered
var checkboxBackgroundCheckedHovered =
var checkboxBorderColorCheckedHovered =
var checkboxHoveredTextColor = semanticColors.inputTextHovered;
var checkboxBackgroundDisabledChecked = semanticColors.disabledBodySubtext;
var checkboxTextColor = semanticColors.bodyText;
var checkboxTextColorDisabled = semanticColors.disabledText;
var indeterminateDotStyles = [
(_a = {
content: '""',
width: 10,
height: 10,
top: 4,
left: 4,
borderWidth: 5,
borderColor: disabled ? checkboxBorderColorDisabled :
checkboxBorderIndeterminateColor,
transitionProperty: 'border-width, border, border-color',
transitionDuration: MS_CHECKBOX_TRANSITION_DURATION,
transitionTimingFunction: MS_CHECKBOX_TRANSITION_TIMING
},
},
_a),
];
return {
root: [
classNames.root,
{
display: 'flex',
},
reversed && 'reversed',
checked && 'is-checked',
!disabled && 'is-enabled',
disabled && 'is-disabled',
!disabled && [
!checked && (_b = {},
_b[":hover ." + classNames.checkbox] = (_c = {
borderColor: checkboxBorderHoveredColor
},
},
_c),
_b[":focus ." + classNames.checkbox] = { borderColor:
checkboxBorderHoveredColor },
_b[":hover ." + classNames.checkmark] = (_d = {
color: checkmarkFontColorHovered,
opacity: '1'
},
color: 'Highlight',
},
_d),
_b),
checked &&
!indeterminate && (_e = {},
_e[":hover ." + classNames.checkbox] = {
background: checkboxBackgroundCheckedHovered,
borderColor: checkboxBorderColorCheckedHovered,
},
_e[":focus ." + classNames.checkbox] = {
background: checkboxBackgroundCheckedHovered,
borderColor: checkboxBorderColorCheckedHovered,
},
_e[style_utilities_1.HighContrastSelector] = (_f = {},
_f[":hover ." + classNames.checkbox] = {
background: 'Highlight',
},
_f[":focus ." + classNames.checkbox] = {
},
_f[":focus:hover ." + classNames.checkbox] = {
},
_f[":focus:hover ." + classNames.checkmark] = {
color: 'Window',
},
_f[":hover ." + classNames.checkmark] = {
color: 'Window',
},
_f),
_e),
indeterminate && (_g = {},
_g[":hover ." + classNames.checkbox + ", :hover ." +
classNames.checkbox + ":after"] = (_h = {
borderColor: checkboxBorderIndeterminateHoveredColor
},
_h[style_utilities_1.HighContrastSelector] = {
},
_h),
_g[":focus ." + classNames.checkbox] = {
borderColor: checkboxBorderIndeterminateHoveredColor,
},
_g[":hover ." + classNames.checkmark] = {
opacity: '0',
},
_g),
(_j = {},
_j[":hover ." + classNames.text + ", :focus ." +
classNames.text] = (_k = {
color: checkboxHoveredTextColor
},
color: disabled ? 'GrayText' : 'WindowText',
},
_k),
_j),
],
className,
],
input: (_l = {
background: 'none',
opacity: 0
},
_l["." + utilities_1.IsFocusVisibleClassName + " &:focus +
label::before"] = (_m = {
outline: '1px solid ' + theme.palette.neutralSecondary,
outlineOffset: '2px'
},
_m[style_utilities_1.HighContrastSelector] = {
outline: '1px solid WindowText',
},
_m),
_l),
label: [
classNames.label,
theme.fonts.medium,
{
display: 'flex',
alignItems: isUsingCustomLabelRender ? 'center' : 'flex-start',
cursor: disabled ? 'default' : 'pointer',
userSelect: 'none',
},
reversed && {
flexDirection: 'row-reverse',
justifyContent: 'flex-end',
},
{
'&::before': {
left: 0,
right: 0,
top: 0,
bottom: 0,
content: '""',
},
},
],
checkbox: [
classNames.checkbox,
(_o = {
display: 'flex',
flexShrink: 0,
height: MS_CHECKBOX_LABEL_SIZE,
width: MS_CHECKBOX_LABEL_SIZE,
border: "1px solid " + checkboxBorderColor,
transitionProperty: 'background, border, border-color',
transitionDuration: MS_CHECKBOX_TRANSITION_DURATION,
transitionTimingFunction: MS_CHECKBOX_TRANSITION_TIMING,
/* in case the icon is bigger than the box */
overflow: 'hidden',
':after': indeterminate ? indeterminateDotStyles : null
},
_o[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ borderColor: 'WindowText' },
_o),
indeterminate && {
borderColor: checkboxBorderIndeterminateColor,
},
!reversed
? // This margin on the checkbox is for backwards compat. Notably
it has the effect where a customRender
// is used, there will be only a 4px margin from checkbox to
label. The label by default would have
// another 4px margin for a total of 8px margin between
checkbox and label. We don't combine the two
// (and move it into the text) to not incur a breaking change
for everyone using custom render atm.
{
marginRight: 4,
}
: {
marginLeft: 4,
},
!disabled &&
!indeterminate &&
checked && (_p = {
background: checkboxBackgroundChecked,
borderColor: checkboxBorderColorChecked
},
_p[style_utilities_1.HighContrastSelector] = {
},
_p),
disabled && (_q = {
borderColor: checkboxBorderColorDisabled
},
_q[style_utilities_1.HighContrastSelector] = {
},
_q),
checked &&
disabled && (_r = {
background: checkboxBackgroundDisabledChecked,
borderColor: checkboxBorderColorDisabled
},
_r[style_utilities_1.HighContrastSelector] = {
},
_r),
],
checkmark: [
classNames.checkmark,
(_s = {
opacity: checked && !indeterminate ? '1' : '0',
color: checkmarkFontColor
},
_s[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ color: disabled ? 'GrayText' : 'Window' },
_s),
],
text: [
classNames.text,
(_t = {
color: disabled ? checkboxTextColorDisabled :
checkboxTextColor,
fontSize: fonts.medium.fontSize,
lineHeight: '20px'
},
_t[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ color: disabled ? 'GrayText' : 'WindowText' },
_t),
!reversed
? {
marginLeft: 4,
}
: {
marginRight: 4,
},
],
};
};
//# sourceMappingURL=Checkbox.styles.js.map
/***/ }),
/***/ 40411:
"use strict";

//# sourceMappingURL=Checkbox.types.js.map
/***/ }),
/***/ 87056:
"use strict";

/***/ }),
/***/ 74514:
"use strict";

exports.ChoiceGroupBase = void 0;
var Label_1 = __webpack_require__(8084);
var getOptionId = function (option, id) {
return id + "-" + option.key;
};
var findOption = function (options, key) {
return key === undefined ? undefined : Utilities_1.find(options, function
(value) { return value.key === key; });
};
var focusSelectedOption = function (options, keyChecked, id) {
var optionToFocus = findOption(options, keyChecked) || options.filter(function
(option) { return !option.disabled; })[0];
var elementToFocus = optionToFocus &&
document.getElementById(getOptionId(optionToFocus, id));
Utilities_1.setFocusVisibility(true, elementToFocus);
}
};
var focusFromFocusTrapZone = function (evt) {
return evt.relatedTarget instanceof HTMLElement &&
evt.relatedTarget.dataset.isFocusTrapZoneBumper === 'true';
};
var useComponentRef = function (options, keyChecked, id, componentRef) {
get checkedOption() {
return findOption(options, keyChecked);
},
focusSelectedOption(options, keyChecked, id);
},
}); }, [options, keyChecked, id]);
};
var COMPONENT_NAME = 'ChoiceGroup';
exports.ChoiceGroupBase = React.forwardRef(function (props, forwardedRef) {
var className = props.className, theme = props.theme, styles = props.styles, _a
= props.options, options = _a === void 0 ? [] : _a, label = props.label, required =
props.required, disabled = props.disabled, name = props.name, defaultSelectedKey =
props.defaultSelectedKey, componentRef = props.componentRef, onChange =
props.onChange;
var id = react_hooks_1.useId('ChoiceGroup');
var labelId = react_hooks_1.useId('ChoiceGroupLabel');
var divProps = Utilities_1.getNativeProps(props, Utilities_1.divProperties, [
'onChange',
'className',
'required',
]);
theme: theme,
optionsContainIconOrImage: options.some(function (option) { return !!
(option.iconProps || option.imageSrc); }),
});
var ariaLabelledBy = props.ariaLabelledBy || (label ? labelId : props['aria-
labelledby']);
var _b = react_hooks_1.useControllableValue(props.selectedKey,
defaultSelectedKey), keyChecked = _b[0], setKeyChecked = _b[1];
var _c = React.useState(), keyFocused = _c[0], setKeyFocused = _c[1];
useDebugWarnings(props);
useComponentRef(options, keyChecked, id, componentRef);
Utilities_1.useFocusRects(rootRef);
var onFocus = React.useCallback(function (ev, option) {
var _a;
if (option) {
setKeyFocused(option.itemKey);
(_a = option.onFocus) === null || _a === void 0 ? void 0 :
_a.call(option, ev);
}
}, []);
var onBlur = React.useCallback(function (ev, option) {
var _a;
setKeyFocused(undefined);
(_a = option === null || option === void 0 ? void 0 : option.onBlur) ===
null || _a === void 0 ? void 0 : _a.call(option, ev);
}, []);
var onOptionChange = React.useCallback(function (evt, option) {
var _a;
if (!option) {
return;
}
setKeyChecked(option.itemKey);
(_a = option.onChange) === null || _a === void 0 ? void 0 : _a.call(option,
evt);
onChange === null || onChange === void 0 ? void 0 : onChange(evt,
findOption(options, option.itemKey));
}, [onChange, options, setKeyChecked]);
var onRadioFocus = React.useCallback(function (evt) {
// Handles scenarios like this bug:
https://github.com/microsoft/fluentui/issues/20173
if (focusFromFocusTrapZone(evt)) {
focusSelectedOption(options, keyChecked, id);
}
}, [options, keyChecked, id]);
classNames.root }, divProps, { ref: mergedRootRefs }),
React.createElement("div", tslib_1.__assign({ role: "radiogroup" },
(ariaLabelledBy && { 'aria-labelledby': ariaLabelledBy }), { onFocus:
onRadioFocus }),
label && (React.createElement(Label_1.Label, { className:
classNames.label, required: required, id: labelId, disabled: disabled }, label)),
React.createElement("div", { className: classNames.flexContainer },
options.map(function (option) {
return (React.createElement(index_1.ChoiceGroupOption,
tslib_1.__assign({ itemKey: option.key }, option, { key: option.key, onBlur:
onBlur, onFocus: onFocus, onChange: onOptionChange, focused: option.key ===
keyFocused, checked: option.key === keyChecked, disabled: option.disabled ||
disabled, id: getOptionId(option, id), labelId: option.labelId || labelId + "-" +
option.key, name: name || id, required: required })));
})))));
});
exports.ChoiceGroupBase.displayName = COMPONENT_NAME;
function useDebugWarnings(props) {
if (false) {}
}
//# sourceMappingURL=ChoiceGroup.base.js.map
/***/ }),
/***/ 41015:
"use strict";

exports.ChoiceGroup = void 0;
var ChoiceGroup_base_1 = __webpack_require__(74514);
var ChoiceGroup_styles_1 = __webpack_require__(68697);
exports.ChoiceGroup = Utilities_1.styled(ChoiceGroup_base_1.ChoiceGroupBase,
ChoiceGroup_styles_1.getStyles, undefined, { scope: 'ChoiceGroup' });
//# sourceMappingURL=ChoiceGroup.js.map
/***/ }),
/***/ 68697:
"use strict";

root: 'ms-ChoiceFieldGroup',
flexContainer: 'ms-ChoiceFieldGroup-flexContainer',
};
var className = props.className, optionsContainIconOrImage =
props.optionsContainIconOrImage, theme = props.theme;
return {
root: [
className,
classNames.root,
theme.fonts.medium,
{
display: 'block',
},
],
flexContainer: [
classNames.flexContainer,
optionsContainIconOrImage && {
display: 'flex',
flexWrap: 'wrap',
},
],
};
};
//# sourceMappingURL=ChoiceGroup.styles.js.map
/***/ }),
/***/ 77004:
"use strict";

//# sourceMappingURL=ChoiceGroup.types.js.map
/***/ }),
/***/ 85087:
"use strict";

exports.ChoiceGroupOptionBase = void 0;
var Image_1 = __webpack_require__(63132);
var LARGE_IMAGE_SIZE = 71;
// This ensures default imageSize value doesn't mutate. Mutation can cause
style re-calcuation.
imageSize: { width: 32, height: 32 },
};
var ChoiceGroupOptionBase = function (propsWithoutDefaults) {
// Mix the `key` prop back in since custom render functions may be expecting it
// (React uses `key` internally rather than passing it through to the
component)
var props =
Utilities_1.getPropsWithDefaults(tslib_1.__assign(tslib_1.__assign({},
DEFAULT_PROPS), { key: propsWithoutDefaults.itemKey }), propsWithoutDefaults);
var ariaLabel = props.ariaLabel, focused = props.focused, required =
props.required, theme = props.theme, iconProps = props.iconProps, imageSrc =
props.imageSrc, imageSize = props.imageSize, disabled = props.disabled, checked =
props.checked, id = props.id, styles = props.styles, name = props.name, rest =
tslib_1.__rest(props, ["ariaLabel", "focused", "required", "theme", "iconProps",
"imageSrc", "imageSize", "disabled", "checked", "id", "styles", "name"]);
theme: theme,
hasIcon: !!iconProps,
hasImage: !!imageSrc,
checked: checked,
disabled: disabled,
imageIsLarge: !!imageSrc && (imageSize.width > LARGE_IMAGE_SIZE ||
imageSize.height > LARGE_IMAGE_SIZE),
imageSize: imageSize,
focused: focused,
});
var _a = Utilities_1.getNativeProps(rest, Utilities_1.inputProperties),
className = _a.className, nativeProps = tslib_1.__rest(_a, ["className"]);
var defaultOnRenderLabel = function () {
return (React.createElement("span", { id: props.labelId, className: "ms-
ChoiceFieldLabel" }, props.text));
};
var defaultOnRenderField = function () {
var _a = props.imageAlt, imageAlt = _a === void 0 ? '' : _a,
selectedImageSrc = props.selectedImageSrc;
var onRenderLabel = props.onRenderLabel
? Utilities_1.composeRenderFunction(props.onRenderLabel,
defaultOnRenderLabel)
: defaultOnRenderLabel;
var label = onRenderLabel(props);
return (React.createElement("label", { htmlFor: id, className:
classNames.field },
imageSrc && (React.createElement("div", { className:
classNames.innerField },
React.createElement("div", { className: classNames.imageWrapper },
React.createElement(Image_1.Image, tslib_1.__assign({ src:
imageSrc, alt: imageAlt }, imageSize))),
classNames.selectedImageWrapper },
React.createElement(Image_1.Image, tslib_1.__assign({ src:
selectedImageSrc, alt: imageAlt }, imageSize))))),
iconProps && (React.createElement("div", { className:
classNames.innerField },
React.createElement("div", { className: classNames.iconWrapper },
React.createElement(Icon_1.Icon, tslib_1.__assign({},
iconProps))))),
imageSrc || iconProps ? React.createElement("div", { className:
classNames.labelWrapper }, label) : label));
};
var _b = props.onRenderField, onRenderField = _b === void 0 ?
defaultOnRenderField : _b;
var onChange = function (evt) {
var _a;
(_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props,
evt, props);
};
var onBlur = function (evt) {
var _a;
(_a = props.onBlur) === null || _a === void 0 ? void 0 : _a.call(props,
evt);
};
var onFocus = function (evt) {
var _a;
(_a = props.onFocus) === null || _a === void 0 ? void 0 : _a.call(props,
evt, props);
};
React.createElement("div", { className: classNames.choiceFieldWrapper },
React.createElement("input", tslib_1.__assign({ "aria-label":
ariaLabel, id: id, className: Utilities_1.css(classNames.input, className), type:
"radio", name: name, disabled: disabled, checked: checked, required: required },
nativeProps, { onChange: onChange, onFocus: onFocus, onBlur: onBlur })),
onRenderField(props, defaultOnRenderField))));
};
exports.ChoiceGroupOptionBase = ChoiceGroupOptionBase;
exports.ChoiceGroupOptionBase.displayName = 'ChoiceGroupOption';
//# sourceMappingURL=ChoiceGroupOption.base.js.map
/***/ }),
/***/ 59848:
"use strict";

exports.ChoiceGroupOption = void 0;
var ChoiceGroupOption_base_1 = __webpack_require__(85087);
var ChoiceGroupOption_styles_1 = __webpack_require__(6131);
exports.ChoiceGroupOption =
Utilities_1.styled(ChoiceGroupOption_base_1.ChoiceGroupOptionBase,
ChoiceGroupOption_styles_1.getStyles, undefined, { scope: 'ChoiceGroupOption' });
//# sourceMappingURL=ChoiceGroupOption.js.map
/***/ }),
/***/ 6131:
"use strict";

root: 'ms-ChoiceField',
choiceFieldWrapper: 'ms-ChoiceField-wrapper',
input: 'ms-ChoiceField-input',
field: 'ms-ChoiceField-field',
innerField: 'ms-ChoiceField-innerField',
imageWrapper: 'ms-ChoiceField-imageWrapper',
iconWrapper: 'ms-ChoiceField-iconWrapper',
labelWrapper: 'ms-ChoiceField-labelWrapper',
checked: 'is-checked',
};
var labelWrapperLineHeight = 15;
var labelWrapperHeight = labelWrapperLineHeight * 2 + 2; // adding 2px height to
ensure text doesn't get cutoff
var iconSize = 32;
var choiceFieldSize = 20;
var choiceFieldTransitionDuration = '200ms';
var choiceFieldTransitionTiming = 'cubic-bezier(.4, 0, .23, 1)';
var radioButtonSpacing = 3;
var radioButtonInnerSize = 5;
function getChoiceGroupFocusStyle(focusBorderColor, hasIconOrImage) {
var _a, _b;
return [
'is-inFocus',
{
_a["." + Utilities_1.IsFocusVisibleClassName + " &"] = {
selectors: {
'::-moz-focus-inner': {
border: 0,
},
':after': {
content: '""',
top: -2,
right: -2,
bottom: -2,
left: -2,
border: "1px solid " + focusBorderColor,
borderWidth: hasIconOrImage ? 1 : 2,
},
_b),
},
},
},
_a),
},
];
}
function getImageWrapperStyle(isSelectedImageWrapper, className, checked) {
return [
className,
{
paddingBottom: 2,
transitionProperty: 'opacity',
transitionDuration: choiceFieldTransitionDuration,
transitionTimingFunction: 'ease',
selectors: {
'.ms-Image': {
borderStyle: 'none',
},
},
},
(checked ? !isSelectedImageWrapper : isSelectedImageWrapper) && [
'is-hidden',
{
left: 0,
top: 0,
width: '100%',
height: '100%',
overflow: 'hidden',
opacity: 0,
},
],
];
}
var _a, _b, _c, _d, _e;
var theme = props.theme, hasIcon = props.hasIcon, hasImage = props.hasImage,
checked = props.checked, disabled = props.disabled, imageIsLarge =
props.imageIsLarge, focused = props.focused, imageSize = props.imageSize;
theme.fonts;
// Tokens
semanticColors.smallInputBorder
var circleBorderColor = palette.neutralPrimary;
var circleHoveredBorderColor = semanticColors.inputBorderHovered;
var circleCheckedBorderColor = semanticColors.inputBackgroundChecked;
semanticColors.inputBackgroundCheckedHovered
var circleCheckedHoveredBorderColor = palette.themeDark;
var circleDisabledBorderColor = semanticColors.disabledBodySubtext;
var circleBackgroundColor = semanticColors.bodyBackground;
var dotUncheckedHoveredColor = palette.neutralSecondary;
var dotCheckedColor = semanticColors.inputBackgroundChecked;
var dotCheckedHoveredColor = palette.themeDark;
var dotDisabledColor = semanticColors.disabledBodySubtext;
semanticColors.bodyTextChecked
var labelHoverFocusColor = palette.neutralDark;
var focusBorderColor = semanticColors.focusBorder;
var iconOrImageChoiceBorderUncheckedHoveredColor =
semanticColors.inputBorderHovered;
var iconOrImageChoiceBorderCheckedColor =
semanticColors.inputBackgroundChecked;
var iconOrImageChoiceBorderCheckedHoveredColor = palette.themeDark;
var iconOrImageChoiceBackgroundColor = palette.neutralLighter;
var fieldHoverOrFocusProperties = {
selectors: {
'.ms-ChoiceFieldLabel': {
color: labelHoverFocusColor,
},
':before': {
borderColor: checked ? circleCheckedHoveredBorderColor :
circleHoveredBorderColor,
},
':after': [
!hasIcon &&
!hasImage &&
!checked && {
content: '""',
transitionProperty: 'background-color',
left: 5,
top: 5,
width: 10,
height: 10,
backgroundColor: dotUncheckedHoveredColor,
},
checked && {
borderColor: dotCheckedHoveredColor,
background: dotCheckedHoveredColor,
},
],
},
};
var enabledFieldWithImageHoverOrFocusProperties = {
borderColor: checked ? iconOrImageChoiceBorderCheckedHoveredColor :
iconOrImageChoiceBorderUncheckedHoveredColor,
selectors: {
':before': {
opacity: 1,
borderColor: checked ? circleCheckedHoveredBorderColor :
circleHoveredBorderColor,
},
},
};
var circleAreaProperties = [
{
content: '""',
backgroundColor: circleBackgroundColor,
borderWidth: 1,
borderColor: circleBorderColor,
width: choiceFieldSize,
height: choiceFieldSize,
top: 0,
left: 0,
transitionProperty: 'border-color',
transitionTimingFunction: choiceFieldTransitionTiming,
},
disabled && {
borderColor: circleDisabledBorderColor,
tslib_1.__assign({ borderColor: 'GrayText', background: 'Window' },
_a),
},
checked && {
borderColor: disabled ? circleDisabledBorderColor :
circleCheckedBorderColor,
},
_b),
},
(hasIcon || hasImage) && {
top: radioButtonSpacing,
right: radioButtonSpacing,
left: 'auto',
opacity: checked ? 1 : 0,
},
];
var dotAreaProperties = [
{
content: '""',
width: 0,
height: 0,
left: choiceFieldSize / 2,
right: 0,
transitionProperty: 'border-width',
transitionTimingFunction: choiceFieldTransitionTiming,
},
checked && {
borderWidth: 5,
borderColor: disabled ? dotDisabledColor : dotCheckedColor,
background: dotCheckedColor,
left: 5,
top: 5,
width: 10,
height: 10,
},
_c),
},
checked &&
top: radioButtonSpacing + radioButtonInnerSize,
right: radioButtonSpacing + radioButtonInnerSize,
left: 'auto', // To reset the value of 'left' to its default value, so
that 'right' works
},
];
return {
root: [
classNames.root,
theme.fonts.medium,
{
display: 'flex',
color: semanticColors.bodyText,
minHeight: 26,
border: 'none',
marginTop: 8,
selectors: {
},
},
},
!hasIcon &&
!hasImage && {
selectors: {
paddingLeft: '26px',
},
},
},
hasImage && 'ms-ChoiceField--image',
hasIcon && 'ms-ChoiceField--icon',
fontSize: 0,
margin: '0 4px 4px 0',
paddingLeft: 0,
backgroundColor: iconOrImageChoiceBackgroundColor,
height: '100%',
},
],
choiceFieldWrapper: [
classNames.choiceFieldWrapper,
focused && getChoiceGroupFocusStyle(focusBorderColor, hasIcon ||
hasImage),
],
// The hidden input
input: [
classNames.input,
{
opacity: 0,
top: 0,
right: 0,
width: '100%',
height: '100%',
margin: 0,
},
],
field: [
classNames.field,
checked && classNames.checked,
{
cursor: 'pointer',
marginTop: 0,
userSelect: 'none',
minHeight: 20,
selectors: {
':hover': !disabled && fieldHoverOrFocusProperties,
':focus': !disabled && fieldHoverOrFocusProperties,
// The circle
':before': circleAreaProperties,
// The dot
':after': dotAreaProperties,
},
},
hasIcon && 'ms-ChoiceField--icon',
hasImage && 'ms-ChoiceField-field--image',
cursor: 'pointer',
paddingTop: 22,
margin: 0,
transitionProperty: 'all',
transitionTimingFunction: 'ease',
display: 'flex',
},
checked && {
borderColor: iconOrImageChoiceBorderCheckedColor,
},
(hasIcon || hasImage) &&
!disabled && {
selectors: {
':hover': enabledFieldWithImageHoverOrFocusProperties,
':focus': enabledFieldWithImageHoverOrFocusProperties,
},
},
disabled && {
cursor: 'default',
selectors: {
color: semanticColors.disabledBodyText,
_d[Styling_1.HighContrastSelector] = tslib_1.__assign({
color: 'GrayText' }, Styling_1.getHighContrastNoAdjustStyle()),
_d),
},
},
},
checked &&
disabled && {
borderColor: iconOrImageChoiceBackgroundColor,
},
],
innerField: [
classNames.innerField,
hasImage && {
// using non-null assertion because we have a default in
`ChoiceGroupOptionBase` class.
height: imageSize.height,
width: imageSize.width,
},
paddingLeft: 30,
paddingRight: 30,
},
imageIsLarge && {
paddingLeft: 24,
paddingRight: 24,
},
disabled && {
opacity: 0.25,
color: 'GrayText',
opacity: 1,
},
_e),
},
],
imageWrapper: getImageWrapperStyle(false, classNames.imageWrapper,
checked),
selectedImageWrapper: getImageWrapperStyle(true, classNames.imageWrapper,
checked),
iconWrapper: [
classNames.iconWrapper,
{
fontSize: iconSize,
lineHeight: iconSize,
height: iconSize,
},
],
labelWrapper: [
classNames.labelWrapper,
fonts.medium,
display: 'block',
margin: '4px 8px 2px 8px',
height: labelWrapperHeight,
lineHeight: labelWrapperLineHeight,
// using non-null assertion because we have a default in
`ChoiceGroupOptionBase` class.
maxWidth: imageSize.width * 2,
overflow: 'hidden',
whiteSpace: 'pre-wrap',
},
],
};
};
//# sourceMappingURL=ChoiceGroupOption.styles.js.map
/***/ }),
/***/ 88640:
"use strict";

//# sourceMappingURL=ChoiceGroupOption.types.js.map
/***/ }),
/***/ 8214:
"use strict";

/***/ }),
/***/ 59076:
"use strict";

/***/ }),
/***/ 81936:
"use strict";

exports.Beak = exports.BEAK_WIDTH = exports.BEAK_HEIGHT = void 0;
var Beak_styles_1 = __webpack_require__(35652);
exports.BEAK_HEIGHT = 10;
exports.BEAK_WIDTH = 18;
exports.Beak = React.forwardRef(function (props, forwardedRef) {
var left = props.left, top = props.top, bottom = props.bottom, right =
props.right, color = props.color, _a = props.direction, direction = _a === void 0 ?
Positioning_1.RectangleEdge.top : _a;
var svgHeight;
var svgWidth;
if (direction === Positioning_1.RectangleEdge.top || direction ===
Positioning_1.RectangleEdge.bottom) {
svgHeight = exports.BEAK_HEIGHT;
svgWidth = exports.BEAK_WIDTH;
}
else {
svgHeight = exports.BEAK_WIDTH;
svgWidth = exports.BEAK_HEIGHT;
}
var pointOne;
var pointTwo;
var pointThree;
var transform;
switch (direction) {
case Positioning_1.RectangleEdge.top:
default:
pointOne = exports.BEAK_WIDTH / 2 + ", 0";
pointTwo = exports.BEAK_WIDTH + ", " + exports.BEAK_HEIGHT;
pointThree = "0, " + exports.BEAK_HEIGHT;
transform = 'translateY(-100%)';
break;
case Positioning_1.RectangleEdge.right:
pointOne = "0, 0";
pointTwo = exports.BEAK_HEIGHT + ", " + exports.BEAK_HEIGHT;
pointThree = "0, " + exports.BEAK_WIDTH;
transform = 'translateX(100%)';
break;
case Positioning_1.RectangleEdge.bottom:
pointOne = "0, 0";
pointTwo = exports.BEAK_WIDTH + ", 0";
pointThree = exports.BEAK_WIDTH / 2 + ", " + exports.BEAK_HEIGHT;
transform = 'translateY(100%)';
break;
case Positioning_1.RectangleEdge.left:
pointOne = exports.BEAK_HEIGHT + ", 0";
pointTwo = "0, " + exports.BEAK_HEIGHT;
pointThree = exports.BEAK_HEIGHT + ", " + exports.BEAK_WIDTH;
transform = 'translateX(-100%)';
break;
}
var classNames = getClassNames(Beak_styles_1.getStyles, {
left: left,
top: top,
bottom: bottom,
right: right,
height: svgHeight + "px",
width: svgWidth + "px",
transform: transform,
color: color,
});
return (React.createElement("div", { className: classNames.root, role:
"presentation", ref: forwardedRef },
React.createElement("svg", { height: svgHeight, width: svgWidth, className:
classNames.beak },
React.createElement("polygon", { points: pointOne + ' ' + pointTwo + '
' + pointThree }))));
});
exports.Beak.displayName = 'Beak';
//# sourceMappingURL=Beak.js.map
/***/ }),
/***/ 35652:
"use strict";

function getStyles(props) {
var _a;
return {
root: [
{
boxShadow: 'inherit',
border: 'none',
transform: props.transform,
width: props.width,
height: props.height,
left: props.left,
top: props.top,
right: props.right,
bottom: props.bottom,
},
],
beak: {
fill: props.color,
display: 'block',
fill: 'windowtext',
},
_a),
},
};
}
//# sourceMappingURL=Beak.styles.js.map
/***/ }),
/***/ 44320:
"use strict";

exports.CoachmarkBase = exports.COACHMARK_ATTRIBUTE_NAME = void 0;
// Utilities
// Component Dependencies
var Beak_1 = __webpack_require__(81936);
// Coachmark
var Coachmark_styles_1 = __webpack_require__(41454);
exports.COACHMARK_ATTRIBUTE_NAME = 'data-coachmarkid';
isCollapsed: true,
mouseProximityOffset: 10,
delayBeforeMouseOpen: 3600,
delayBeforeCoachmarkAnimation: 0,
isPositionForced: true,
positioningContainerProps: {
},
};
function useCollapsedState(props, entityInnerHostElementRef) {
var propsIsCollapsed = props.isCollapsed, onAnimationOpenStart =
props.onAnimationOpenStart, onAnimationOpenEnd = props.onAnimationOpenEnd;
/** Is the Coachmark currently collapsed into a tear drop shape */
var _a = React.useState(!!propsIsCollapsed), isCollapsed = _a[0],
setIsCollapsed = _a[1];
var setTimeout = react_hooks_1.useSetTimeout().setTimeout;
// Rather than pushing out logic elsewhere to prevent openCoachmark from being
called repeatedly,
// we'll track it here and only invoke the logic once. We do this with a ref,
rather than just the state,
// because the openCoachmark callback can be captured in scope for an effect
var hasCoachmarkBeenOpened = React.useRef(!isCollapsed);
var openCoachmark = React.useCallback(function () {
var _a, _b;
if (!hasCoachmarkBeenOpened.current) {
setIsCollapsed(false);
onAnimationOpenStart === null || onAnimationOpenStart === void 0 ? void
0 : onAnimationOpenStart();
(_b = (_a = entityInnerHostElementRef.current) === null || _a === void
0 ? void 0 : _a.addEventListener) === null || _b === void 0 ? void 0 : _b.call(_a,
'transitionend', function () {
// Need setTimeout to trigger narrator
setTimeout(function () {
if (entityInnerHostElementRef.current) {
Utilities_1.focusFirstChild(entityInnerHostElementRef.current);
}
}, 1000);
onAnimationOpenEnd === null || onAnimationOpenEnd === void 0 ? void
0 : onAnimationOpenEnd();
});
hasCoachmarkBeenOpened.current = true;
}
}, [entityInnerHostElementRef, onAnimationOpenEnd, onAnimationOpenStart,
setTimeout]);
if (!propsIsCollapsed) {
openCoachmark();
}
if isCollapsed changes
}, [propsIsCollapsed]);
return [isCollapsed, openCoachmark];
}
function usePositionedData() {
/**
* Alignment edge of callout in relation to target
*/
var _a = React.useState(), targetAlignment = _a[0], setTargetAlignment = _a[1];
/**
* Position of Coachmark/TeachingBubble in relation to target
*/
var _b = React.useState(), targetPosition = _b[0], setTargetPosition = _b[1];
var onPositioned = function (_a) {
var alignmentEdge = _a.alignmentEdge, targetEdge = _a.targetEdge;
return async.requestAnimationFrame(function () {
setTargetAlignment(alignmentEdge);
setTargetPosition(targetEdge);
});
};
return [targetAlignment, targetPosition, onPositioned];
}
function useBeakPosition(props, targetAlignment, targetPosition) {
var isRTL = Utilities_1.getRTL(props.theme);
return React.useMemo(function () {
var beakDirection = targetPosition === undefined ?
Positioning_1.RectangleEdge.bottom : Positioning_1.getOppositeEdge(targetPosition);
var beakPosition = { direction: beakDirection };
var transformOriginX;
var transformOriginY;
var distanceAdjustment = '3px'; // Adjustment distance for Beak to shift
towards Coachmark bubble.
switch (beakDirection) {
// If Beak is pointing Up or Down
case Positioning_1.RectangleEdge.top:
case Positioning_1.RectangleEdge.bottom:
// If there is no target alignment, then beak is X-axis centered in
callout
if (!targetAlignment) {
beakPosition.left = "calc(50% - " + Beak_1.BEAK_WIDTH / 2 +
"px)";
transformOriginX = 'center';
}
else {
// Beak is aligned to the left of target
if (targetAlignment === Positioning_1.RectangleEdge.left) {
beakPosition.left = Coachmark_styles_1.COACHMARK_WIDTH / 2
- Beak_1.BEAK_WIDTH / 2 + "px";
transformOriginX = 'left';
}
else {
// Beak is aligned to the right of target
beakPosition.right = Coachmark_styles_1.COACHMARK_WIDTH / 2
- Beak_1.BEAK_WIDTH / 2 + "px";
transformOriginX = 'right';
}
}
if (beakDirection === Positioning_1.RectangleEdge.top) {
beakPosition.top = distanceAdjustment;
transformOriginY = 'top';
}
else {
beakPosition.bottom = distanceAdjustment;
transformOriginY = 'bottom';
}
break;
// If Beak is pointing Left or Right
case Positioning_1.RectangleEdge.left:
case Positioning_1.RectangleEdge.right:
// If there is no target alignment, then beak is Y-axis centered in
callout
if (!targetAlignment) {
beakPosition.top = "calc(50% - " + Beak_1.BEAK_WIDTH / 2 +
"px)";
transformOriginY = "center";
}
else {
// Beak is aligned to the top of target
if (targetAlignment === Positioning_1.RectangleEdge.top) {
beakPosition.top = Coachmark_styles_1.COACHMARK_WIDTH / 2 -
Beak_1.BEAK_WIDTH / 2 + "px";
transformOriginY = "top";
}
else {
// Beak is aligned to the bottom of target
beakPosition.bottom = Coachmark_styles_1.COACHMARK_WIDTH /
2 - Beak_1.BEAK_WIDTH / 2 + "px";
transformOriginY = "bottom";
}
}
if (beakDirection === Positioning_1.RectangleEdge.left) {
if (isRTL) {
beakPosition.right = distanceAdjustment;
}
else {
beakPosition.left = distanceAdjustment;
}
transformOriginX = 'left';
}
else {
if (isRTL) {
beakPosition.left = distanceAdjustment;
}
else {
beakPosition.right = distanceAdjustment;
}
transformOriginX = 'right';
}
break;
}
return [beakPosition, transformOriginX + " " + transformOriginY];
}, [targetAlignment, targetPosition, isRTL]);
}
function useListeners(props, translateAnimationContainer, openCoachmark) {
var _a;
var document = (_a = Utilities_1.getDocument()) === null || _a === void 0 ?
void 0 : _a.documentElement;
react_hooks_1.useOnEvent(document, 'keydown', function (e) {
var _a, _b;
// Open coachmark if user presses ALT + C (arbitrary keypress for now)
if (
(e.altKey && e.which === Utilities_1.KeyCodes.c) ||
(e.which === Utilities_1.KeyCodes.enter && ((_b = (_a =
translateAnimationContainer.current) === null || _a === void 0 ? void 0 :
_a.contains) === null || _b === void 0 ? void 0 : _b.call(_a, e.target)))) {
openCoachmark();
}
}, true);
var dismissOnLostFocus = function (ev) {
var _a;
if (props.preventDismissOnLostFocus) {
var clickTarget = ev.target;
var clickedOutsideCallout = translateAnimationContainer.current && !
Utilities_1.elementContains(translateAnimationContainer.current, clickTarget);
var target = props.target;
if (clickedOutsideCallout && clickTarget !== target && !
Utilities_1.elementContains(target, clickTarget)) {
(_a = props.onDismiss) === null || _a === void 0 ? void 0 :
_a.call(props, ev);
}
}
};
react_hooks_1.useOnEvent(document, 'click', dismissOnLostFocus, true);
react_hooks_1.useOnEvent(document, 'focus', dismissOnLostFocus, true);
}
function useProximityHandlers(props, translateAnimationContainer, openCoachmark) {
var _a = react_hooks_1.useSetTimeout(), setTimeout = _a.setTimeout,
clearTimeout = _a.clearTimeout;
/** The target element the mouse would be in proximity to */
var targetElementRect = React.useRef();
var setTargetElementRect = function () {
if (translateAnimationContainer.current) {
targetElementRect.current =
translateAnimationContainer.current.getBoundingClientRect();
}
};
var events = new Utilities_1.EventGroup({});
// We don't want the user to immediately trigger the Coachmark when it's
opened
var _a = props.mouseProximityOffset, mouseProximityOffset = _a === void
0 ? 0 : _a;
/** Cached ids returned when setTimeout runs during the window resize
event trigger. */
var timeoutIds = [];
// Take the initial measure out of the initial render to prevent an
unnecessary render.
setTargetElementRect();
// When the window resizes we want to async get the bounding client
rectangle.
// Every time the event is triggered we want to setTimeout and then
clear any previous
// instances of setTimeout.
events.on(window, 'resize', function () {
timeoutIds.forEach(function (value) {
clearTimeout(value);
});
timeoutIds.splice(0, timeoutIds.length); // clear array
timeoutIds.push(setTimeout(function () {
}, 100));
});
}, 10);
// Every time the document's mouse move is triggered, we want to check
if inside of an element
// and set the state with the result.
events.on(document, 'mousemove', function (e) {
var _a;
var mouseY = e.clientY;
var mouseX = e.clientX;
if (isInsideElement(targetElementRect.current, mouseX, mouseY,
mouseProximityOffset)) {
openCoachmark();
}
(_a = props.onMouseMove) === null || _a === void 0 ? void 0 :
_a.call(props, e);
});
}, props.delayBeforeMouseOpen);
return function () { return events.dispose(); };
on mount
}, []);
}
function useComponentRef(props) {
var onDismiss = props.onDismiss;
React.useImperativeHandle(props.componentRef, function (ev) { return ({
dismiss: function () {
onDismiss === null || onDismiss === void 0 ? void 0 : onDismiss(ev);
},
}); }, [onDismiss]);
}
function useAriaAlert(_a) {
var ariaAlertText = _a.ariaAlertText;
/** ARIA alert text to read aloud with Narrator once the Coachmark is mounted
*/
var _b = React.useState(), alertText = _b[0], setAlertText = _b[1];
// Need to add RAF to have narrator read change in alert container
async.requestAnimationFrame(function () {
setAlertText(ariaAlertText);
});
on mount
}, []);
return alertText;
}
function useAutoFocus(_a) {
var preventFocusOnMount = _a.preventFocusOnMount;
var setTimeout = react_hooks_1.useSetTimeout().setTimeout;
/**
* The cached HTMLElement reference to the Entity Inner Host
* element.
*/
var entityHost = React.useRef(null);
if (!preventFocusOnMount) {
setTimeout(function () { var _a; return (_a = entityHost.current) ===
null || _a === void 0 ? void 0 : _a.focus(); }, 1000);
}
on mount
}, []);
return entityHost;
}
function useEntityHostMeasurements(props, entityInnerHostElementRef) {
/** Is the teaching bubble currently retrieving the original dimensions of the
hosted entity. */
var _a = React.useState(!!props.isCollapsed), isMeasuring = _a[0],
setIsMeasuring = _a[1];
/** Cached width and height of _entityInnerHostElement */
var _b = React.useState(props.isCollapsed ? { width: 0, height: 0 } : {}),
entityInnerHostRect = _b[0], setEntityInnerHostRect = _b[1];
if (entityInnerHostElementRef.current) {
setEntityInnerHostRect({
width: entityInnerHostElementRef.current.offsetWidth,
height: entityInnerHostElementRef.current.offsetHeight,
});
setIsMeasuring(false);
}
});
on mount
}, []);
return [isMeasuring, entityInnerHostRect];
}
function useDeprecationWarning(props) {
if (false) {}
}
var COMPONENT_NAME = 'CoachmarkBase';
exports.CoachmarkBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
var entityInnerHostElementRef = React.useRef(null);
var translateAnimationContainer = React.useRef(null);
var _a = usePositionedData(), targetAlignment = _a[0], targetPosition = _a[1],
onPositioned = _a[2];
var _b = useCollapsedState(props, entityInnerHostElementRef), isCollapsed =
_b[0], openCoachmark = _b[1];
var _c = useBeakPosition(props, targetAlignment, targetPosition),
beakPositioningProps = _c[0], transformOrigin = _c[1];
var _d = useEntityHostMeasurements(props, entityInnerHostElementRef),
isMeasuring = _d[0], entityInnerHostRect = _d[1];
var alertText = useAriaAlert(props);
var entityHost = useAutoFocus(props);
useListeners(props, translateAnimationContainer, openCoachmark);
useComponentRef(props);
useProximityHandlers(props, translateAnimationContainer, openCoachmark);
useDeprecationWarning(props);
var beaconColorOne = props.beaconColorOne, beaconColorTwo =
props.beaconColorTwo, children = props.children, target = props.target, color =
props.color, positioningContainerProps = props.positioningContainerProps,
ariaDescribedBy = props.ariaDescribedBy, ariaDescribedByText =
props.ariaDescribedByText, ariaLabelledBy = props.ariaLabelledBy,
ariaLabelledByText = props.ariaLabelledByText, ariaAlertText = props.ariaAlertText,
delayBeforeCoachmarkAnimation = props.delayBeforeCoachmarkAnimation, styles =
props.styles, theme = props.theme, className = props.className, persistentBeak =
props.persistentBeak;
// Defaulting the main background before passing it to the styles because it is
used for `Beak` too.
var defaultColor = color;
if (!defaultColor && theme) {
defaultColor = theme.semanticColors.primaryButtonBackground;
}
theme: theme,
beaconColorOne: beaconColorOne,
beaconColorTwo: beaconColorTwo,
isCollapsed: isCollapsed,
isMeasuring: isMeasuring,
color: defaultColor,
transformOrigin: transformOrigin,
entityHostHeight: entityInnerHostRect.height === undefined ? undefined :
entityInnerHostRect.height + "px",
entityHostWidth: entityInnerHostRect.width === undefined ? undefined :
entityInnerHostRect.width + "px",
width: Coachmark_styles_1.COACHMARK_WIDTH + "px",
height: Coachmark_styles_1.COACHMARK_HEIGHT + "px",
delayBeforeCoachmarkAnimation: delayBeforeCoachmarkAnimation + "ms",
});
var finalHeight = isCollapsed ? Coachmark_styles_1.COACHMARK_HEIGHT :
entityInnerHostRect.height;
return (React.createElement(index_1.PositioningContainer,
tslib_1.__assign({ target: target, offsetFromTarget: Beak_1.BEAK_HEIGHT,
finalHeight: finalHeight, ref: forwardedRef, onPositioned: onPositioned, bounds:
getBounds(props) }, positioningContainerProps),
React.createElement("div", { className: classNames.root },
ariaAlertText && (React.createElement("div", { className:
classNames.ariaContainer, role: "alert", "aria-hidden": !isCollapsed },
alertText)),
React.createElement("div", { className: classNames.pulsingBeacon }),
classNames.translateAnimationContainer, ref: translateAnimationContainer },
classNames.scaleAnimationLayer },
classNames.rotateAnimationLayer },
(isCollapsed || persistentBeak) &&
React.createElement(Beak_1.Beak, tslib_1.__assign({}, beakPositioningProps,
{ color: defaultColor })),
classNames.entityHost, ref: entityHost, tabIndex: -1, "data-is-focusable": true,
role: "dialog", "aria-labelledby": ariaLabelledBy, "aria-describedby":
ariaDescribedBy },
isCollapsed && [
ariaLabelledBy && (React.createElement("p", { id:
ariaLabelledBy, key: 0, className: classNames.ariaContainer },
ariaLabelledByText)),
ariaDescribedBy && (React.createElement("p", { id:
ariaDescribedBy, key: 1, className: classNames.ariaContainer },
ariaDescribedByText)),
],
{ isClickableOutsideFocusTrap: true, forceFocusInsideTrap: false },
classNames.entityInnerHost, ref: entityInnerHostElementRef },
classNames.childrenContainer, "aria-hidden": isCollapsed }, children))))))))));
});
exports.CoachmarkBase.displayName = COMPONENT_NAME;
function getBounds(_a) {
var isPositionForced = _a.isPositionForced, positioningContainerProps =
_a.positioningContainerProps;
if (isPositionForced) {
// If directionalHint direction is the top or bottom auto edge, then we
want to set the left/right bounds
// to the window x-axis to have auto positioning work correctly.
if (positioningContainerProps &&
(positioningContainerProps.directionalHint ===
DirectionalHint_1.DirectionalHint.topAutoEdge ||
positioningContainerProps.directionalHint ===
DirectionalHint_1.DirectionalHint.bottomAutoEdge)) {
return {
left: 0,
top: -Infinity,
bottom: Infinity,
right: window.innerWidth,
width: window.innerWidth,
height: Infinity,
};
}
else {
return {
left: -Infinity,
top: -Infinity,
bottom: Infinity,
right: Infinity,
width: Infinity,
height: Infinity,
};
}
}
else {
return undefined;
}
}
function isInsideElement(targetElementRect, mouseX, mouseY, mouseProximityOffset) {
if (mouseProximityOffset === void 0) { mouseProximityOffset = 0; }
return (mouseX > targetElementRect.left - mouseProximityOffset &&
mouseX < targetElementRect.left + targetElementRect.width +
mouseProximityOffset &&
mouseY > targetElementRect.top - mouseProximityOffset &&
mouseY < targetElementRect.top + targetElementRect.height +
mouseProximityOffset);
}
//# sourceMappingURL=Coachmark.base.js.map
/***/ }),
/***/ 75358:
"use strict";

exports.Coachmark = void 0;
var Coachmark_styles_1 = __webpack_require__(41454);
var Coachmark_base_1 = __webpack_require__(44320);
exports.Coachmark = Utilities_1.styled(Coachmark_base_1.CoachmarkBase,
Coachmark_styles_1.getStyles, undefined, {
scope: 'Coachmark',
});
//# sourceMappingURL=Coachmark.js.map
/***/ }),
/***/ 41454:
"use strict";

exports.getStyles = exports.rotateOne = exports.scaleOne = exports.translateOne =
exports.COACHMARK_HEIGHT = exports.COACHMARK_WIDTH = void 0;
exports.COACHMARK_WIDTH = 32;
exports.COACHMARK_HEIGHT = 32;
exports.translateOne = Utilities_1.memoizeFunction(function () {
'0%': {
transform: 'translate(0, 0)',
animationTimingFunction: 'linear',
},
'78.57%': {
animationTimingFunction: 'cubic-bezier(0.62, 0, 0.56, 1)',
},
'82.14%': {
transform: 'translate(0, -5px)',
animationTimingFunction: 'cubic-bezier(0.58, 0, 0, 1)',
},
'84.88%': {
transform: 'translate(0, 9px)',
animationTimingFunction: 'cubic-bezier(1, 0, 0.56, 1)',
},
'88.1%': {
transform: 'translate(0, -2px)',
},
'90.12%': {
},
'100%': {
},
});
});
exports.scaleOne = Utilities_1.memoizeFunction(function () {
'0%': {
transform: ' scale(0)',
},
'14.29%': {
transform: 'scale(0)',
animationTimingFunction: 'cubic-bezier(0.84, 0, 0.52, 0.99)',
},
'16.67%': {
transform: 'scale(1.15)',
animationTimingFunction: 'cubic-bezier(0.48, -0.01, 0.52, 1.01)',
},
'19.05%': {
animationTimingFunction: 'cubic-bezier(0.48, 0.02, 0.52, 0.98)',
},
'21.43%': {
},
'42.86%': {
},
'45.71%': {
},
'50%': {
},
'90.12%': {
},
'92.98%': {
},
'97.26%': {
},
'100%': {
},
});
});
exports.rotateOne = Utilities_1.memoizeFunction(function () {
'0%': {
},
'83.33%': {
transform: ' rotate(0deg)',
},
'83.93%': {
},
'84.52%': {
transform: 'rotate(-15deg)',
},
'85.12%': {
},
'85.71%': {
},
'86.31%': {
},
'100%': {
},
});
});
var _a;
var theme = props.theme, className = props.className, color = props.color,
beaconColorOne = props.beaconColorOne, beaconColorTwo = props.beaconColorTwo,
delayBeforeCoachmarkAnimation = props.delayBeforeCoachmarkAnimation, isCollapsed =
props.isCollapsed, isMeasuring = props.isMeasuring, entityHostHeight =
props.entityHostHeight, entityHostWidth = props.entityHostWidth, transformOrigin =
props.transformOrigin;
if (!theme) {
throw new Error('theme is undefined or null in base Dropdown getStyles
function.');
}
var animationInnerDimension = '35px';
var animationOuterDimension = '150px';
var animationBorderWidth = '10px';
var ContinuousPulse =
Styling_1.PulsingBeaconAnimationStyles.continuousPulseAnimationDouble(beaconColorOn
e ? beaconColorOne : theme.palette.themePrimary, beaconColorTwo ? beaconColorTwo :
theme.palette.themeTertiary, animationInnerDimension, animationOuterDimension,
animationBorderWidth);
var ContinuousPulseAnimation =
Styling_1.PulsingBeaconAnimationStyles.createDefaultAnimation(ContinuousPulse,
delayBeforeCoachmarkAnimation);
return {
root: [
theme.fonts.medium,
{
},
className,
],
pulsingBeacon: [
{
top: '50%',
left: '50%',
transform: Utilities_1.getRTL(theme) ? 'translate(50%, -50%)' :
'translate(-50%, -50%)',
width: '0px',
height: '0px',
opacity: '0',
},
isCollapsed && ContinuousPulseAnimation,
],
// Translate Animation Layer
translateAnimationContainer: [
{
width: '100%',
height: '100%',
},
isCollapsed && {
animationDuration: '14s',
animationDirection: 'normal',
animationDelay: '0s',
animationFillMode: 'forwards',
animationName: exports.translateOne(),
transition: 'opacity 0.5s ease-in-out',
},
!isCollapsed && {
opacity: '1',
},
],
// Scale Animation Layer
scaleAnimationLayer: [
{
width: '100%',
height: '100%',
},
isCollapsed && {
animationName: exports.scaleOne(),
},
],
// Rotate Animation Layer
rotateAnimationLayer: [
{
width: '100%',
height: '100%',
},
isCollapsed && {
animationName: exports.rotateOne(),
},
!isCollapsed && {
opacity: '1',
},
],
// Layer Host, defaults to collapsed
entityHost: [
{
outline: 'none',
overflow: 'hidden',
backgroundColor: color,
borderRadius: exports.COACHMARK_WIDTH,
transition: 'border-radius 250ms, width 500ms, height 500ms cubic-
bezier(0.5, 0, 0, 1)',
visibility: 'hidden',
},
outline: "1px solid " + theme.palette.themeTertiary,
},
_a),
},
!isMeasuring &&
isCollapsed && {
width: exports.COACHMARK_WIDTH,
height: exports.COACHMARK_HEIGHT,
},
!isMeasuring && {
visibility: 'visible',
},
!isCollapsed && {
opacity: '1',
width: entityHostWidth,
height: entityHostHeight,
},
],
entityInnerHost: [
{
transition: 'transform 500ms cubic-bezier(0.5, 0, 0, 1)',
transformOrigin: transformOrigin,
},
!isCollapsed && {
width: entityHostWidth,
height: entityHostHeight,
},
!isMeasuring && {
},
],
childrenContainer: [
{
display: !isMeasuring && isCollapsed ? 'none' : 'block',
},
],
ariaContainer: {
position: 'fixed',
opacity: 0,
height: 0,
width: 0,
},
};
}
//# sourceMappingURL=Coachmark.styles.js.map
/***/ }),
/***/ 75505:
"use strict";

//# sourceMappingURL=Coachmark.types.js.map
/***/ }),
/***/ 60219:
"use strict";
var _a;
exports.PositioningContainer = exports.useHeightOffset = void 0;
var PositioningContainer_styles_1 = __webpack_require__(28199);
// Utilites/Helpers
var OFF_SCREEN_STYLE = { opacity: 0 };
// In order for some of the max height logic to work properly we need to set the
border.
// The value is arbitrary.
var BORDER_WIDTH = 1;
var SLIDE_ANIMATIONS = (_a = {},
_a[Positioning_1.RectangleEdge.top] = 'slideUpIn20',
_a[Positioning_1.RectangleEdge.bottom] = 'slideDownIn20',
_a[Positioning_1.RectangleEdge.left] = 'slideLeftIn20',
_a[Positioning_1.RectangleEdge.right] = 'slideRightIn20',
_a);
preventDismissOnScroll: false,
offsetFromTarget: 0,
minPagePadding: 8,
};
function useCachedBounds(props, targetWindow) {
/** The bounds used when determining if and where the PositioningContainer
should be placed. */
var positioningBounds = React.useRef();
var getCachedBounds = function () {
if (!positioningBounds.current) {
var currentBounds = props.bounds;
if (!currentBounds) {
currentBounds = {
top: 0 + props.minPagePadding,
left: 0 + props.minPagePadding,
right: targetWindow.innerWidth - props.minPagePadding,
bottom: targetWindow.innerHeight - props.minPagePadding,
width: targetWindow.innerWidth - props.minPagePadding * 2,
height: targetWindow.innerHeight - props.minPagePadding * 2,
};
}
positioningBounds.current = currentBounds;
}
return positioningBounds.current;
};
return getCachedBounds;
}
function usePositionState(props, positionedHost, contentHost, targetRef,
getCachedBounds) {
/**
* Current set of calculated positions for the outermost parent container.
*/
var _a = React.useState(), positions = _a[0], setPositions = _a[1];
var positionAttempts = React.useRef(0);
var updateAsyncPosition = function () {
async.requestAnimationFrame(function () { return updatePosition(); });
};
var updatePosition = function () {
var offsetFromTarget = props.offsetFromTarget, onPositioned =
props.onPositioned;
var hostElement = positionedHost.current;
var positioningContainerElement = contentHost.current;
if (hostElement && positioningContainerElement) {
var currentProps = tslib_1.__assign({}, props);
currentProps.bounds = getCachedBounds();
currentProps.target = targetRef.current;
var target = currentProps.target;
if (target) {
// Check if the target is an Element or a MouseEvent and the
document contains it
// or don't check anything else if the target is a Point or
Rectangle
if ((!target.getBoundingClientRect && !target.preventDefault) ||
document.body.contains(target)) {
currentProps.gapSpace = offsetFromTarget;
var newPositions = Positioning_1.positionElement(currentProps,
hostElement, positioningContainerElement);
// Set the new position only when the positions are not exists
or one of the new positioningContainer
// positions are different. The position should not change if
the position is within 2 decimal places.
if ((!positions && newPositions) ||
(positions && newPositions && !arePositionsEqual(positions,
newPositions) && positionAttempts.current < 5)) {
// We should not reposition the positioningContainer more
than a few times, if it is then the content is
// likely resizing and we should stop trying to reposition
to prevent a stack overflow.
positionAttempts.current++;
setPositions(newPositions);
onPositioned(newPositions);
}
else {
onPositioned(newPositions);
}
}
else if (positions !== undefined) {
}
}
else if (positions !== undefined) {
}
}
};
React.useEffect(updateAsyncPosition);
return [positions, updateAsyncPosition];
}
function useSetInitialFocus(_a, contentHost, positions) {
var setInitialFocus = _a.setInitialFocus;
var didSetInitialFocus = React.useRef(false);
if (!didSetInitialFocus.current && contentHost.current && setInitialFocus
&& positions) {
didSetInitialFocus.current = true;
Utilities_1.focusFirstChild(contentHost.current);
}
});
}
function useMaxHeight(_a, targetRef, getCachedBounds) {
var directionalHintFixed = _a.directionalHintFixed, offsetFromTarget =
_a.offsetFromTarget, directionalHint = _a.directionalHint, target = _a.target;
/**
* The maximum height the PositioningContainer can grow to
* without going beyond the window or target bounds
*/
var maxHeight = React.useRef();
// If the target element changed, reset the max height. If we are tracking
// target with class name, always reset because we do not know if
// fabric has rendered a new element and disposed the old element.
if (typeof target === 'string') {
maxHeight.current = undefined;
}
maxHeight.current = undefined;
}, [target, offsetFromTarget]);
/**
* Return the maximum height the container can grow to
* without going out of the specified bounds
*/
var getCachedMaxHeight = function () {
if (!maxHeight.current) {
if (directionalHintFixed && targetRef.current) {
var gapSpace = offsetFromTarget ? offsetFromTarget : 0;
maxHeight.current = Positioning_1.getMaxHeight(targetRef.current,
directionalHint, gapSpace, getCachedBounds());
}
else {
maxHeight.current = getCachedBounds().height - BORDER_WIDTH * 2;
}
}
return maxHeight.current;
};
return getCachedMaxHeight;
}
function useAutoDismissEvents(_a, positionedHost, targetWindow, targetRef,
positions, updateAsyncPosition) {
var onDismiss = _a.onDismiss, preventDismissOnScroll =
_a.preventDismissOnScroll;
var onResize = React.useCallback(function (ev) {
if (onDismiss) {
onDismiss(ev);
}
else {
updateAsyncPosition();
}
}, [onDismiss, updateAsyncPosition]);
var dismissOnLostFocus = React.useCallback(function (ev) {
var clickedOutsideCallout = positionedHost.current && !
Utilities_1.elementContains(positionedHost.current, target);
if ((!targetRef.current && clickedOutsideCallout) ||
(ev.target !== targetWindow &&
clickedOutsideCallout &&
(targetRef.current.stopPropagation ||
!targetRef.current ||
(target !== targetRef.current && !
Utilities_1.elementContains(targetRef.current, target))))) {
onResize(ev);
}
}, [onResize, positionedHost, targetRef, targetWindow]);
var dismissOnScroll = React.useCallback(function (ev) {
if (positions && !preventDismissOnScroll) {
dismissOnLostFocus(ev);
}
}, [dismissOnLostFocus, positions, preventDismissOnScroll]);
var events = new Utilities_1.EventGroup({});
// This is added so the positioningContainer will dismiss when the window
is scrolled
// but not when something inside the positioningContainer is scrolled. The
delay seems
// to be required to avoid React firing an async focus event in IE from
// the target changing focus quickly prior to rendering the
positioningContainer.
async.setTimeout(function () {
var _a, _b;
events.on(targetWindow, 'scroll', async.throttle(dismissOnScroll, 10),
true);
events.on(targetWindow, 'resize', async.throttle(onResize, 10), true);
events.on((_a = targetWindow === null || targetWindow === void 0 ? void
0 : targetWindow.document) === null || _a === void 0 ? void 0 : _a.body, 'focus',
dismissOnLostFocus, true);
events.on((_b = targetWindow === null || targetWindow === void 0 ? void
0 : targetWindow.document) === null || _b === void 0 ? void 0 : _b.body, 'click',
dismissOnLostFocus, true);
}, 0);
return function () { return events.dispose(); };
on mount
}, [dismissOnScroll]);
}
function useHeightOffset(_a, contentHost) {
var finalHeight = _a.finalHeight;
/**
* Tracks the current height offset and updates during
* the height animation when props.finalHeight is specified.
*/
var _b = React.useState(0), heightOffset = _b[0], setHeightOffset = _b[1];
var setHeightOffsetTimer = React.useRef(0);
/** Animates the height if finalHeight was given. */
var setHeightOffsetEveryFrame = function () {
if (contentHost && finalHeight) {
setHeightOffsetTimer.current = async.requestAnimationFrame(function ()
{
if (!contentHost.current) {
return;
}
var positioningContainerMainElem = contentHost.current.lastChild;
var cardScrollHeight = positioningContainerMainElem.scrollHeight;
var cardCurrHeight = positioningContainerMainElem.offsetHeight;
var scrollDiff = cardScrollHeight - cardCurrHeight;
setHeightOffset(heightOffset + scrollDiff);
if (positioningContainerMainElem.offsetHeight < finalHeight) {
setHeightOffsetEveryFrame();
}
else {
async.cancelAnimationFrame(setHeightOffsetTimer.current);
}
});
}
};
// eslint-disable-next-line react-hooks/exhaustive-deps -- should only re-run
if finalHeight changes
React.useEffect(setHeightOffsetEveryFrame, [finalHeight]);
return heightOffset;
}
exports.useHeightOffset = useHeightOffset;
exports.PositioningContainer = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
// @TODO rename to reflect the name of this class
var contentHost = React.useRef(null);
/**
* The primary positioned div.
*/
var positionedHost = React.useRef(null);
var rootRef = react_hooks_1.useMergedRefs(forwardedRef, positionedHost);
var _a = react_hooks_1.useTarget(props.target, positionedHost), targetRef =
_a[0], targetWindow = _a[1];
var getCachedBounds = useCachedBounds(props, targetWindow);
var _b = usePositionState(props, positionedHost, contentHost, targetRef,
getCachedBounds), positions = _b[0], updateAsyncPosition = _b[1];
var getCachedMaxHeight = useMaxHeight(props, targetRef, getCachedBounds);
var heightOffset = useHeightOffset(props, contentHost);
useSetInitialFocus(props, contentHost, positions);
useAutoDismissEvents(props, positionedHost, targetWindow, targetRef, positions,
updateAsyncPosition);
// eslint-disable-next-line react-hooks/exhaustive-deps -- should only run on
initial render
React.useEffect(function () { var _a; return (_a = props.onLayerMounted) ===
null || _a === void 0 ? void 0 : _a.call(props); }, []);
// If there is no target window then we are likely in server side rendering and
we should not render anything.
if (!targetWindow) {
return null;
}
var className = props.className, doNotLayer = props.doNotLayer,
positioningContainerWidth = props.positioningContainerWidth,
positioningContainerMaxHeight = props.positioningContainerMaxHeight, children =
props.children;
var styles = PositioningContainer_styles_1.getClassNames();
var directionalClassName = positions && positions.targetEdge ?
Styling_2.AnimationClassNames[SLIDE_ANIMATIONS[positions.targetEdge]] : '';
var getContentMaxHeight = getCachedMaxHeight() + heightOffset;
var contentMaxHeight = positioningContainerMaxHeight &&
positioningContainerMaxHeight > getContentMaxHeight
? getContentMaxHeight
: positioningContainerMaxHeight;
var content = (React.createElement("div", { ref: rootRef, className:
Utilities_1.css('ms-PositioningContainer', styles.container) },
React.createElement("div", { className: Styling_2.mergeStyles('ms-
PositioningContainer-layerHost', styles.root, className, directionalClassName, !!
positioningContainerWidth && { width: positioningContainerWidth }, doNotLayer &&
{ zIndex: Styling_1.ZIndexes.Layer }), style: positions ? positions.elementPosition
: OFF_SCREEN_STYLE,
// Safari and Firefox on Mac OS requires this to back-stop click events
so focus remains in the Callout.
// See
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus
tabIndex: -1, ref: contentHost },
children,
// @TODO apply to the content container
contentMaxHeight)));
return doNotLayer ? content : React.createElement(Layer_1.Layer, null,
content);
});
exports.PositioningContainer.displayName = 'PositioningContainer';
function arePositionsEqual(positions, newPosition) {
return comparePositions(positions.elementPosition,
newPosition.elementPosition);
}
function comparePositions(oldPositions, newPositions) {
for (var key in newPositions) {
if (newPositions.hasOwnProperty(key)) {
var oldPositionEdge = oldPositions[key];
var newPositionEdge = newPositions[key];
if (oldPositionEdge && newPositionEdge) {
if (oldPositionEdge.toFixed(2) !== newPositionEdge.toFixed(2)) {
return false;
}
}
}
}
return true;
}
//# sourceMappingURL=PositioningContainer.js.map
/***/ }),
/***/ 28199:
"use strict";

exports.getClassNames = Utilities_1.memoizeFunction(function () {
var _a;
root: [
{
border: '1px solid ${}',
},
_a),
},
],
container: {
},
main: {
backgroundColor: '#ffffff',
},
overFlowYHidden: {
},
});
});
//# sourceMappingURL=PositioningContainer.styles.js.map
/***/ }),
/***/ 36771:
"use strict";

//# sourceMappingURL=PositioningContainer.types.js.map
/***/ }),
/***/ 35024:
"use strict";

/***/ }),
/***/ 79332:
"use strict";

/***/ }),
/***/ 28248:
"use strict";

exports.ColorPickerBase = void 0;
var TextField_1 = __webpack_require__(76422);
var ColorRectangle_1 = __webpack_require__(12313);
var ColorSlider_1 = __webpack_require__(49631);
var consts_1 = __webpack_require__(79376);
// These imports are separated to help with bundling
var getColorFromString_1 = __webpack_require__(7453);
var getColorFromRGBA_1 = __webpack_require__(46868);
var clamp_1 = __webpack_require__(96033);
var updateA_1 = __webpack_require__(78685);
var updateT_1 = __webpack_require__(51869);
var updateH_1 = __webpack_require__(74634);
var correctRGB_1 = __webpack_require__(20356);
var correctHex_1 = __webpack_require__(93507);
var ColorRectangle_base_1 = __webpack_require__(40609);
var allColorComponents = ['hex', 'r', 'g', 'b', 'a', 't'];
var errorKeys = {
hex: 'hexError',
r: 'redError',
g: 'greenError',
b: 'blueError',
a: 'alphaError',
t: 'transparencyError',
};
/**
* {@docCategory ColorPicker}
*/
var ColorPickerBase = /** @class */ (function (_super) {
tslib_1.__extends(ColorPickerBase, _super);
function ColorPickerBase(props) {
_this._onSVChanged = function (ev, color) {
_this._updateColor(ev, color);
};
_this._onHChanged = function (ev, h) {
_this._updateColor(ev, updateH_1.updateH(_this.state.color, h));
};
/** Callback for when the alpha/transparency slider changes */
_this._onATChanged = function (ev, value) {
var updater = _this.props.alphaType === 'transparency' ?
updateT_1.updateT : updateA_1.updateA;
_this._updateColor(ev, updater(_this.state.color, Math.round(value)));
};
_this._onBlur = function (event) {
var _a;
var _b = _this.state, color = _b.color, editingColor = _b.editingColor;
if (!editingColor) {
return;
}
// If there was an intermediate incorrect value (such as too large or
empty), correct it.
var value = editingColor.value, component = editingColor.component;
var isHex = component === 'hex';
var isAlpha = component === 'a';
var isTransparency = component === 't';
var minLength = isHex ? consts_1.MIN_HEX_LENGTH :
consts_1.MIN_RGBA_LENGTH;
if (value.length >= minLength && (isHex || !isNaN(Number(value)))) {
// Real value. Clamp to appropriate length (hex) or range (rgba).
var newColor = void 0;
if (isHex) {
newColor = getColorFromString_1.getColorFromString('#' +
correctHex_1.correctHex(value));
}
else if (isAlpha || isTransparency) {
var updater = isAlpha ? updateA_1.updateA : updateT_1.updateT;
newColor = updater(color, clamp_1.clamp(Number(value),
consts_1.MAX_COLOR_ALPHA));
}
else {
newColor =
getColorFromRGBA_1.getColorFromRGBA(correctRGB_1.correctRGB(tslib_1.__assign(tslib_
1.__assign({}, color), (_a = {}, _a[component] = Number(value), _a))));
}
// Update state and call onChange
_this._updateColor(event, newColor);
}
else {
// Intermediate value was an empty string or too short (hex only).
// Just clear the intermediate state and revert to the previous
value.
_this.setState({ editingColor: undefined });
}
};
var strings = props.strings; // always defined since it's in defaultProps
Utilities_1.warnDeprecations('ColorPicker', props, {
hexLabel: 'strings.hex',
redLabel: 'strings.red',
greenLabel: 'strings.green',
blueLabel: 'strings.blue',
alphaLabel: 'strings.alpha',
alphaSliderHidden: 'alphaType',
});
if (strings.hue) {
// warnDeprecations can't handle nested deprecated props
Utilities_1.warn("ColorPicker property 'strings.hue' was used but has
been deprecated. Use 'strings.hueAriaLabel' instead.");
}
_this.state = {
color: _getColorFromProps(props) ||
getColorFromString_1.getColorFromString('#ffffff'),
};
_this._textChangeHandlers = {};
for (var _i = 0, allColorComponents_1 = allColorComponents; _i <
allColorComponents_1.length; _i++) {
var component = allColorComponents_1[_i];
_this._textChangeHandlers[component] = _this._onTextChange.bind(_this,
component);
}
var defaultStrings = ColorPickerBase.defaultProps.strings;
_this._textLabels = {
/* eslint-disable deprecation/deprecation */
r: props.redLabel || strings.red || defaultStrings.red,
g: props.greenLabel || strings.green || defaultStrings.green,
b: props.blueLabel || strings.blue || defaultStrings.blue,
a: props.alphaLabel || strings.alpha || defaultStrings.alpha,
hex: props.hexLabel || strings.hex || defaultStrings.hex,
t: strings.transparency || defaultStrings.transparency,
/* eslint-enable deprecation/deprecation */
};
_this._strings = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({},
defaultStrings), {
// these aria labels default to the visible labels
alphaAriaLabel: _this._textLabels.a, transparencyAriaLabel:
_this._textLabels.t }), strings);
return _this;
}
Object.defineProperty(ColorPickerBase.prototype, "color", {
get: function () {
return this.state.color;
},
enumerable: false,
configurable: true
});
ColorPickerBase.prototype.componentDidUpdate = function (prevProps, prevState)
{
// if props changed (as opposed to a state update), update the color
if (prevProps !== this.props) {
var color = _getColorFromProps(this.props);
if (color) {
this._updateColor(undefined, color);
}
}
};
ColorPickerBase.prototype.render = function () {
var _this = this;
var strings = this._strings;
var textLabels = this._textLabels;
var theme = props.theme, className = props.className, styles =
props.styles, alphaType = props.alphaType,
_a = props.alphaSliderHidden,
alphaSliderHidden = _a === void 0 ? alphaType === 'none' : _a, tooltipProps
= props.tooltipProps;
var color = this.state.color;
var useTransparency = alphaType === 'transparency';
var colorComponents = ['hex', 'r', 'g', 'b', useTransparency ? 't' : 'a'];
var atValue = useTransparency ? color.t : color.a;
var atLabel = useTransparency ? textLabels.t : textLabels.a;
theme: theme,
alphaType: alphaType,
});
var selectedColorAriaParts = [textLabels.r, color.r, textLabels.g, color.g,
textLabels.b, color.b];
if (!alphaSliderHidden && typeof atValue === 'number') {
selectedColorAriaParts.push(atLabel, atValue + "%");
}
var ariaLabel = strings.rootAriaLabelFormat.replace('{0}',
selectedColorAriaParts.join(' '));
"group", "aria-label": ariaLabel },
React.createElement("div", { className: classNames.panel },
React.createElement(ColorRectangle_1.ColorRectangle, { color:
color, onChange: this._onSVChanged, ariaLabel: strings.svAriaLabel,
ariaDescription: strings.svAriaDescription, ariaValueFormat:
strings.svAriaValueFormat, className: classNames.colorRectangle }),
React.createElement("div", { className: classNames.flexContainer },
classNames.flexSlider },
React.createElement(ColorSlider_1.ColorSlider, { className:
"is-hue", type: "hue",
ariaLabel: strings.hue || strings.hueAriaLabel, value:
color.h, onChange: this._onHChanged }),
!alphaSliderHidden &&
(React.createElement(ColorSlider_1.ColorSlider, { className: "is-alpha", type:
alphaType, ariaLabel: useTransparency ? strings.transparencyAriaLabel :
strings.alphaAriaLabel, overlayColor: color.hex, value: atValue, onChange:
this._onATChanged }))),
props.showPreview && (React.createElement("div", { className:
classNames.flexPreviewBox },
classNames.colorSquare + ' is-preview', style: {
backgroundColor: color.str,
} })))),
React.createElement("table", { className: classNames.table, role:
"group", cellPadding: "0", cellSpacing: "0" },
React.createElement("thead", null,
React.createElement("tr", { className:
classNames.tableHeader },
React.createElement("td", { className:
classNames.tableHexCell }, textLabels.hex),
React.createElement("td", null, textLabels.r),
React.createElement("td", null, textLabels.g),
React.createElement("td", null, textLabels.b),
!alphaSliderHidden && React.createElement("td",
{ className: classNames.tableAlphaCell }, atLabel))),
React.createElement("tbody", null,
React.createElement("tr", null,
colorComponents.map(function (comp) {
if ((comp === 'a' || comp === 't') &&
alphaSliderHidden) {
return null;
}
var tooltipContent = _this._getTooltipValue(comp);
return (React.createElement("td", { key: comp },
tslib_1.__assign({ content: tooltipContent, directionalHint:
DirectionalHint_1.DirectionalHint.bottomCenter, role: "alert" }, tooltipProps),
React.createElement(TextField_1.TextField,
{ className: classNames.input, onChange: _this._textChangeHandlers[comp], onBlur:
_this._onBlur, value: _this._getDisplayValue(comp), spellCheck: false, ariaLabel:
textLabels[comp], autoComplete: "off", invalid: !!tooltipContent }))));
})))))));
};
ColorPickerBase.prototype._getDisplayValue = function (component) {
var _a = this.state, color = _a.color, editingColor = _a.editingColor;
if (editingColor && editingColor.component === component) {
return editingColor.value;
}
if (component === 'hex') {
return color[component] || '';
}
else if (typeof color[component] === 'number' && !isNaN(color[component]))
{
return String(color[component]);
}
return '';
};
/* Get the error tooltip value for a component if the component is in an
invalid state */
ColorPickerBase.prototype._getTooltipValue = function (component) {
var editingColor = this.state.editingColor;
// if the component does not have an interim value, it is valid
if (!editingColor || editingColor.component !== component) {
return undefined;
}
var value = editingColor.value;
// for hex, do not show a tooltip if the value is between 3-6 characters
if (component === 'hex' && value.length >= consts_1.MIN_HEX_LENGTH &&
value.length <= consts_1.MAX_HEX_LENGTH) {
return undefined;
}
var errorKey = errorKeys[component];
return this._strings[errorKey];
};
ColorPickerBase.prototype._onTextChange = function (component, event, newValue)
{
var _a;
var isHex = component === 'hex';
var isAlpha = component === 'a';
var isTransparency = component === 't';
newValue = (newValue || '').substr(0, isHex ? consts_1.MAX_HEX_LENGTH :
consts_1.MAX_RGBA_LENGTH);
// Ignore what the user typed if it contains invalid characters
var validCharsRegex = isHex ? consts_1.HEX_REGEX : consts_1.RGBA_REGEX;
if (!validCharsRegex.test(newValue)) {
return;
}
// Determine if the entry is valid (different methods for hex, alpha, and
RGB)
var isValid;
if (newValue === '') {
// Empty string is obviously not valid
isValid = false;
}
else if (isHex) {
// Technically hex values of length 3 are also valid, but committing
the value here would
// cause it to be automatically converted to a value of length 6, which
may not be what the
// user wanted if they're not finished typing. (Values of length 3 will
be committed on blur.)
isValid = newValue.length === consts_1.MAX_HEX_LENGTH;
}
else if (isAlpha || isTransparency) {
isValid = Number(newValue) <= consts_1.MAX_COLOR_ALPHA;
}
else {
isValid = Number(newValue) <= consts_1.MAX_COLOR_RGB;
}
if (!isValid) {
// If the new value is an empty string or other invalid value, save
that to display.
// (if the user still hasn't entered anything on blur, the last value
is restored)
this.setState({ editingColor: { component: component, value: newValue }
});
}
else if (String(color[component]) === newValue) {
// If the new value is the same as the current value, mostly ignore it.
// Exception is that if the user was previously editing the value (but
hadn't yet entered
// a new valid value), we should clear the intermediate value.
if (this.state.editingColor) {
this.setState({ editingColor: undefined });
}
}
else {
// Should be a valid color. Update the value.
var newColor = isHex
? getColorFromString_1.getColorFromString('#' + newValue)
: isTransparency
? updateT_1.updateT(color, Number(newValue))
:
getColorFromRGBA_1.getColorFromRGBA(tslib_1.__assign(tslib_1.__assign({}, color),
(_a = {}, _a[component] = Number(newValue), _a)));
this._updateColor(event, newColor);
}
};
/**
* Update the displayed color and call change handlers if appropriate.
* @param ev - Event if call was triggered by an event (undefined if triggered
by props change)
* @param newColor - Updated color
*/
ColorPickerBase.prototype._updateColor = function (ev, newColor) {
if (!newColor) {
return;
}
var _a = this.state, color = _a.color, editingColor = _a.editingColor;
// For black or white, the hue can change without changing the string.
var isDifferentColor = newColor.h !== color.h || newColor.str !==
color.str;
if (isDifferentColor || editingColor) {
// If ev is undefined, it's an update from props (which should be
unconditionally respected
// and not call onChange).
if (ev && this.props.onChange) {
this.props.onChange(ev, newColor);
if (ev.defaultPrevented) {
return;
}
}
this.setState({ color: newColor, editingColor: undefined });
}
};
ColorPickerBase.defaultProps = {
alphaType: 'alpha',
strings: {
rootAriaLabelFormat: 'Color picker, {0} selected.',
hex: 'Hex',
red: 'Red',
green: 'Green',
blue: 'Blue',
alpha: 'Alpha',
transparency: 'Transparency',
hueAriaLabel: 'Hue',
svAriaLabel:
ColorRectangle_base_1.ColorRectangleBase.defaultProps.ariaLabel,
svAriaValueFormat:
ColorRectangle_base_1.ColorRectangleBase.defaultProps.ariaValueFormat,
svAriaDescription:
ColorRectangle_base_1.ColorRectangleBase.defaultProps.ariaDescription,
hexError: 'Hex values must be between 3 and 6 characters long',
alphaError: 'Alpha must be between 0 and 100',
transparencyError: 'Transparency must be between 0 and 100',
redError: 'Red must be between 0 and 255',
greenError: 'Green must be between 0 and 255',
blueError: 'Blue must be between 0 and 255',
},
};
return ColorPickerBase;
exports.ColorPickerBase = ColorPickerBase;
function _getColorFromProps(props) {
var color = props.color;
return typeof color === 'string' ?
getColorFromString_1.getColorFromString(color) : color;
}
//# sourceMappingURL=ColorPicker.base.js.map
/***/ }),
/***/ 73041:
"use strict";

exports.ColorPicker = void 0;
var ColorPicker_base_1 = __webpack_require__(28248);
var ColorPicker_styles_1 = __webpack_require__(3960);
exports.ColorPicker = Utilities_1.styled(ColorPicker_base_1.ColorPickerBase,
ColorPicker_styles_1.getStyles, undefined, { scope: 'ColorPicker' });
//# sourceMappingURL=ColorPicker.js.map
/***/ }),
/***/ 3960:
"use strict";

var className = props.className, theme = props.theme, alphaType =
props.alphaType;
return {
root: [
'ms-ColorPicker',
theme.fonts.medium,
{
maxWidth: 300,
},
className,
],
panel: [
'ms-ColorPicker-panel',
{
padding: '16px',
},
],
table: [
'ms-ColorPicker-table',
{
tableLayout: 'fixed',
width: '100%',
selectors: {
'tbody td:last-of-type .ms-ColorPicker-input': {
paddingRight: 0,
},
},
},
],
tableHeader: [
theme.fonts.small,
{
selectors: {
td: {
paddingBottom: 4,
},
},
},
],
tableHexCell: {
width: '25%',
},
// Account for "Transparency" being a longer word
tableAlphaCell: alphaType === 'transparency' && {
width: '22%',
},
colorSquare: [
'ms-ColorPicker-colorSquare',
{
width: 48,
height: 48,
margin: '0 0 0 8px',
border: '1px solid #c8c6c4',
},
],
flexContainer: {
display: 'flex',
},
flexSlider: {
flexGrow: '1',
},
flexPreviewBox: {
flexGrow: '0',
},
input: [
'ms-ColorPicker-input',
{
width: '100%',
border: 'none',
height: 30,
selectors: {
'&.ms-TextField': {
paddingRight: 4,
},
'& .ms-TextField-field': {
minWidth: 'auto',
padding: 5,
textOverflow: 'clip',
},
},
},
],
};
};
//# sourceMappingURL=ColorPicker.styles.js.map
/***/ }),
/***/ 93498:
"use strict";

//# sourceMappingURL=ColorPicker.types.js.map
/***/ }),
/***/ 40609:
"use strict";

exports._getNewColor = exports.ColorRectangleBase = void 0;
// These imports are separated to help with bundling
var getFullColorString_1 = __webpack_require__(7252);
var updateSV_1 = __webpack_require__(42083);
/**
*/
var ColorRectangleBase = /** @class */ (function (_super) {
tslib_1.__extends(ColorRectangleBase, _super);
function ColorRectangleBase(props) {
_this._disposables = [];
_this._isAdjustingSaturation = true;
_this._descriptionId = Utilities_1.getId('ColorRectangle-description');
var color = _this.state.color;
var s = color.s, v = color.v;
var increment = ev.shiftKey ? 10 : 1;
// Intentionally DO NOT flip the color picker in RTL: its orientation
is not very meaningful,
// and getting all the math and styles flipped correctly is tricky
switch (ev.which) {
case Utilities_1.KeyCodes.up: {
_this._isAdjustingSaturation = false;
v += increment; // V = 100 (lightest) is at the top
break;
}
case Utilities_1.KeyCodes.down: {
_this._isAdjustingSaturation = false;
v -= increment; // V = 0 (darkest) is at the bottom
break;
}
case Utilities_1.KeyCodes.left: {
s -= increment;
break;
}
case Utilities_1.KeyCodes.right: {
s += increment;
break;
}
default:
return;
}
_this._updateColor(ev, updateSV_1.updateSV(color, clamp_1.clamp(s,
consts_1.MAX_COLOR_SATURATION), clamp_1.clamp(v, consts_1.MAX_COLOR_VALUE)));
};
_this._disposables.push(Utilities_1.on(window, 'mousemove',
_this._onMouseMove, true), Utilities_1.on(window, 'mouseup',
_this._disposeListeners, true));
_this._onMouseMove(ev);
};
_this._onMouseMove = function (ev) {
if (!_this._root.current) {
return;
}
// Leaving the following commented code which is sometimes necessary
for debugging:
// If the primary button (1) isn't pressed, the user is no longer
dragging, so turn off
// the event handlers and exit.
// if (!(ev.buttons & 1)) {
// this._disposeListeners();
// return;
// }
var newColor = _getNewColor(ev, _this.state.color,
_this._root.current);
if (newColor) {
_this._updateColor(ev, newColor);
}
};
_this._disposeListeners = function () {
_this._disposables.forEach(function (dispose) { return dispose(); });
};
_this.state = { color: props.color };
return _this;
}
Object.defineProperty(ColorRectangleBase.prototype, "color", {
get: function () {
return this.state.color;
},
enumerable: false,
configurable: true
});
ColorRectangleBase.prototype.componentDidUpdate = function (prevProps,
prevState) {
// if props changed (as opposed to a state update), set the value
// TODO: switch to strict controlled pattern instead
if (prevProps !== this.props && this.props.color) {
this.setState({ color: this.props.color });
}
};
ColorRectangleBase.prototype.componentWillUnmount = function () {
this._disposeListeners();
};
ColorRectangleBase.prototype.render = function () {
var _a = this.props, minSize = _a.minSize, theme = _a.theme, className =
_a.className, styles = _a.styles, ariaValueFormat = _a.ariaValueFormat, ariaLabel =
_a.ariaLabel, ariaDescription = _a.ariaDescription;
theme: theme,
minSize: minSize,
});
var valueText = ariaValueFormat.replace('{0}',
String(color.s)).replace('{1}', String(color.v));
return (React.createElement("div", { ref: this._root, tabIndex: 0,
className: classNames.root, style: { backgroundColor:
getFullColorString_1.getFullColorString(color) }, onMouseDown: this._onMouseDown,
onKeyDown: this._onKeyDown, role: "slider", "aria-valuetext": valueText, "aria-
valuenow": this._isAdjustingSaturation ? color.s : color.v, "aria-valuemin": 0,
"aria-valuemax": consts_1.MAX_COLOR_VALUE, "aria-label": ariaLabel, "aria-
describedby": this._descriptionId, "data-is-focusable": true },
React.createElement("div", { className: classNames.description, id:
this._descriptionId }, ariaDescription),
React.createElement("div", { className: classNames.light }),
React.createElement("div", { className: classNames.dark }),
React.createElement("div", { className: classNames.thumb, style:
{ left: color.s + '%', top: consts_1.MAX_COLOR_VALUE - color.v + '%',
backgroundColor: color.str } })));
};
ColorRectangleBase.prototype._updateColor = function (ev, color) {
var onChange = this.props.onChange;
var oldColor = this.state.color;
if (color.s === oldColor.s && color.v === oldColor.v) {
return; // no change
}
if (onChange) {
onChange(ev, color);
}
this.setState({ color: color });
}
};
ColorRectangleBase.defaultProps = {
minSize: 220,
ariaLabel: 'Saturation and brightness',
ariaValueFormat: 'Saturation {0} brightness {1}',
ariaDescription: 'Use left and right arrow keys to set saturation. Use up
and down arrow keys to set brightness.',
};
return ColorRectangleBase;
exports.ColorRectangleBase = ColorRectangleBase;
/**
* Exported for testing only.
* @internal
*/
function _getNewColor(ev, prevColor, root) {
var rectSize = root.getBoundingClientRect();
var sPercentage = (ev.clientX - rectSize.left) / rectSize.width;
var vPercentage = (ev.clientY - rectSize.top) / rectSize.height;
return updateSV_1.updateSV(prevColor, clamp_1.clamp(Math.round(sPercentage *
consts_1.MAX_COLOR_SATURATION), consts_1.MAX_COLOR_SATURATION),
clamp_1.clamp(Math.round(consts_1.MAX_COLOR_VALUE - vPercentage *
consts_1.MAX_COLOR_VALUE), consts_1.MAX_COLOR_VALUE));
}
exports._getNewColor = _getNewColor;
//# sourceMappingURL=ColorRectangle.base.js.map
/***/ }),
/***/ 12313:
"use strict";
exports.ColorRectangle = void 0;
var ColorRectangle_base_1 = __webpack_require__(40609);
var ColorRectangle_styles_1 = __webpack_require__(49263);
exports.ColorRectangle =
Utilities_1.styled(ColorRectangle_base_1.ColorRectangleBase,
ColorRectangle_styles_1.getStyles, undefined, { scope: 'ColorRectangle' });
//# sourceMappingURL=ColorRectangle.js.map
/***/ }),
/***/ 49263:
"use strict";

var _a, _b;
var className = props.className, theme = props.theme, minSize = props.minSize;
var palette = theme.palette, effects = theme.effects;
return {
root: [
'ms-ColorPicker-colorRect',
{
marginBottom: 8,
border: "1px solid " + palette.neutralLighter,
minWidth: minSize,
minHeight: minSize,
outline: 'none',
_a[Styling_1.HighContrastSelector] = tslib_1.__assign({},
_a["." + Utilities_1.IsFocusVisibleClassName + " &:focus"] =
(_b = {
outline: "1px solid " + palette.neutralSecondary
},
_b["" + Styling_1.HighContrastSelector] = {
outline: '2px solid CanvasText',
},
_b),
_a),
},
className,
],
light: [
'ms-ColorPicker-light',
{
left: 0,
right: 0,
top: 0,
bottom: 0,
// Intentionally DO NOT flip the color picker in RTL: its
orientation is not very meaningful,
background: 'linear-gradient(to right, white 0%, transparent
100%) /*@noflip*/',
},
],
dark: [
'ms-ColorPicker-dark',
{
left: 0,
right: 0,
top: 0,
bottom: 0,
background: 'linear-gradient(to bottom, transparent 0, #000 100%)',
},
],
thumb: [
'ms-ColorPicker-thumb',
{
width: 20,
height: 20,
background: 'white',
selectors: {
':before': {
left: 0,
right: 0,
top: 0,
bottom: 0,
border: "2px solid " + palette.white,
content: '""',
},
},
},
],
description: style_utilities_1.hiddenContentStyle,
};
};
//# sourceMappingURL=ColorRectangle.styles.js.map
/***/ }),
/***/ 75563:
"use strict";
//# sourceMappingURL=ColorRectangle.types.js.map
/***/ }),
/***/ 92010:
"use strict";

exports.ColorSliderBase = void 0;
/**
*/
var ColorSliderBase = /** @class */ (function (_super) {
tslib_1.__extends(ColorSliderBase, _super);
function ColorSliderBase(props) {
var currentValue = _this.value;
var maxValue = _this._maxValue;
var increment = ev.shiftKey ? 10 : 1;
// Intentionally DO NOT flip the color picker in RTL: its orientation
is not very meaningful,
switch (ev.which) {
currentValue -= increment;
break;
}
currentValue += increment;
break;
}
case Utilities_1.KeyCodes.home: {
currentValue = 0;
break;
}
case Utilities_1.KeyCodes.end: {
currentValue = maxValue;
break;
}
default: {
return;
}
}
_this._updateValue(ev, clamp_1.clamp(currentValue, maxValue));
};
var win = Utilities_1.getWindow(_this);
if (win) {
_this._disposables.push(Utilities_1.on(win, 'mousemove',
_this._onMouseMove, true), Utilities_1.on(win, 'mouseup', _this._disposeListeners,
true));
}
};
_this._onMouseMove = function (ev) {
if (!_this._root.current) {
return;
}
var maxValue = _this._maxValue;
var rectSize = _this._root.current.getBoundingClientRect();
var currentPercentage = (ev.clientX - rectSize.left) / rectSize.width;
var newValue = clamp_1.clamp(Math.round(currentPercentage * maxValue),
maxValue);
_this._updateValue(ev, newValue);
};
_this._disposeListeners = function () {
_this._disposables.forEach(function (dispose) { return dispose(); });
};
Utilities_1.warnDeprecations('ColorSlider', props, {
thumbColor: 'styles.sliderThumb',
overlayStyle: 'overlayColor',
isAlpha: 'type',
maxValue: 'type',
minValue: 'type',
});
if (_this._type !== 'hue' && !(props.overlayColor || props.overlayStyle)) {
Utilities_1.warn("ColorSlider: 'overlayColor' is required when 'type'
is \"alpha\" or \"transparency\"");
}
_this.state = {
currentValue: props.value || 0,
};
return _this;
}
Object.defineProperty(ColorSliderBase.prototype, "value", {
get: function () {
return this.state.currentValue;
},
enumerable: false,
configurable: true
});
ColorSliderBase.prototype.componentDidUpdate = function (prevProps, prevState)
{
// if props changed (as opposed to a state update), set the value
// TODO: switch to strict controlled pattern instead
if (prevProps !== this.props && this.props.value !== undefined) {
this.setState({ currentValue: this.props.value });
}
};
ColorSliderBase.prototype.componentWillUnmount = function () {
this._disposeListeners();
};
ColorSliderBase.prototype.render = function () {
var type = this._type;
var maxValue = this._maxValue;
var _a = this.props,
overlayStyle = _a.overlayStyle, overlayColor = _a.overlayColor, theme =
_a.theme, className = _a.className, styles = _a.styles, _b = _a.ariaLabel,
ariaLabel = _b === void 0 ? type : _b;
var currentValue = this.value;
theme: theme,
type: type,
});
var currentPercentage = (100 * currentValue) / maxValue;
return (React.createElement("div", { ref: this._root, className:
classNames.root, tabIndex: 0, onKeyDown: this._onKeyDown, onMouseDown:
this._onMouseDown, role: "slider", "aria-valuenow": currentValue, "aria-valuetext":
String(currentValue), "aria-valuemin": 0, "aria-valuemax": maxValue, "aria-label":
ariaLabel, "data-is-focusable": true },
!!(overlayColor || overlayStyle) && (React.createElement("div",
{ className: classNames.sliderOverlay,
// this isn't included in getStyles because it may change
frequently
style: overlayColor
? {
background: type === 'transparency'
? "linear-gradient(to right, #" + overlayColor + ",
transparent)"
: "linear-gradient(to right, transparent, #" +
overlayColor + ")",
}
: overlayStyle })),
React.createElement("div", { className: classNames.sliderThumb, style:
{ left: currentPercentage + '%' } })));
};
Object.defineProperty(ColorSliderBase.prototype, "_type", {
get: function () {
var _a = this.props, isAlpha = _a.isAlpha, _b = _a.type, type = _b ===
void 0 ? isAlpha ? 'alpha' : 'hue' : _b;
return type;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ColorSliderBase.prototype, "_maxValue", {
get: function () {
return this._type === 'hue' ? consts_1.MAX_COLOR_HUE :
consts_1.MAX_COLOR_ALPHA;
},
enumerable: false,
configurable: true
});
ColorSliderBase.prototype._updateValue = function (ev, newValue) {
if (newValue === this.value) {
return;
}
var onChange = this.props.onChange;
if (onChange) {
onChange(ev, newValue);
}
this.setState({
currentValue: newValue,
});
}
};
ColorSliderBase.defaultProps = {
value: 0,
};
return ColorSliderBase;
exports.ColorSliderBase = ColorSliderBase;
//# sourceMappingURL=ColorSlider.base.js.map
/***/ }),
/***/ 49631:
"use strict";

exports.ColorSlider = void 0;
var ColorSlider_base_1 = __webpack_require__(92010);
var ColorSlider_styles_1 = __webpack_require__(22346);
exports.ColorSlider = Utilities_1.styled(ColorSlider_base_1.ColorSliderBase,
ColorSlider_styles_1.getStyles, undefined, { scope: 'ColorSlider' });
//# sourceMappingURL=ColorSlider.js.map
/***/ }),
/***/ 22346:
"use strict";

var hueStyle = {
background: "linear-gradient(" + [
'to left',
'red 0',
'#f09 10%',
'#cd00ff 20%',
'#3200ff 30%',
'#06f 40%',
'#00fffd 50%',
'#0f6 60%',
'#35ff00 70%',
'#cdff00 80%',
'#f90 90%',
'red 100%',
].join(',') + ")",
};
var alphaStyle = {
backgroundImage:
'url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAJUlEQVQY
V2N89erVfwY0ICYmxoguxjgUFKI7GsTH5m4M3w1ChQC1/Ca8i2n1WgAAAABJRU5ErkJggg==)',
};
var _a, _b;
var theme = props.theme, className = props.className, _c = props.type, type =
_c === void 0 ? 'hue' : _c, _d = props.isAlpha, useAlphaBackground = _d === void
0 ? type !== 'hue' : _d;
var palette = theme.palette, effects = theme.effects;
return {
root: [
'ms-ColorPicker-slider',
{
height: 20,
marginBottom: 8,
border: "1px solid " + palette.neutralLight,
outline: 'none',
(_b = {
outline: "1px solid " + palette.neutralSecondary
},
_b["" + Styling_1.HighContrastSelector] = {
outline: '2px solid CanvasText',
},
_b),
_a),
},
useAlphaBackground ? alphaStyle : hueStyle,
className,
],
sliderOverlay: [
'ms-ColorPicker-sliderOverlay',
{
content: '',
left: 0,
right: 0,
top: 0,
bottom: 0,
},
],
sliderThumb: [
'ms-ColorPicker-thumb',
'is-slider',
{
width: 20,
height: 20,
background: 'white',
top: '50%',
},
],
};
};
//# sourceMappingURL=ColorSlider.styles.js.map
/***/ }),
/***/ 25190:
"use strict";

//# sourceMappingURL=ColorSlider.types.js.map
/***/ }),
/***/ 60093:
"use strict";

/***/ }),
/***/ 87687:
"use strict";

exports.getComboBoxOptionClassNames = exports.getClassNames = void 0;
exports.getClassNames = Utilities_1.memoizeFunction(function (styles, className,
isOpen, disabled, required, focused, allowFreeForm, hasErrorMessage) {
return {
container: Styling_1.mergeStyles('ms-ComboBox-container', className,
styles.container),
label: Styling_1.mergeStyles(styles.label, disabled &&
styles.labelDisabled),
root: Styling_1.mergeStyles('ms-ComboBox', hasErrorMessage ?
styles.rootError : isOpen && 'is-open', required && 'is-required', styles.root, !
allowFreeForm && styles.rootDisallowFreeForm, hasErrorMessage && !focused ?
styles.rootError : !disabled && focused && styles.rootFocused, !disabled && {
selectors: {
':hover': hasErrorMessage ? styles.rootError : !isOpen && !focused
&& styles.rootHovered,
':active': hasErrorMessage ? styles.rootError : styles.rootPressed,
':focus': hasErrorMessage ? styles.rootError : styles.rootFocused,
},
}, disabled && ['is-disabled', styles.rootDisabled]),
input: Styling_1.mergeStyles('ms-ComboBox-Input', styles.input, disabled &&
styles.inputDisabled),
errorMessage: Styling_1.mergeStyles(styles.errorMessage),
callout: Styling_1.mergeStyles('ms-ComboBox-callout', styles.callout),
optionsContainerWrapper: Styling_1.mergeStyles('ms-ComboBox-
optionsContainerWrapper', styles.optionsContainerWrapper),
optionsContainer: Styling_1.mergeStyles('ms-ComboBox-optionsContainer',
styles.optionsContainer),
header: Styling_1.mergeStyles('ms-ComboBox-header', styles.header),
divider: Styling_1.mergeStyles('ms-ComboBox-divider', styles.divider),
screenReaderText: Styling_1.mergeStyles(styles.screenReaderText),
};
});
exports.getComboBoxOptionClassNames = Utilities_1.memoizeFunction(function (styles)
{
return {
optionText: Styling_1.mergeStyles('ms-ComboBox-optionText',
styles.optionText),
root: Styling_1.mergeStyles('ms-ComboBox-option', styles.root, {
selectors: {
':hover': styles.rootHovered,
':focus': styles.rootFocused,
':active': styles.rootPressed,
},
}),
optionTextWrapper: Styling_1.mergeStyles(styles.optionTextWrapper),
};
});
//# sourceMappingURL=ComboBox.classNames.js.map
/***/ }),
/***/ 90912:
"use strict";

exports.ComboBox = void 0;
var Autofill_1 = __webpack_require__(98515);
var Checkbox_1 = __webpack_require__(78754);
var ComboBox_styles_1 = __webpack_require__(11092);
var ComboBox_classNames_1 = __webpack_require__(87687);
var SelectableOption_1 = __webpack_require__(51087);
var SearchDirection;
(function (SearchDirection) {
SearchDirection[SearchDirection["backward"] = -1] = "backward";
SearchDirection[SearchDirection["none"] = 0] = "none";
SearchDirection[SearchDirection["forward"] = 1] = "forward";
})(SearchDirection || (SearchDirection = {}));
var HoverStatus;
(function (HoverStatus) {
/** Used when the user was hovering and has since moused out of the menu items
*/
HoverStatus[HoverStatus["clearAll"] = -2] = "clearAll";
/** Default "normal" state, when no hover has happened or a hover is in
progress */
HoverStatus[HoverStatus["default"] = -1] = "default";
})(HoverStatus || (HoverStatus = {}));
var ScrollIdleDelay = 250; /* ms */
/**
* This is used to clear any pending autocomplete text (used when autocomplete is
true and
* allowFreeform is false)
*/
var ReadOnlyPendingAutoCompleteTimeout = 1000; /* ms */
/**
* Internal component that is used to wrap all ComboBox options.
* This is used to customize when we want to re-render components,
* so we don't re-render every option every time render is executed.
*/
var ComboBoxOptionWrapper = React.memo(function (_a) {
var render = _a.render;
return render();
}, function (_a, _b) {
var oldRender = _a.render, oldProps = tslib_1.__rest(_a, ["render"]);
var newRender = _b.render, newProps = tslib_1.__rest(_b, ["render"]);
// The render function will always be different, so we ignore that prop
return Utilities_1.shallowCompare(oldProps, newProps);
});
var COMPONENT_NAME = 'ComboBox';
options: [],
allowFreeform: false,
autoComplete: 'on',
buttonIconProps: { iconName: 'ChevronDown' },
};
function useOptionsState(_a) {
var options = _a.options, defaultSelectedKey = _a.defaultSelectedKey,
selectedKey = _a.selectedKey;
/** The currently selected indices */
var _b = React.useState(function () {
return getSelectedIndices(options,
buildDefaultSelectedKeys(defaultSelectedKey, selectedKey));
}), selectedIndices = _b[0], setSelectedIndices = _b[1];
/** The options currently available for the callout */
var _c = React.useState(options), currentOptions = _c[0], setCurrentOptions =
_c[1];
/** This value is used for the autocomplete hint value */
var _d = React.useState(), suggestedDisplayValue = _d[0],
setSuggestedDisplayValue = _d[1];
if (selectedKey !== undefined) {
var selectedKeys = buildSelectedKeys(selectedKey);
var indices = getSelectedIndices(options, selectedKeys);
setSelectedIndices(indices);
}
setCurrentOptions(options);
}, [options, selectedKey]);
if (selectedKey === null) {
setSuggestedDisplayValue(undefined);
}
}, [selectedKey]);
return [
selectedIndices,
setSelectedIndices,
currentOptions,
setCurrentOptions,
suggestedDisplayValue,
setSuggestedDisplayValue,
];
}
exports.ComboBox = React.forwardRef(function (propsWithoutDefaults, forwardedRef) {
var _a = Utilities_1.getPropsWithDefaults(DEFAULT_PROPS, propsWithoutDefaults),
ref = _a.ref, props = tslib_1.__rest(_a, ["ref"]);
var mergedRootRef = react_hooks_1.useMergedRefs(rootRef, forwardedRef);
var _b = useOptionsState(props), selectedIndices = _b[0], setSelectedIndices =
_b[1], currentOptions = _b[2], setCurrentOptions = _b[3], suggestedDisplayValue =
_b[4], setSuggestedDisplayValue = _b[5];
return (React.createElement(ComboBoxInternal, tslib_1.__assign({}, props,
{ hoisted: {
mergedRootRef: mergedRootRef,
rootRef: rootRef,
selectedIndices: selectedIndices,
setSelectedIndices: setSelectedIndices,
currentOptions: currentOptions,
setCurrentOptions: setCurrentOptions,
suggestedDisplayValue: suggestedDisplayValue,
setSuggestedDisplayValue: setSuggestedDisplayValue,
} })));
});
exports.ComboBox.displayName = COMPONENT_NAME;
/**
* Depth-first search to find the first descendant element where the match function
returns true.
* @param match - the function that determines if the element is a match
* @returns the matched element or null no match was found
*/
function findFirstDescendant(element, match) {
var children = utilities_1.getChildren(element);
// For loop is used because forEach cannot be stopped.
for (var index = 0; index < children.length; index++) {
var child = children[index];
if (match(child)) {
return child;
}
var candidate = findFirstDescendant(child, match);
if (candidate) {
return candidate;
}
}
return null;
}
var ComboBoxInternal = /** @class */ (function (_super) {
tslib_1.__extends(ComboBoxInternal, _super);
function ComboBoxInternal(props) {
/** The input aspect of the combo box */
_this._autofill = React.createRef();
/** The wrapping div of the input and button */
_this._comboBoxWrapper = React.createRef();
/** The callout element */
_this._comboBoxMenu = React.createRef();
/** The menu item element that is currently selected */
_this._selectedElement = React.createRef();
/**
* {@inheritdoc}
*/
_this.focus = function (shouldOpenOnFocus, useFocusAsync) {
return;
}
if (_this._autofill.current) {
if (useFocusAsync) {
Utilities_1.focusAsync(_this._autofill.current);
}
else {
_this._autofill.current.focus();
}
if (shouldOpenOnFocus) {
_this.setState({
isOpen: true,
});
}
}
// Programmatically setting focus means that there is nothing else that
needs to be done
// Focus is now contained
if (!_this._hasFocus()) {
_this.setState({ focusState: 'focused' });
}
};
/**
* Close menu callout if it is open
*/
_this.dismissMenu = function () {
var isOpen = _this.state.isOpen;
isOpen && _this.setState({ isOpen: false });
};
/**
* componentWillReceiveProps handler for the auto fill component
* Checks/updates the input value to set, if needed
* @param defaultVisibleValue - the defaultVisibleValue that got passed
* in to the auto fill's componentWillReceiveProps
* @returns - the updated value to set, if needed
*/
_this._onUpdateValueInAutofillWillReceiveProps = function () {
var comboBox = _this._autofill.current;
if (!comboBox) {
return null;
}
if (comboBox.value === null || comboBox.value === undefined) {
return null;
}
var visibleValue = normalizeToString(_this._currentVisibleValue);
if (comboBox.value !== visibleValue) {
return visibleValue;
}
return comboBox.value;
};
_this._renderComboBoxWrapper = function (multiselectAccessibleText,
errorMessageId) {
var _a = _this.props, label = _a.label, disabled = _a.disabled,
ariaLabel = _a.ariaLabel, _b = _a.ariaDescribedBy, ariaDescribedBy = _b === void
0 ? _this.props['aria-describedby'] : _b, required = _a.required, errorMessage =
_a.errorMessage, buttonIconProps = _a.buttonIconProps, _c = _a.isButtonAriaHidden,
isButtonAriaHidden = _c === void 0 ? true : _c, title = _a.title, placeholderProp =
_a.placeholder, tabIndex = _a.tabIndex, autofill = _a.autofill, iconButtonProps =
_a.iconButtonProps, suggestedDisplayValue = _a.hoisted.suggestedDisplayValue;
// If the combo box has focus, is multiselect, and has a display
string, then use that placeholder
// so that the selected items don't appear to vanish. This is not ideal
but it's the only reasonable way
// to correct the behavior where the input is cleared so the user can
type. If a full refactor is done, then this
// should be removed and the multiselect combo box should behave like a
picker.
var placeholder = _this._hasFocus() && _this.props.multiSelect &&
multiselectAccessibleText
? multiselectAccessibleText
: placeholderProp;
var labelledBy = [_this.props['aria-labelledby'], label && _this._id +
'-label'].join(' ').trim();
return (React.createElement("div", { "data-ktp-target": true, ref:
_this._comboBoxWrapper, id: _this._id + 'wrapper', className:
_this._classNames.root, "aria-owns": isOpen ? _this._id + '-list' : undefined },
React.createElement(Autofill_1.Autofill, tslib_1.__assign({ "data-
ktp-execute-target": true, "data-is-interactable": !disabled, componentRef:
_this._autofill, id: _this._id + '-input', className: _this._classNames.input,
type: "text", onFocus: _this._onFocus, onBlur: _this._onBlur, onKeyDown:
_this._onInputKeyDown, onKeyUp: _this._onInputKeyUp, onClick:
_this._onAutofillClick, onTouchStart: _this._onTouchStart, onInputValueChange:
_this._onInputChange, "aria-expanded": isOpen, "aria-autocomplete":
_this._getAriaAutoCompleteValue(), role: "combobox", readOnly: disabled, "aria-
labelledby": labelledBy ? labelledBy : undefined, "aria-label": ariaLabel && !label
? ariaLabel : undefined, "aria-describedby": errorMessage !== undefined ?
Utilities_1.mergeAriaAttributeValues(ariaDescribedBy, errorMessageId) :
ariaDescribedBy, "aria-activedescendant": _this._getAriaActiveDescendantValue(),
"aria-required": required, "aria-disabled": disabled, "aria-controls": isOpen ?
_this._id + '-list' : undefined, spellCheck: false, defaultVisibleValue:
_this._currentVisibleValue, suggestedDisplayValue: suggestedDisplayValue,
updateValueInWillReceiveProps: _this._onUpdateValueInAutofillWillReceiveProps,
shouldSelectFullInputValueInComponentDidUpdate:
_this._onShouldSelectFullInputValueInAutofillComponentDidUpdate, title: title,
preventValueSelection: !_this._hasFocus(), placeholder: placeholder, tabIndex:
disabled ? -1 : tabIndex }, autofill)),
React.createElement(Button_1.IconButton,
tslib_1.__assign({ className: 'ms-ComboBox-CaretDown-button', styles:
_this._getCaretButtonStyles(), role: "presentation", "aria-hidden":
isButtonAriaHidden, "data-is-focusable": false, tabIndex: -1, onClick:
_this._onComboBoxClick, onBlur: _this._onBlur, iconProps: buttonIconProps,
disabled: disabled, checked: isOpen }, iconButtonProps))));
};
/**
* componentDidUpdate handler for the auto fill component
*
* @param defaultVisibleValue - the current defaultVisibleValue in the auto
fill's componentDidUpdate
* @param suggestedDisplayValue - the current suggestedDisplayValue in the
auto fill's componentDidUpdate
* @returns - should the full value of the input be selected?
* True if the defaultVisibleValue equals the suggestedDisplayValue, false
otherwise
*/
_this._onShouldSelectFullInputValueInAutofillComponentDidUpdate = function
() {
return _this._currentVisibleValue ===
_this.props.hoisted.suggestedDisplayValue;
};
/**
* Get the correct value to pass to the input
* to show to the user based off of the current props and state
* @returns the value to pass to the input
*/
_this._getVisibleValue = function () {
var _a = _this.props, text = _a.text, allowFreeform = _a.allowFreeform,
autoComplete = _a.autoComplete, _b = _a.hoisted, suggestedDisplayValue =
_b.suggestedDisplayValue, selectedIndices = _b.selectedIndices, currentOptions =
_b.currentOptions;
var _c = _this.state, currentPendingValueValidIndex =
_c.currentPendingValueValidIndex, currentPendingValue = _c.currentPendingValue,
isOpen = _c.isOpen;
var currentPendingIndexValid = indexWithinBounds(currentOptions,
currentPendingValueValidIndex);
// If the user passed is a value prop, use that
// unless we are open and have a valid current pending index
if (!(isOpen && currentPendingIndexValid) &&
text &&
(currentPendingValue === null || currentPendingValue ===
undefined)) {
return text;
}
if (_this.props.multiSelect) {
// Multi-select
if (_this._hasFocus()) {
var index = -1;
if (autoComplete === 'on' && currentPendingIndexValid) {
index = currentPendingValueValidIndex;
}
return _this._getPendingString(currentPendingValue,
currentOptions, index);
}
else {
return _this._getMultiselectDisplayString(selectedIndices,
currentOptions, suggestedDisplayValue);
}
}
else {
// Single-select
var index = _this._getFirstSelectedIndex();
if (allowFreeform) {
// If we are allowing freeform and autocomplete is also true
// and we've got a pending value that matches an option,
remember
// the matched option's index
if (autoComplete === 'on' && currentPendingIndexValid) {
}
// Since we are allowing freeform, if there is currently a
pending value, use that
// otherwise use the index determined above (falling back to ''
if we did not get a valid index)
return _this._getPendingString(currentPendingValue,
currentOptions, index);
}
else {
// If we are not allowing freeform and have a valid index that
matches the pending value,
// we know we will need some version of the pending value
if (currentPendingIndexValid && autoComplete === 'on') {
// If autoComplete is on, return the raw pending value,
otherwise remember
// the matched option's index
return normalizeToString(currentPendingValue);
}
else if (!_this.state.isOpen && currentPendingValue) {
return indexWithinBounds(currentOptions, index)
? currentPendingValue
: normalizeToString(suggestedDisplayValue);
}
else {
return indexWithinBounds(currentOptions, index)
? getPreviewText(currentOptions[index])
: normalizeToString(suggestedDisplayValue);
}
}
}
};
/**
* Handler for typing changes on the input
* @param updatedValue - the newly changed value
*/
_this._onInputChange = function (updatedValue) {
_this._handleInputWhenDisabled(null /* event */);
return;
}
if (_this.props.onInputValueChange) {
_this.props.onInputValueChange(updatedValue);
}
_this.props.allowFreeform
? _this._processInputChangeWithFreeform(updatedValue)
: _this._processInputChangeWithoutFreeform(updatedValue);
};
/**
* Focus (and select) the content of the input
* and set the focused state
*/
_this._onFocus = function () {
var _a, _b;
(_b = (_a = _this._autofill.current) === null || _a === void 0 ? void 0
: _a.inputElement) === null || _b === void 0 ? void 0 : _b.select();
if (!_this._hasFocus()) {
_this.setState({ focusState: 'focusing' });
}
};
/**
* Callback issued when the options should be resolved, if they have been
updated or
* if they need to be passed in the first time. This only does work if an
onResolveOptions
* callback was passed in
*/
_this._onResolveOptions = function () {
if (_this.props.onResolveOptions) {
// get the options
var newOptions_1 =
_this.props.onResolveOptions(tslib_1.__spreadArray([],
_this.props.hoisted.currentOptions));
// Check to see if the returned value is an array, if it is update
the state
// If the returned value is not an array then check to see if it's
a promise or PromiseLike.
// If it is then resolve it asynchronously.
if (Array.isArray(newOptions_1)) {
_this.props.hoisted.setCurrentOptions(newOptions_1);
}
else if (newOptions_1 && newOptions_1.then) {
// Ensure that the promise will only use the callback if it was
the most recent one
// and update the state when the promise returns
_this._currentPromise = newOptions_1;
newOptions_1.then(function (newOptionsFromPromise) {
if (newOptions_1 === _this._currentPromise) {
_this.props.hoisted.setCurrentOptions(newOptionsFromPromise);
}
});
}
}
};
/**
* OnBlur handler. Set the focused state to false
* and submit any pending value
*/
var _a, _b;
// Do nothing if the blur is coming from something
// inside the comboBox root or the comboBox menu since
// it we are not really blurring from the whole comboBox
var relatedTarget = event.relatedTarget;
if (event.relatedTarget === null) {
// In IE11, due to lack of support, event.relatedTarget is always
// null making every onBlur call to be "outside" of the ComboBox
// even when it's not. Using document.activeElement is another way
// for us to be able to get what the relatedTarget without relying
// on the event
relatedTarget = document.activeElement;
}
if (relatedTarget) {
var isBlurFromComboBoxTitle = (_a =
_this.props.hoisted.rootRef.current) === null || _a === void 0 ? void 0 :
_a.contains(relatedTarget);
var isBlurFromComboBoxMenu = (_b = _this._comboBoxMenu.current) ===
null || _b === void 0 ? void 0 : _b.contains(relatedTarget);
var isBlurFromComboBoxMenuAncestor = _this._comboBoxMenu.current &&
Utilities_1.findElementRecursive(_this._comboBoxMenu.current,
function (element) { return element === relatedTarget; });
if (isBlurFromComboBoxTitle || isBlurFromComboBoxMenu ||
isBlurFromComboBoxMenuAncestor) {
if (isBlurFromComboBoxMenuAncestor &&
_this._hasFocus() &&
(!_this.props.multiSelect || _this.props.allowFreeform)) {
_this._submitPendingValue(event);
}
event.preventDefault();
event.stopPropagation();
return;
}
}
if (_this._hasFocus()) {
_this.setState({ focusState: 'none' });
if (!_this.props.multiSelect || _this.props.allowFreeform) {
_this._submitPendingValue(event);
}
}
};
// Render Callout container and pass in list
_this._onRenderContainer = function (props, defaultRender) {
var onRenderList = props.onRenderList, calloutProps =
props.calloutProps, dropdownWidth = props.dropdownWidth, dropdownMaxWidth =
props.dropdownMaxWidth, _a = props.onRenderUpperContent, onRenderUpperContent = _a
=== void 0 ? _this._onRenderUpperContent : _a, _b = props.onRenderLowerContent,
onRenderLowerContent = _b === void 0 ? _this._onRenderLowerContent : _b,
useComboBoxAsMenuWidth = props.useComboBoxAsMenuWidth, persistMenu =
props.persistMenu, _c = props.shouldRestoreFocus, shouldRestoreFocus = _c === void
0 ? true : _c;
var id = _this._id;
var comboBoxMenuWidth = useComboBoxAsMenuWidth &&
_this._comboBoxWrapper.current
? _this._comboBoxWrapper.current.clientWidth + 2
: undefined;
return (React.createElement(Callout_1.Callout,
tslib_1.__assign({ isBeakVisible: false, gapSpace: 0, doNotLayer: false,
directionalHint: Callout_1.DirectionalHint.bottomLeftEdge, directionalHintFixed:
false }, calloutProps, { onLayerMounted: _this._onLayerMounted, className:
Utilities_1.css(_this._classNames.callout, calloutProps === null || calloutProps
=== void 0 ? void 0 : calloutProps.className), target:
_this._comboBoxWrapper.current, onDismiss: _this._onDismiss, onMouseDown:
_this._onCalloutMouseDown, onScroll: _this._onScroll, setInitialFocus: false,
calloutWidth: useComboBoxAsMenuWidth && _this._comboBoxWrapper.current
? comboBoxMenuWidth && comboBoxMenuWidth
: dropdownWidth, calloutMaxWidth: dropdownMaxWidth ?
dropdownMaxWidth : comboBoxMenuWidth, hidden: persistMenu ? !isOpen : undefined,
shouldRestoreFocus: shouldRestoreFocus }),
onRenderUpperContent(_this.props, _this._onRenderUpperContent),
_this._classNames.optionsContainerWrapper, ref: _this._comboBoxMenu }, onRenderList
=== null || onRenderList === void 0 ? void 0 :
onRenderList(tslib_1.__assign(tslib_1.__assign({}, props), { id: id }),
_this._onRenderList)),
onRenderLowerContent(_this.props, _this._onRenderLowerContent)));
};
_this._onLayerMounted = function () {
_this._onCalloutLayerMounted();
// need to call this again here to get the correct scroll parent
dimensions
// when the callout is first opened
_this._scrollIntoView();
}, 0);
if (_this.props.calloutProps &&
_this.props.calloutProps.onLayerMounted) {
_this.props.calloutProps.onLayerMounted();
}
};
_this._onRenderLabel = function (onRenderLabelProps) {
var _a = onRenderLabelProps.props, label = _a.label, disabled =
_a.disabled, required = _a.required;
if (label) {
return (React.createElement(Label_1.Label, { id: _this._id + '-
label', disabled: disabled, required: required, className:
_this._classNames.label },
label,
onRenderLabelProps.multiselectAccessibleText &&
(React.createElement("span", { className: _this._classNames.screenReaderText },
onRenderLabelProps.multiselectAccessibleText))));
}
return null;
};
// Render List of items
_this._onRenderList = function (props) {
var _a = props.onRenderItem, onRenderItem = _a === void 0 ?
_this._onRenderItem : _a, label = props.label, ariaLabel = props.ariaLabel,
multiSelect = props.multiSelect;
var queue = { items: [] };
var renderedList = [];
var emptyQueue = function () {
var newGroup = queue.id
? [
React.createElement("div", { role: "group", key: queue.id,
"aria-labelledby": queue.id }, queue.items),
]
: queue.items;
renderedList = tslib_1.__spreadArray(tslib_1.__spreadArray([],
renderedList), newGroup);
// Flush items and id
queue = { items: [] };
};
var placeRenderedOptionIntoQueue = function (item, index) {
/*
Case Header
empty queue if it's not already empty
ensure unique ID for header and set queue ID
push header into queue
Case Divider
push divider into queue if not first item
empty queue if not already empty
Default
push item into queue
*/
switch (item.itemType) {
case SelectableOption_1.SelectableOptionMenuItemType.Header:
queue.items.length > 0 && emptyQueue();
var id_1 = _this._id + item.key;
queue.items.push(onRenderItem(tslib_1.__assign(tslib_1.__assign({ id: id_1 },

item), { index: index }), _this._onRenderItem));
queue.id = id_1;
break;
case SelectableOption_1.SelectableOptionMenuItemType.Divider:
index > 0 &&
queue.items.push(onRenderItem(tslib_1.__assign(tslib_1.__assign({}, item), { index:
index }), _this._onRenderItem));
break;
default:

}
};
// Place options into the queue. Queue will be emptied anytime a Header
or Divider is encountered
props.options.forEach(function (item, index) {
placeRenderedOptionIntoQueue(item, index);
});
// Push remaining items into all renderedList
var id = _this._id;
return (React.createElement("div", { id: id + '-list', className:
_this._classNames.optionsContainer, "aria-labelledby": label && id + '-label',
"aria-label": ariaLabel && !label ? ariaLabel : undefined, "aria-multiselectable":
multiSelect ? 'true' : undefined, role: "listbox" }, renderedList));
};
// Render items
return _this._renderSeparator(item);
return _this._renderHeader(item);
default:
return _this._renderOption(item);
}
};
// Default _onRenderLowerContent function returns nothing
_this._onRenderLowerContent = function () {
return null;
};
// Default _onRenderUpperContent function returns nothing
_this._onRenderUpperContent = function () {
return null;
};
_this._renderOption = function (item) {
var _a = _this.props.onRenderOption, onRenderOption = _a === void 0 ?
_this._onRenderOptionContent : _a;
var id = _this._id;
var isSelected = _this._isOptionSelected(item.index);
var isChecked = _this._isOptionChecked(item.index);
var isIndeterminate = _this._isOptionIndeterminate(item.index);
var optionStyles = _this._getCurrentOptionStyles(item);
var optionClassNames =
ComboBox_classNames_1.getComboBoxOptionClassNames(_this._getCurrentOptionStyles(ite
m));
var title = item.title;
var onRenderCheckboxLabel = function () { return onRenderOption(item,
_this._onRenderOptionContent); };
var getOptionComponent = function () {
return !_this.props.multiSelect ?
(React.createElement(Button_1.CommandButton, { id: id + '-list' + item.index, key:
item.key, "data-index": item.index, styles: optionStyles, checked: isSelected,
className: 'ms-ComboBox-option', onClick: _this._onItemClick(item),
onMouseEnter: _this._onOptionMouseEnter.bind(_this,
item.index),
onMouseMove: _this._onOptionMouseMove.bind(_this, item.index),
onMouseLeave: _this._onOptionMouseLeave, role: "option", "aria-selected":
isSelected ? 'true' : 'false', ariaLabel: item.ariaLabel, disabled: item.disabled,
title: title }, React.createElement("span", { className:
optionClassNames.optionTextWrapper, ref: isSelected ? _this._selectedElement :
undefined }, onRenderOption(item, _this._onRenderOptionContent)))) :
(React.createElement(Checkbox_1.Checkbox, { id: id + '-list' + item.index,
ariaLabel: item.ariaLabel, key: item.key, styles: optionStyles, className: 'ms-
ComboBox-option', onChange: _this._onItemClick(item), label: item.text, checked:
isChecked, indeterminate: isIndeterminate, title: title, disabled: item.disabled,
onRenderLabel: onRenderCheckboxLabel, inputProps:
tslib_1.__assign({
// aria-selected should only be applied to checked items,
not hovered items
'aria-selected': isChecked ? 'true' : 'false', role:
'option' }, {
'data-index': item.index,
'data-is-focusable': true,
}) }));
};
return (React.createElement(ComboBoxOptionWrapper, { key: item.key,
index: item.index, disabled: item.disabled, isSelected: isSelected, isChecked:
isChecked, isIndeterminate: isIndeterminate, text: item.text,
render: getOptionComponent, data: item.data }));
};
/**
* Mouse clicks to headers, dividers and scrollbar should not make input
lose focus
*/
_this._onCalloutMouseDown = function (ev) {
};
/**
* Scroll handler for the callout to make sure the mouse events
* for updating focus are not interacting during scroll
*/
_this._onScroll = function () {
var _a;
if (!_this._isScrollIdle && _this._scrollIdleTimeoutId !== undefined) {
_this._async.clearTimeout(_this._scrollIdleTimeoutId);
_this._scrollIdleTimeoutId = undefined;
}
else {
_this._isScrollIdle = false;
}
if ((_a = _this.props.calloutProps) === null || _a === void 0 ? void
0 : _a.onScroll) {
_this.props.calloutProps.onScroll();
}
_this._scrollIdleTimeoutId = _this._async.setTimeout(function () {
_this._isScrollIdle = true;
}, ScrollIdleDelay);
};
_this._onRenderOptionContent = function (item) {
var optionClassNames =
ComboBox_classNames_1.getComboBoxOptionClassNames(_this._getCurrentOptionStyles(ite
m));
optionClassNames.optionText }, item.text);
};
/**
* Handles dismissing (cancelling) the menu
*/
_this._onDismiss = function () {
var onMenuDismiss = _this.props.onMenuDismiss;
if (onMenuDismiss) {
onMenuDismiss();
}
// In persistMode we need to simulate callout layer mount
// since that only happens once. We do it on dismiss since
// it works either way.
if (_this.props.persistMenu) {
_this._onCalloutLayerMounted();
}
// close the menu
_this._setOpenStateAndFocusOnClose(false /* isOpen */, false /*
focusInputAfterClose */);
// reset the selected index
// to the last value state
_this._resetSelectedIndex();
};
_this._onAfterClearPendingInfo = function () {
_this._processingClearPendingInfo = false;
};
/**
* Handle keydown on the input
* @param ev - The keyboard event that was fired
*/
_this._onInputKeyDown = function (ev) {
var _a = _this.props, disabled = _a.disabled, allowFreeform =
_a.allowFreeform, autoComplete = _a.autoComplete, currentOptions =
_a.hoisted.currentOptions;
var _b = _this.state, isOpen = _b.isOpen,
currentPendingValueValidIndexOnHover = _b.currentPendingValueValidIndexOnHover;
// Take note if we are processing an alt (option) or meta (command)
keydown.
// See comment in _onInputKeyUp for reasoning.
_this._lastKeyDownWasAltOrMeta = isAltOrMeta(ev);
if (disabled) {
_this._handleInputWhenDisabled(ev);
return;
}
var index = _this._getPendingSelectedIndex(false /*
includeCurrentPendingValue */);
switch (ev.which) {
case Utilities_1.KeyCodes.enter:
if (_this._autofill.current &&
_this._autofill.current.inputElement) {
_this._autofill.current.inputElement.select();
}
_this._submitPendingValue(ev);
if (_this.props.multiSelect && isOpen) {
_this.setState({
currentPendingValueValidIndex: index,
});
}
else {
// On enter submit the pending value
if (isOpen ||
((!allowFreeform ||
_this.state.currentPendingValue === undefined ||
_this.state.currentPendingValue === null ||
_this.state.currentPendingValue.length <= 0) &&
_this.state.currentPendingValueValidIndex < 0)) {
// if we are open or
// if we are not allowing freeform or
// our we have no pending value
// and no valid pending index
// flip the open state
_this.setState({
isOpen: !isOpen,
});
}
}
break;
case Utilities_1.KeyCodes.tab:
// On enter submit the pending value
if (!_this.props.multiSelect) {
_this._submitPendingValue(ev);
}
// If we are not allowing freeform
// or the combo box is open, flip the open state
if (isOpen) {
_this._setOpenStateAndFocusOnClose(!isOpen, false /*
}
// Allow TAB to propagate
return;
case Utilities_1.KeyCodes.escape:
// reset the selected index
_this._resetSelectedIndex();
// Close the menu if opened
if (isOpen) {
_this.setState({
isOpen: false,
});
}
else {
return;
}
break;
case Utilities_1.KeyCodes.up:
// if we are in clearAll state (e.g. the user as hovering
// and has since mousedOut of the menu items),
// go to the last index
if (currentPendingValueValidIndexOnHover ===
HoverStatus.clearAll) {
index = _this.props.hoisted.currentOptions.length;
}
if (ev.altKey || ev.metaKey) {
// Close the menu if it is open and break so
// that the event get stopPropagation and prevent default.
// Otherwise, we need to let the event continue to
propagate
if (isOpen) {
_this._setOpenStateAndFocusOnClose(!isOpen, true /*
break;
}
return;
}
// do not scroll page
// Go to the previous option
_this._setPendingInfoFromIndexAndDirection(index,
SearchDirection.backward);
break;
case Utilities_1.KeyCodes.down:
// Expand the combo box on ALT + DownArrow
if (ev.altKey || ev.metaKey) {
_this._setOpenStateAndFocusOnClose(true /* isOpen */,
true /* focusInputAfterClose */);
}
else {
// if we are in clearAll state (e.g. the user as hovering
// and has since mousedOut of the menu items),
// go to the first index
if (currentPendingValueValidIndexOnHover ===
HoverStatus.clearAll) {
index = -1;
}
// do not scroll page
// Got to the next option
SearchDirection.forward);
}
break;
case Utilities_1.KeyCodes.home:
case Utilities_1.KeyCodes.end:
return;
}
// Set the initial values to respond to HOME
// which goes to the first selectable option
index = -1;
var directionToSearch = SearchDirection.forward;
// If end, update the values to respond to END
// which goes to the last selectable option
if (ev.which === Utilities_1.KeyCodes.end) {
index = currentOptions.length;
directionToSearch = SearchDirection.backward;
}
directionToSearch);
break;
/* eslint-disable no-fallthrough */
case Utilities_1.KeyCodes.space:
// event handled in _onComboBoxKeyUp
if (!allowFreeform && autoComplete === 'off') {
break;
}
default:
/* eslint-enable no-fallthrough */
// are we processing a function key? if so bail out
if (ev.which >= 112 /* F1 */ && ev.which <= 123 /* F12 */) {
return;
}
// If we get here and we got either and ALT key
// or meta key, let the event propagate
if (ev.keyCode === Utilities_1.KeyCodes.alt || ev.key ===
'Meta' /* && isOpen */) {
return;
}
// If we are not allowing freeform and
// allowing autoComplete, handle the input here
// since we have marked the input as readonly
if (!allowFreeform && autoComplete === 'on') {
_this._onInputChange(ev.key);
break;
}
// allow the key to propagate by default
return;
}
};
/**
* Handle keyup on the input
* @param ev - the keyboard event that was fired
*/
_this._onInputKeyUp = function (ev) {
_a.allowFreeform, autoComplete = _a.autoComplete;
// We close the menu on key up only if ALL of the following are true:
// - Most recent key down was alt or meta (command)
// - The alt/meta key down was NOT followed by some other key (such as
down/up arrow to
// expand/collapse the menu)
// - We're not on a Mac (or iOS)
// This is because on Windows, pressing alt moves focus to the
application menu bar or similar,
// closing any open context menus. There is not a similar behavior on
Macs.
var keyPressIsAltOrMetaAlone = _this._lastKeyDownWasAltOrMeta &&
isAltOrMeta(ev);
_this._lastKeyDownWasAltOrMeta = false;
var shouldHandleKey = keyPressIsAltOrMetaAlone && !(Utilities_1.isMac()
|| Utilities_1.isIOS());
if (disabled) {
_this._handleInputWhenDisabled(ev);
return;
}
switch (ev.which) {
// If we are not allowing freeform and are not autoComplete
// make space expand/collapse the combo box
// and allow the event to propagate
if (!allowFreeform && autoComplete === 'off') {
_this._setOpenStateAndFocusOnClose(!isOpen, !!isOpen);
}
return;
default:
if (shouldHandleKey && isOpen) {
_this._setOpenStateAndFocusOnClose(!isOpen, true /*
}
else {
if (_this.state.focusState === 'focusing' &&
_this.props.openOnKeyboardFocus) {
_this.setState({ isOpen: true });
}
if (_this.state.focusState !== 'focused') {
}
}
return;
}
};
_this._onOptionMouseLeave = function () {
if (_this._shouldIgnoreMouseEvent()) {
return;
}
// Ignore the event in persistMenu mode if the callout has
// closed. This is to avoid clearing the visuals on item click.
if (_this.props.persistMenu && !_this.state.isOpen) {
return;
}
_this.setState({
currentPendingValueValidIndexOnHover: HoverStatus.clearAll,
});
};
/**
* Click handler for the button of the combo box and the input when not
allowing freeform.
* This toggles the expand/collapse state of the combo box (if enabled).
*/
_this._onComboBoxClick = function () {
if (!disabled) {
_this._setOpenStateAndFocusOnClose(!isOpen, false /*
}
};
/**
* Click handler for the autofill.
*/
_this._onAutofillClick = function () {
_a.allowFreeform;
if (allowFreeform && !disabled) {
_this.focus(_this.state.isOpen || _this._processingTouch);
}
else {
_this._onComboBoxClick();
}
};
_this._onTouchStart = function () {
if (_this._comboBoxWrapper.current && !('onpointerdown' in
_this._comboBoxWrapper)) {
}
};
_this._onPointerDown = function (ev) {
}
};
Utilities_1.warnMutuallyExclusive(COMPONENT_NAME, props, {
defaultSelectedKey: 'selectedKey',
text: 'defaultSelectedKey',
selectedKey: 'value',
dropdownWidth: 'useComboBoxAsMenuWidth',
ariaLabel: 'label',
});
_this._id = props.id || Utilities_1.getId('ComboBox');
_this._gotMouseMove = false;
_this._processingClearPendingInfo = false;
_this.state = {
isOpen: false,
focusState: 'none',
currentPendingValueValidIndex: -1,
currentPendingValue: undefined,
currentPendingValueValidIndexOnHover: HoverStatus.default,
};
return _this;
}
Object.defineProperty(ComboBoxInternal.prototype, "selectedOptions", {
/**
* All selected options
*/
get: function () {
var _a = this.props.hoisted, currentOptions = _a.currentOptions,
selectedIndices = _a.selectedIndices;
return SelectableOption_1.getAllSelectedOptions(currentOptions,
selectedIndices);
},
enumerable: false,
configurable: true
});
ComboBoxInternal.prototype.componentDidMount = function () {
if (this._comboBoxWrapper.current && !this.props.disabled) {
// hook up resolving the options if needed on focus
this._events.on(this._comboBoxWrapper.current, 'focus',
this._onResolveOptions, true);
if ('onpointerdown' in this._comboBoxWrapper.current) {
// For ComboBoxes, touching anywhere in the combo box should drop
the dropdown, including the input element.
// This gives more hit target space for touch environments. We're
setting the onpointerdown here, because React
// does not support Pointer events yet.
this._events.on(this._comboBoxWrapper.current, 'pointerdown',
this._onPointerDown, true);
}
}
};
ComboBoxInternal.prototype.componentDidUpdate = function (prevProps, prevState)
{
var _this = this;
var _a = this.props, allowFreeform = _a.allowFreeform, text = _a.text,
onMenuOpen = _a.onMenuOpen, onMenuDismissed = _a.onMenuDismissed, selectedIndices =
_a.hoisted.selectedIndices;
var _b = this.state, isOpen = _b.isOpen, currentPendingValueValidIndex =
_b.currentPendingValueValidIndex;
// If we are newly open or are open and the pending valid index changed,
// make sure the currently selected/pending option is scrolled into view
if (isOpen && (!prevState.isOpen || prevState.currentPendingValueValidIndex
!== currentPendingValueValidIndex)) {
// Need this timeout so that the selectedElement ref is correctly
updated
this._async.setTimeout(function () { return _this._scrollIntoView(); },
0);
}
// if an action is taken that put focus in the ComboBox
// and If we are open or we are just closed, shouldFocusAfterClose is set,
// but we are not the activeElement set focus on the input
if (this._hasFocus() &&
(isOpen ||
(prevState.isOpen &&
!isOpen &&
this._focusInputAfterClose &&
this._autofill.current &&
document.activeElement !==
this._autofill.current.inputElement))) {
this.focus(undefined /*shouldOpenOnFocus*/, true /*useFocusAsync*/);
}
// If we should focusAfterClose AND
// just opened/closed the menu OR
// are focused AND
// updated the selectedIndex with the menu closed OR
// are not allowing freeform OR
// the value changed
// we need to set selection
if (this._focusInputAfterClose &&
((prevState.isOpen && !isOpen) ||
(this._hasFocus() &&
((!isOpen &&
!this.props.multiSelect &&
prevProps.hoisted.selectedIndices &&
selectedIndices &&
prevProps.hoisted.selectedIndices[0] !==
selectedIndices[0]) ||
!allowFreeform ||
text !== prevProps.text)))) {
this._onFocus();
}
this._notifyPendingValueChanged(prevState);
if (isOpen && !prevState.isOpen && onMenuOpen) {
onMenuOpen();
}
if (!isOpen && prevState.isOpen && onMenuDismissed) {
onMenuDismissed();
}
};
ComboBoxInternal.prototype.componentWillUnmount = function () {
};
// Primary Render
ComboBoxInternal.prototype.render = function () {
var id = this._id;
var errorMessageId = id + '-error';
var _a = this.props, className = _a.className, disabled = _a.disabled,
required = _a.required, errorMessage = _a.errorMessage, _b = _a.onRenderContainer,
onRenderContainer = _b === void 0 ? this._onRenderContainer : _b, _c =
_a.onRenderLabel, onRenderLabel = _c === void 0 ? this._onRenderLabel : _c, _d =
_a.onRenderList, onRenderList = _d === void 0 ? this._onRenderList : _d, _e =
_a.onRenderItem, onRenderItem = _e === void 0 ? this._onRenderItem : _e, _f =
_a.onRenderOption, onRenderOption = _f === void 0 ? this._onRenderOptionContent :
_f, allowFreeform = _a.allowFreeform, customStyles = _a.styles, theme = _a.theme,
persistMenu = _a.persistMenu, multiSelect = _a.multiSelect, _g = _a.hoisted,
suggestedDisplayValue = _g.suggestedDisplayValue, selectedIndices =
_g.selectedIndices, currentOptions = _g.currentOptions;
var isOpen = this.state.isOpen;
this._currentVisibleValue = this._getVisibleValue();
// Single select is already accessible since the whole text is selected
// when focus enters the input. Since multiselect appears to clear the
input
// it needs special accessible text
var multiselectAccessibleText = multiSelect
? this._getMultiselectDisplayString(selectedIndices, currentOptions,
suggestedDisplayValue)
: undefined;
var divProps = Utilities_1.getNativeProps(this.props,
Utilities_1.divProperties, [
'onChange',
'value',
'aria-describedby',
'aria-labelledby',
]);
var hasErrorMessage = errorMessage && errorMessage.length > 0 ? true :
false;
this._classNames = this.props.getClassNames
? this.props.getClassNames(theme, !!isOpen, !!disabled, !!required, !!
this._hasFocus(), !!allowFreeform, !!hasErrorMessage, className)
:
ComboBox_classNames_1.getClassNames(ComboBox_styles_1.getStyles(theme,
customStyles), className, !!isOpen, !!disabled, !!required, !!this._hasFocus(), !!
allowFreeform, !!hasErrorMessage);
var comboBoxWrapper =
this._renderComboBoxWrapper(multiselectAccessibleText, errorMessageId);
return (React.createElement("div", tslib_1.__assign({}, divProps, { ref:
this.props.hoisted.mergedRootRef, className: this._classNames.container }),
onRenderLabel({ props: this.props, multiselectAccessibleText:
multiselectAccessibleText }, this._onRenderLabel),
comboBoxWrapper,
(persistMenu || isOpen) &&
onRenderContainer(tslib_1.__assign(tslib_1.__assign({},
this.props), { onRenderList: onRenderList, onRenderItem: onRenderItem,
onRenderOption: onRenderOption, options: currentOptions.map(function (item, index)
{ return (tslib_1.__assign(tslib_1.__assign({}, item), { index: index })); }),
onDismiss: this._onDismiss }), this._onRenderContainer),
hasErrorMessage && (React.createElement("div", { role: "alert", id:
errorMessageId, className: this._classNames.errorMessage }, errorMessage))));
};
ComboBoxInternal.prototype._getPendingString = function (currentPendingValue,
currentOptions, index) {
return currentPendingValue !== null && currentPendingValue !== undefined
? currentPendingValue
: indexWithinBounds(currentOptions, index)
? getPreviewText(currentOptions[index])
: '';
};
/**
* Returns a string that concatenates all of the selected values
* for multiselect combo box.
*/
ComboBoxInternal.prototype._getMultiselectDisplayString = function
(selectedIndices, currentOptions, suggestedDisplayValue) {
var displayValues = [];
for (var idx = 0; selectedIndices && idx < selectedIndices.length; idx++) {
var index = selectedIndices[idx];
if (currentOptions[index].itemType !==
SelectableOption_1.SelectableOptionMenuItemType.SelectAll) {
displayValues.push(indexWithinBounds(currentOptions, index)
? currentOptions[index].text
: normalizeToString(suggestedDisplayValue));
}
}
var _a = this.props.multiSelectDelimiter, multiSelectDelimiter = _a ===
void 0 ? ', ' : _a;
return displayValues.join(multiSelectDelimiter);
};
/**
* Process the new input's new value when the combo box allows freeform entry
* @param updatedValue - the input's newly changed value
*/
ComboBoxInternal.prototype._processInputChangeWithFreeform = function
(updatedValue) {
var currentOptions = this.props.hoisted.currentOptions;
var newCurrentPendingValueValidIndex = -1;
// if the new value is empty, see if we have an exact match and then set
the pending info
if (updatedValue === '') {
var items = currentOptions
.map(function (item, index) { return
(tslib_1.__assign(tslib_1.__assign({}, item), { index: index })); })
.filter(function (option) { return isNormalOption(option) &&
getPreviewText(option) === updatedValue; });
// if we found a match remember the index
if (items.length === 1) {
newCurrentPendingValueValidIndex = items[0].index;
}
this._setPendingInfo(updatedValue, newCurrentPendingValueValidIndex,
updatedValue);
return;
}
// Remember the original value and then make the value lowercase for
comparison
var originalUpdatedValue = updatedValue;
updatedValue = updatedValue.toLocaleLowerCase();
var newSuggestedDisplayValue = '';
// If autoComplete is on, attempt to find a match from the available
options
if (this.props.autoComplete === 'on') {
// If autoComplete is on, attempt to find a match where the text of an
option starts with the updated value
getPreviewText(option).toLocaleLowerCase().indexOf(updatedValue) === 0; });
if (items.length > 0) {
// use ariaLabel as the value when the option is set
var text = getPreviewText(items[0]);
// If the user typed out the complete option text, we don't need
any suggested display text anymore
newSuggestedDisplayValue = text.toLocaleLowerCase() !==
updatedValue ? text : '';
// remember the index of the match we found
}
}
else {
// If autoComplete is off, attempt to find a match only when the value
is exactly equal to the text of an option
getPreviewText(option).toLocaleLowerCase() === updatedValue; });
// if we found a match remember the index
if (items.length === 1) {
}
}
// Set the updated state
this._setPendingInfo(originalUpdatedValue,
newCurrentPendingValueValidIndex, newSuggestedDisplayValue);
};
/**
* Process the new input's new value when the combo box does not allow freeform
entry
* @param updatedValue - the input's newly changed value
*/
ComboBoxInternal.prototype._processInputChangeWithoutFreeform = function
(updatedValue) {
var _this = this;
var _a = this.state, currentPendingValue = _a.currentPendingValue,
currentPendingValueValidIndex = _a.currentPendingValueValidIndex;
if (this.props.autoComplete === 'on') {
// If autoComplete is on while allow freeform is off,
// we will remember the key press and build up a string to attempt to
match
// as long as characters are typed within a the timeout span of each
other,
// otherwise we will clear the string and start building a new one on
the next keypress.
// Also, only do this processing if we have a non-empty value
if (updatedValue !== '') {
// If we have a pending autocomplete clearing task,
// we know that the user is typing with key press happening
// within the timeout of each other so remove the clearing task
// and continue building the pending value with the updated value
if (this._autoCompleteTimeout) {
this._async.clearTimeout(this._autoCompleteTimeout);
this._autoCompleteTimeout = undefined;
updatedValue = normalizeToString(currentPendingValue) +
updatedValue;
}
var originalUpdatedValue = updatedValue;
updatedValue = updatedValue.toLocaleLowerCase();
// If autoComplete is on, attempt to find a match where the text of
an option starts with the updated value
.map(function (item, i) { return
(tslib_1.__assign(tslib_1.__assign({}, item), { index: i })); })
option.text.toLocaleLowerCase().indexOf(updatedValue) === 0; });
// If we found a match, update the state
if (items.length > 0) {
this._setPendingInfo(originalUpdatedValue, items[0].index,
getPreviewText(items[0]));
}
// Schedule a timeout to clear the pending value after the timeout
span
this._autoCompleteTimeout = this._async.setTimeout(function () {
_this._autoCompleteTimeout = undefined;
}, ReadOnlyPendingAutoCompleteTimeout);
return;
}
}
// If we get here, either autoComplete is on or we did not find a match
with autoComplete on.
// Remember we are not allowing freeform, so at this point, if we have a
pending valid value index
// use that; otherwise use the selectedIndex
var index = currentPendingValueValidIndex >= 0 ?
currentPendingValueValidIndex : this._getFirstSelectedIndex();
// Since we are not allowing freeform, we need to
// set both the pending and suggested values/index
// to allow us to select all content in the input to
// give the illusion that we are readonly (e.g. freeform off)
this._setPendingInfoFromIndex(index);
};
ComboBoxInternal.prototype._getFirstSelectedIndex = function () {
var selectedIndices = this.props.hoisted.selectedIndices;
return (selectedIndices === null || selectedIndices === void 0 ? void 0 :
selectedIndices.length) ? selectedIndices[0] : -1;
};
/**
* Walk along the options starting at the index, stepping by the delta
(positive or negative)
* looking for the next valid selectable index (e.g. skipping headings and
dividers)
* @param index - the index to get the next selectable index from
* @param delta - optional delta to step by when finding the next index,
defaults to 0
* @returns - the next valid selectable index. If the new index is outside of
the bounds,
* it will snap to the edge of the options array. If delta == 0 and the given
index is not selectable
*/
ComboBoxInternal.prototype._getNextSelectableIndex = function (index,
searchDirection) {
var newIndex = index + searchDirection;
newIndex = Math.max(0, Math.min(currentOptions.length - 1, newIndex));
if (!indexWithinBounds(currentOptions, newIndex)) {
return -1;
}
var option = currentOptions[newIndex];
if (!isSelectableOption(option) || option.hidden === true) {
// Should we continue looking for an index to select?
if (searchDirection !== SearchDirection.none &&
((newIndex > 0 && searchDirection < SearchDirection.none) ||
(newIndex >= 0 && newIndex < currentOptions.length &&
searchDirection > SearchDirection.none))) {
newIndex = this._getNextSelectableIndex(newIndex, searchDirection);
}
else {
// If we cannot perform a useful search just return the index we
were given
return index;
}
}
// We have the next valid selectable index, return it
return newIndex;
};
/**
* Set the selected index. Note, this is
* the "real" selected index, not the pending selected index
* @param index - the index to set (or the index to set from if a search
direction is provided)
* @param searchDirection - the direction to search along the options from the
given index
*/
ComboBoxInternal.prototype._setSelectedIndex = function (index,
submitPendingValueEvent, searchDirection) {
if (searchDirection === void 0) { searchDirection = SearchDirection.none; }
var _a = this.props, onChange = _a.onChange, onPendingValueChanged =
_a.onPendingValueChanged, _b = _a.hoisted, initialIndices = _b.selectedIndices,
currentOptions = _b.currentOptions;
// Clone currentOptions and selectedIndices so we don't mutate state
var selectedIndices = initialIndices ? initialIndices.slice() : [];
var changedOptions = currentOptions.slice();
// Find the next selectable index, if searchDirection is none
// we will get our starting index back
index = this._getNextSelectableIndex(index, searchDirection);
if (!indexWithinBounds(currentOptions, index)) {
return;
}
// Are we at a new index? If so, update the state, otherwise
// there is nothing to do
if (this.props.multiSelect ||
selectedIndices.length < 1 ||
(selectedIndices.length === 1 && selectedIndices[0] !== index)) {
var option = tslib_1.__assign({}, currentOptions[index]);
// if option doesn't existing, or option is disabled, we noop
if (!option || option.disabled) {
return;
}
if (this.props.multiSelect) {
// Setting the initial state of option.selected in Multi-select
combo box by checking the
// selectedIndices array and overriding the undefined issue
option.selected = option.selected !== undefined ? !
option.selected : selectedIndices.indexOf(index) < 0;
// handle changing all options if SelectAll is changed
if (option.itemType ===
selectedIndices = [];
// if select all is set to checked, push all selectable option
indices
if (option.selected) {
currentOptions.forEach(function (currentOption, i) {
if (!currentOption.disabled &&
isSelectableOption(currentOption)) {
selectedIndices.push(i);
changedOptions[i] =
tslib_1.__assign(tslib_1.__assign({}, currentOption), { selected: true });
}
});
}
// otherwise un-check all options
else {
changedOptions = currentOptions.map(function
(currentOption) { return (tslib_1.__assign(tslib_1.__assign({}, currentOption),
{ selected: false })); });
}
}
// otherwise update the individual option
else {
if (option.selected && selectedIndices.indexOf(index) < 0) {
selectedIndices.push(index);
}
else if (!option.selected && selectedIndices.indexOf(index) >=
0) {
selectedIndices = selectedIndices.filter(function (value) {
return value !== index; });
}
changedOptions[index] = option;
// If SelectAll exists and another option was toggled, update
the SelectAll option's state
var selectAllOption = changedOptions.filter(function (o)
{ return o.itemType ===
SelectableOption_1.SelectableOptionMenuItemType.SelectAll; })[0];
if (selectAllOption) {
var selectAllState =
this._isSelectAllChecked(selectedIndices);
var selectAllIndex_1 =
changedOptions.indexOf(selectAllOption);
if (selectAllState) {
selectedIndices.push(selectAllIndex_1);
changedOptions[selectAllIndex_1] =
tslib_1.__assign(tslib_1.__assign({}, selectAllOption), { selected: true });
}
else {
selectedIndices = selectedIndices.filter(function
(value) { return value !== selectAllIndex_1; });
changedOptions[selectAllIndex_1] =
tslib_1.__assign(tslib_1.__assign({}, selectAllOption), { selected: false });
}
}
}
}
else {
selectedIndices[0] = index;
}
submitPendingValueEvent.persist();
// Only setState if combo box is uncontrolled.
if (this.props.selectedKey || this.props.selectedKey === null) {
// If combo box value is changed, revert preview first
if (this._hasPendingValue && onPendingValueChanged) {
onPendingValueChanged();
this._hasPendingValue = false;
}
}
else {
this.props.hoisted.setSelectedIndices(selectedIndices);
this.props.hoisted.setCurrentOptions(changedOptions);
// If ComboBox value is changed, revert preview first
if (this._hasPendingValue && onPendingValueChanged) {
onPendingValueChanged();
this._hasPendingValue = false;
}
}
// Call onChange after state is updated
if (onChange) {
onChange(submitPendingValueEvent, option, index,
getPreviewText(option));
}
}
if (this.props.multiSelect && this.state.isOpen) {
return;
}
// clear all of the pending info
this._clearPendingInfo();
};
/**
* Submit a pending value if there is one
*/
ComboBoxInternal.prototype._submitPendingValue = function
(submitPendingValueEvent) {
var _a;
var _b = this.props, onChange = _b.onChange, allowFreeform =
_b.allowFreeform, autoComplete = _b.autoComplete, multiSelect = _b.multiSelect,
hoisted = _b.hoisted;
var currentOptions = hoisted.currentOptions;
var _c = this.state, currentPendingValue = _c.currentPendingValue,
currentPendingValueValidIndex = _c.currentPendingValueValidIndex,
currentPendingValueValidIndexOnHover = _c.currentPendingValueValidIndexOnHover;
// Do not submit any pending value if we
// have already initiated clearing the pending info
if (this._processingClearPendingInfo) {
return;
}
// If we allow freeform we need to handle that
// if currentPendingValue is null or undefined the user did not submit
anything
// (not even empty because we would have stored that as the pending
value)
if (currentPendingValue === null || currentPendingValue === undefined)
{
// if a user did not type anything they may just hovered over an
item
if (currentPendingValueValidIndexOnHover >= 0) {
this._setSelectedIndex(currentPendingValueValidIndexOnHover,
submitPendingValueEvent);
}
return;
}
// Check to see if the user typed an exact match
if (indexWithinBounds(currentOptions, currentPendingValueValidIndex)) {
var pendingOptionText =
getPreviewText(currentOptions[currentPendingValueValidIndex]).toLocaleLowerCase();
var autofill = this._autofill.current;
// By exact match, that means: our pending value is the same as the
pending option text OR
// the pending option starts with the pending value and we have an
"autoComplete" selection
// where the total length is equal to pending option length OR
// the live value in the underlying input matches the pending
option; update the state
if (currentPendingValue.toLocaleLowerCase() === pendingOptionText
||
(autoComplete &&
pendingOptionText.indexOf(currentPendingValue.toLocaleLowerCase()) === 0 &&

(autofill === null || autofill === void 0 ? void 0 :
autofill.isValueSelected) &&
currentPendingValue.length + (autofill.selectionEnd -
autofill.selectionStart) ===
pendingOptionText.length) ||
((_a = autofill === null || autofill === void 0 ? void 0 :
autofill.inputElement) === null || _a === void 0 ? void 0 :
_a.value.toLocaleLowerCase()) === pendingOptionText) {
this._setSelectedIndex(currentPendingValueValidIndex,
if (multiSelect && this.state.isOpen) {
return;
}
return;
}
}
if (onChange) {
if (onChange) {
// trigger onChange to clear value
onChange(submitPendingValueEvent, undefined, undefined,
currentPendingValue);
}
}
else {
// If we are not controlled, create a new selected option
var newOption = {
key: currentPendingValue || Utilities_1.getId(),
text: normalizeToString(currentPendingValue),
};
// If it's multiselect, set selected state to true
if (multiSelect) {
newOption.selected = true;
}
var newOptions = currentOptions.concat([newOption]);
if (selectedIndices) {
if (!multiSelect) {
selectedIndices = [];
}
selectedIndices.push(newOptions.length - 1);
}
hoisted.setCurrentOptions(newOptions);
hoisted.setSelectedIndices(selectedIndices);
}
}
else if (currentPendingValueValidIndex >= 0) {
// Since we are not allowing freeform, we must have a matching
// to be able to update state
this._setSelectedIndex(currentPendingValueValidIndex,
}
else if (currentPendingValueValidIndexOnHover >= 0) {
// If all else failed and we were hovering over an item, select it
this._setSelectedIndex(currentPendingValueValidIndexOnHover,
}
// Finally, clear the pending info
};
ComboBoxInternal.prototype._onCalloutLayerMounted = function () {
// In persistMenu mode _onLayerMounted is only called once for the lifetime
// of the component. Any functionality required for callout "on mount" can
// go here so that we can also call it again during callout dismissal to
reset
// object state.
this._gotMouseMove = false;
};
// Render separator
ComboBoxInternal.prototype._renderSeparator = function (item) {
var index = item.index, key = item.key;
if (index && index > 0) {
return React.createElement("div", { role: "separator", key: key,
className: this._classNames.divider });
}
return null;
};
ComboBoxInternal.prototype._renderHeader = function (item) {
var _a = this.props.onRenderOption, onRenderOption = _a === void 0 ?
this._onRenderOptionContent : _a;
return (React.createElement("div", { id: item.id, key: item.key, className:
this._classNames.header }, onRenderOption(item, this._onRenderOptionContent)));
};
/**
* If we are coming from a mouseOut:
* there is no visible selected option.
*
* Else if We are hovering over an item:
* that gets the selected look.
*
* Else:
* Use the current valid pending index if it exists OR
* we do not have a valid index and we currently have a pending input value,
* otherwise use the selected index
* */
ComboBoxInternal.prototype._isOptionHighlighted = function (index) {
var currentPendingValueValidIndexOnHover =
this.state.currentPendingValueValidIndexOnHover;
// If the hover state is set to clearAll, don't show a selected index.
// Note, this happens when the user moused out of the menu items
if (currentPendingValueValidIndexOnHover === HoverStatus.clearAll) {
return false;
}
return currentPendingValueValidIndexOnHover >= 0
? currentPendingValueValidIndexOnHover === index
: this._isOptionSelected(index);
};
ComboBoxInternal.prototype._isOptionSelected = function (index) {
return this._getPendingSelectedIndex(true /* includePendingValue */) ===
index;
};
ComboBoxInternal.prototype._isOptionChecked = function (index) {
if (this.props.multiSelect && index !== undefined &&
this.props.hoisted.selectedIndices) {
var idxOfSelectedIndex = -1;
idxOfSelectedIndex = this.props.hoisted.selectedIndices.indexOf(index);
return idxOfSelectedIndex >= 0;
}
return false;
};
ComboBoxInternal.prototype._isOptionIndeterminate = function (index) {
var _a = this.props, multiSelect = _a.multiSelect, hoisted = _a.hoisted;
if (multiSelect && index !== undefined && hoisted.selectedIndices &&
hoisted.currentOptions) {
var option = hoisted.currentOptions[index];
if (option && option.itemType ===
return hoisted.selectedIndices.length > 0 && !
this._isSelectAllChecked();
}
}
return false;
};
ComboBoxInternal.prototype._isSelectAllChecked = function (testIndices) {
var _a = this.props, multiSelect = _a.multiSelect, hoisted = _a.hoisted;
var selectAllOption = hoisted.currentOptions.find(function (option)
{ return option.itemType ===
SelectableOption_1.SelectableOptionMenuItemType.SelectAll; });
var selectedIndices = testIndices || hoisted.selectedIndices;
if (!multiSelect || !selectedIndices || !selectAllOption) {
return false;
}
// start by not including the select all option itself
var selectAllIndex = hoisted.currentOptions.indexOf(selectAllOption);
var compareSelectedIndices = selectedIndices.filter(function (value)
{ return value !== selectAllIndex; });
// get array of selectable options, excluding disabled options, headers,
and dividers
var selectableOptions = hoisted.currentOptions.filter(function (option) {
return !option.disabled && option.itemType !==
SelectableOption_1.SelectableOptionMenuItemType.SelectAll &&
isSelectableOption(option);
});
return compareSelectedIndices.length === selectableOptions.length;
};
/**
* Gets the pending selected index taking into account valueValidIndex and
selectedIndex
* @param includeCurrentPendingValue - Should we include the
currentPendingValue when
* finding the index
*/
ComboBoxInternal.prototype._getPendingSelectedIndex = function
(includeCurrentPendingValue) {
var _a = this.state, currentPendingValueValidIndex =
_a.currentPendingValueValidIndex, currentPendingValue = _a.currentPendingValue;
return currentPendingValueValidIndex >= 0 ||
(includeCurrentPendingValue && currentPendingValue !== null &&
currentPendingValue !== undefined)
? currentPendingValueValidIndex
: this.props.multiSelect
? 0
: this._getFirstSelectedIndex();
};
/**
* Scroll the selected element into view
*/
ComboBoxInternal.prototype._scrollIntoView = function () {
var _a = this.props, onScrollToItem = _a.onScrollToItem,
scrollSelectedToTop = _a.scrollSelectedToTop;
var currentPendingSelectedIndex = this._getPendingSelectedIndex(true);
if (onScrollToItem) {
// Use the custom scroll handler
onScrollToItem(currentPendingSelectedIndex >= 0 ?
currentPendingSelectedIndex : this._getFirstSelectedIndex());
return;
}
var scrollToElement = this._selectedElement.current;
// in multi-select there are multiple selected elements, so we use the
pending select index
// to locate the option to scroll to.
if (this.props.multiSelect && this._comboBoxMenu.current) {
scrollToElement = findFirstDescendant(this._comboBoxMenu.current,
function (element) {
var _a;
return ((_a = element.dataset) === null || _a === void 0 ? void 0 :
_a.index) === currentPendingSelectedIndex.toString();
});
}
if (scrollToElement && scrollToElement.offsetParent) {
var alignToTop = true;
// We are using refs, scroll the ref into view
if (this._comboBoxMenu.current &&
this._comboBoxMenu.current.offsetParent) {
var scrollableParent = this._comboBoxMenu.current.offsetParent;
var selectedElement = scrollToElement.offsetParent;
var _b = selectedElement, offsetHeight = _b.offsetHeight, offsetTop
= _b.offsetTop;
var _c = scrollableParent, parentOffsetHeight = _c.offsetHeight,
scrollTop = _c.scrollTop;
var isAbove = offsetTop < scrollTop;
var isBelow = offsetTop + offsetHeight > scrollTop +
parentOffsetHeight;
if (isAbove || scrollSelectedToTop) {
alignToTop = false;
scrollableParent.scrollTo(0, offsetTop);
}
else if (isBelow) {
scrollableParent.scrollTo(0, offsetTop - parentOffsetHeight +
offsetHeight);
}
}
// if _comboboxMenu doesn't exist, fall back to scrollIntoView
else {
scrollToElement.offsetParent.scrollIntoView(alignToTop);
}
}
};
/**
* Click handler for the menu items
* to select the item and also close the menu
* @param index - the index of the item that was clicked
*/
ComboBoxInternal.prototype._onItemClick = function (item) {
var _this = this;
var onItemClick = this.props.onItemClick;
var index = item.index;
// only close the callout when it's in single-select mode
// ensure that focus returns to the input, not the button
_this._autofill.current && _this._autofill.current.focus();
_this.setState({
isOpen: false,
});
}
// Continue processing the click only after
// performing menu close / control focus(inner working)
onItemClick && onItemClick(ev, item, index);
_this._setSelectedIndex(index, ev);
};
};
/**
* Reset the selected index by clearing the
* input (of any pending text), clearing the pending state,
* and setting the suggested display value to the last
* selected state text
*/
ComboBoxInternal.prototype._resetSelectedIndex = function () {
var selectedIndex = this._getFirstSelectedIndex();
if (selectedIndex > 0 && selectedIndex < currentOptions.length) {
this.props.hoisted.setSuggestedDisplayValue(currentOptions[selectedIndex].text);
}
else if (this.props.text) {
// If we had a value initially, restore it
this.props.hoisted.setSuggestedDisplayValue(this.props.text);
}
};
/**
* Clears the pending info state
*/
ComboBoxInternal.prototype._clearPendingInfo = function () {
this._processingClearPendingInfo = true;
this.props.hoisted.setSuggestedDisplayValue(undefined);
this.setState({
currentPendingValue: undefined,
currentPendingValueValidIndex: -1,
}, this._onAfterClearPendingInfo);
};
/**
* Set the pending info
* @param currentPendingValue - new pending value to set
* @param currentPendingValueValidIndex - new pending value index to set
* @param suggestedDisplayValue - new suggest display value to set
*/
ComboBoxInternal.prototype._setPendingInfo = function (currentPendingValue,
currentPendingValueValidIndex, suggestedDisplayValue) {
if (currentPendingValueValidIndex === void 0)
{ currentPendingValueValidIndex = -1; }
if (this._processingClearPendingInfo) {
return;
}
this.props.hoisted.setSuggestedDisplayValue(suggestedDisplayValue);
this.setState({
currentPendingValue: normalizeToString(currentPendingValue),
currentPendingValueValidIndex: currentPendingValueValidIndex,
});
};
/**
* Set the pending info from the given index
* @param index - the index to set the pending info from
*/
ComboBoxInternal.prototype._setPendingInfoFromIndex = function (index) {
if (index >= 0 && index < currentOptions.length) {
var option = currentOptions[index];
this._setPendingInfo(getPreviewText(option), index,
getPreviewText(option));
}
else {
}
};
/**
* Sets the pending info for the combo box
* @param index - the index to search from
* @param searchDirection - the direction to search
*/
ComboBoxInternal.prototype._setPendingInfoFromIndexAndDirection = function
(index, searchDirection) {
// update index to allow content to wrap
if (searchDirection === SearchDirection.forward && index >=
currentOptions.length - 1) {
index = -1;
}
else if (searchDirection === SearchDirection.backward && index <= 0) {
index = currentOptions.length;
}
// get the next "valid" index
var indexUpdate = this._getNextSelectableIndex(index, searchDirection);
// if the two indices are equal we didn't move and
// we should attempt to get get the first/last "valid" index to use
// (Note, this takes care of the potential cases where the first/last
// item is not focusable), otherwise use the updated index
if (index === indexUpdate) {
if (searchDirection === SearchDirection.forward) {
index = this._getNextSelectableIndex(-1, searchDirection);
}
else if (searchDirection === SearchDirection.backward) {
index = this._getNextSelectableIndex(currentOptions.length,
searchDirection);
}
}
else {
index = indexUpdate;
}
if (indexWithinBounds(currentOptions, index)) {
this._setPendingInfoFromIndex(index);
}
};
ComboBoxInternal.prototype._notifyPendingValueChanged = function (prevState) {
var onPendingValueChanged = this.props.onPendingValueChanged;
if (!onPendingValueChanged) {
return;
}
var _a = this.state, currentPendingValue = _a.currentPendingValue,
currentPendingValueValidIndex = _a.currentPendingValueValidIndex,
currentPendingValueValidIndexOnHover = _a.currentPendingValueValidIndexOnHover;
var newPendingIndex = undefined;
var newPendingValue = prevState.currentPendingValue;
if (currentPendingValueValidIndexOnHover !==
prevState.currentPendingValueValidIndexOnHover &&
indexWithinBounds(currentOptions,
currentPendingValueValidIndexOnHover)) {
// Set new pending index if hover index was changed
newPendingIndex = currentPendingValueValidIndexOnHover;
}
else if (currentPendingValueValidIndex !==
prevState.currentPendingValueValidIndex &&
indexWithinBounds(currentOptions, currentPendingValueValidIndex)) {
// Set new pending index if currentPendingValueValidIndex was changed
newPendingIndex = currentPendingValueValidIndex;
}
else if (currentPendingValue !== prevState.currentPendingValue) {
// Set pendingValue in the case it was changed and no index was changed
newPendingValue = currentPendingValue;
}
// Notify when there is a new pending index/value. Also, if there is a
pending value, it needs to send undefined.
if (newPendingIndex !== undefined || newPendingValue !== undefined ||
this._hasPendingValue) {
onPendingValueChanged(newPendingIndex !== undefined ?
currentOptions[newPendingIndex] : undefined, newPendingIndex, newPendingValue);
this._hasPendingValue = newPendingIndex !== undefined ||
newPendingValue !== undefined;
}
};
/**
* Sets the isOpen state and updates focusInputAfterClose
*/
ComboBoxInternal.prototype._setOpenStateAndFocusOnClose = function (isOpen,
focusInputAfterClose) {
this._focusInputAfterClose = focusInputAfterClose;
this.setState({
isOpen: isOpen,
});
};
ComboBoxInternal.prototype._onOptionMouseEnter = function (index) {
if (this._shouldIgnoreMouseEvent()) {
return;
}
this.setState({
currentPendingValueValidIndexOnHover: index,
});
};
ComboBoxInternal.prototype._onOptionMouseMove = function (index) {
this._gotMouseMove = true;
if (!this._isScrollIdle || this.state.currentPendingValueValidIndexOnHover
=== index) {
return;
}
this.setState({
currentPendingValueValidIndexOnHover: index,
});
};
ComboBoxInternal.prototype._shouldIgnoreMouseEvent = function () {
return !this._isScrollIdle || !this._gotMouseMove;
};
/**
* Handle dismissing the menu and eating the required key event when disabled
* @param ev - the keyboard event that was fired
*/
ComboBoxInternal.prototype._handleInputWhenDisabled = function (ev) {
// If we are disabled, close the menu (if needed)
// and eat all keystrokes other than TAB or ESC
if (this.props.disabled) {
if (this.state.isOpen) {
this.setState({ isOpen: false });
}
// When disabled stop propagation and prevent default
// of the event unless we have a tab, escape, or function key
if (ev !== null &&
ev.which !== Utilities_1.KeyCodes.tab &&
ev.which !== Utilities_1.KeyCodes.escape &&
(ev.which < 112 /* F1 */ || ev.which > 123) /* F12 */) {
}
}
};
ComboBoxInternal.prototype._handleTouchAndPointerEvent = function () {
var _this = this;
// If we already have an existing timeout from a previous touch and pointer
event
// cancel that timeout so we can set a nwe one.
if (this._lastTouchTimeoutId !== undefined) {
}
}, TouchIdleDelay);
};
/**
* Get the styles for the current option.
* @param item - Item props for the current option
*/
ComboBoxInternal.prototype._getCaretButtonStyles = function () {
var customCaretDownButtonStyles = this.props.caretDownButtonStyles;
return ComboBox_styles_1.getCaretDownButtonStyles(this.props.theme,
customCaretDownButtonStyles);
};
/**
* Get the styles for the current option.
* @param item - Item props for the current option
*/
ComboBoxInternal.prototype._getCurrentOptionStyles = function (item) {
var customStylesForAllOptions = this.props.comboBoxOptionStyles;
var customStylesForCurrentOption = item.styles;
return ComboBox_styles_1.getOptionStyles(this.props.theme,
customStylesForAllOptions, customStylesForCurrentOption,
this._isPendingOption(item), item.hidden, this._isOptionHighlighted(item.index));
};
/**
* Get the aria-activedescendant value for the combo box.
* @returns the id of the current focused combo item, otherwise the id of the
currently selected element,
* null otherwise
*/
ComboBoxInternal.prototype._getAriaActiveDescendantValue = function () {
var _a = this.state, isOpen = _a.isOpen, currentPendingValueValidIndex =
_a.currentPendingValueValidIndex;
var descendantText = isOpen && (selectedIndices === null || selectedIndices
=== void 0 ? void 0 : selectedIndices.length) ? this._id + '-list' +
selectedIndices[0] : undefined;
if (isOpen && this._hasFocus() && currentPendingValueValidIndex !== -1) {
descendantText = this._id + '-list' + currentPendingValueValidIndex;
}
return descendantText;
};
/**
* Get the aria autocomplete value for the combo box
* @returns 'inline' if auto-complete automatically dynamic, 'both' if we have
a list of possible values to pick from
* and can dynamically populate input, and 'list' if auto-complete is not
enabled as selection is the only option.
* Ideally, this should be 'none' if auto-complete is not enabled, but there is
a known bug in Edge
* where the callout may appear over the combo box if this attribute is set to
'none'
*/
ComboBoxInternal.prototype._getAriaAutoCompleteValue = function () {
var autoComplete = !this.props.disabled && this.props.autoComplete ===
'on';
return autoComplete ? (this.props.allowFreeform ? 'inline' : 'both') :
'list';
};
ComboBoxInternal.prototype._isPendingOption = function (item) {
return item && item.index === this.state.currentPendingValueValidIndex;
};
/**
* Returns true if the component has some kind of focus. If it's either
focusing or if it's focused
*/
ComboBoxInternal.prototype._hasFocus = function () {
return this.state.focusState !== 'none';
};
ComboBoxInternal = tslib_1.__decorate([
Utilities_1.customizable('ComboBox', ['theme', 'styles'], true)
], ComboBoxInternal);
return ComboBoxInternal;
/**
* Get the indices of the options that are marked as selected
* @param options - the combo box options
* @param selectedKeys - the known selected keys to find
* @returns - an array of the indices of the selected options, empty array if
nothing is selected
*/
function getSelectedIndices(options, selectedKeys) {
if (!options || !selectedKeys) {
return [];
}
var selectedIndices = {};
options.forEach(function (option, index) {
if (option.selected) {
selectedIndices[index] = true;
}
});
var _loop_1 = function (selectedKey) {
var index = Utilities_1.findIndex(options, function (option) { return
option.key === selectedKey; });
if (index > -1) {
selectedIndices[index] = true;
}
};
for (var _i = 0, selectedKeys_1 = selectedKeys; _i < selectedKeys_1.length; _i+
+) {
var selectedKey = selectedKeys_1[_i];
_loop_1(selectedKey);
}
return Object.keys(selectedIndices).map(Number).sort();
}
/**
* Given default selected key(s) and selected key(s), return the selected keys(s).
* When default selected key(s) are available, they take precedence and return them
instead of selected key(s).
*
* @returns No matter what specific types the input parameters are, always return
an array of
* either strings or numbers instead of primitive type. This normalization makes
caller's logic easier.
*/
function buildDefaultSelectedKeys(defaultSelectedKey, selectedKey) {
var selectedKeys = buildSelectedKeys(defaultSelectedKey);
if (selectedKeys.length) {
return selectedKeys;
}
return buildSelectedKeys(selectedKey);
}
function buildSelectedKeys(selectedKey) {
if (selectedKey === undefined) {
return [];
}
// need to cast here so typescript does not complain
return (selectedKey instanceof Array ? selectedKey : [selectedKey]);
}
function normalizeToString(value) {
return value || '';
}
/**
* Is the index within the bounds of the array?
* @param options - options to check if the index is valid for
* @param index - the index to check
* @returns - true if the index is valid for the given options, false otherwise
*/
function indexWithinBounds(options, index) {
return !!options && index >= 0 && index < options.length;
}
/** Whether this is a normal option, not a header or divider or select all. */
function isNormalOption(option) {
return (option.itemType !==
SelectableOption_1.SelectableOptionMenuItemType.Header &&
option.itemType !== SelectableOption_1.SelectableOptionMenuItemType.Divider
&&
option.itemType !==
SelectableOption_1.SelectableOptionMenuItemType.SelectAll);
}
/** Whether this is a selectable option, not a header or divider. */
function isSelectableOption(option) {
return (option.itemType !==
SelectableOption_1.SelectableOptionMenuItemType.Header && option.itemType !==
SelectableOption_1.SelectableOptionMenuItemType.Divider);
}
/**
* For scenarios where the option's `text` prop contains embedded styles, we use
the option's
* àriaLabel` value as the text in the input and for autocomplete matching. We
know to use this
* when the ùseAriaLabelAsText` prop is set to true.
*/
function getPreviewText(item) {
return item.useAriaLabelAsText && item.ariaLabel ? item.ariaLabel : item.text;
}
/**
* Returns true if the key for the event is alt (Mac option) or meta (Mac command).
*/
function isAltOrMeta(ev) {
return ev.which === Utilities_1.KeyCodes.alt || ev.key === 'Meta';
}
//# sourceMappingURL=ComboBox.js.map
/***/ }),
/***/ 11092:
"use strict";
var _a, _b;

exports.getStyles = exports.getCaretDownButtonStyles = exports.getOptionStyles =
void 0;
var ComboBoxHeight = 32;
var ComboBoxLineHeight = 30;
var ComboBoxCaretDownWidth = 32;
var ComboBoxOptionHeight = 36;
var getDisabledStyles = Utilities_1.memoizeFunction(function (theme) {
var _a;
var semanticColors = theme.semanticColors;
return {
backgroundColor: semanticColors.disabledBackground,
color: semanticColors.disabledText,
cursor: 'default',
selectors: (_a = {
':after': {
borderColor: semanticColors.disabledBackground,
}
},
color: 'GrayText',
selectors: {
':after': {
},
},
},
_a),
};
});
var listOptionHighContrastStyles = {
_a[Styling_1.HighContrastSelector] = tslib_1.__assign({ backgroundColor:
'Highlight', borderColor: 'Highlight', color: 'HighlightText' },
_a),
};
var inputHighContrastStyles = {
_b[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'WindowText', backgroundColor: 'Window' },
_b),
};
exports.getOptionStyles = Utilities_1.memoizeFunction(function (theme,
customStylesForAllOptions, customOptionStylesForCurrentOption, isPending, isHidden,
isSelected) {
var _a;
var option = {
textHoveredColor: semanticColors.menuItemTextHovered,
textSelectedColor: palette.neutralDark,
textDisabledColor: semanticColors.disabledText,
backgroundHoveredColor: semanticColors.menuItemBackgroundHovered,
backgroundPressedColor: semanticColors.menuItemBackgroundPressed,
};
var optionStyles = {
root: [
theme.fonts.medium,
{
backgroundColor: isPending ? option.backgroundHoveredColor :
'transparent',
cursor: 'pointer',
display: isHidden ? 'none' : 'block',
width: '100%',
height: 'auto',
minHeight: ComboBoxOptionHeight,
lineHeight: '20px',
padding: '0 8px',
borderWidth: '1px',
borderRadius: 0,
wordWrap: 'break-word',
overflowWrap: 'break-word',
textAlign: 'left',
selectors: tslib_1.__assign(tslib_1.__assign((_a = {},
border: 'none',
borderColor: 'Background',
}, _a), (!isHidden && {
'&.ms-Checkbox': {
display: 'flex',
},
})), { '&.ms-Button--command:hover:active': {
backgroundColor: option.backgroundPressedColor,
}, '.ms-Checkbox-label': {
width: '100%',
} }),
},
isSelected
? [
{
color: option.textSelectedColor,
selectors: {
':hover': [
{
backgroundColor: option.backgroundHoveredColor,
},
listOptionHighContrastStyles,
],
},
},
Styling_1.getFocusStyle(theme, { inset: -1, isFocusedOnly:
false }),
listOptionHighContrastStyles,
]
: [],
],
rootHovered: {
color: option.textHoveredColor,
},
rootFocused: {
},
rootDisabled: {
color: option.textDisabledColor,
cursor: 'default',
},
optionText: {
overflow: 'hidden',
minWidth: '0px',
maxWidth: '100%',
},
optionTextWrapper: {
maxWidth: '100%',
display: 'flex',
},
};
return Styling_1.concatStyleSets(optionStyles, customStylesForAllOptions,
customOptionStylesForCurrentOption);
});
exports.getCaretDownButtonStyles = Utilities_1.memoizeFunction(function (theme,
customStyles) {
var _a, _b;
var semanticColors = theme.semanticColors, fonts = theme.fonts;
var caret = {
buttonTextColor: semanticColors.bodySubtext,
buttonTextHoveredCheckedColor: semanticColors.buttonTextChecked,
buttonBackgroundHoveredColor: semanticColors.listItemBackgroundHovered,
buttonBackgroundCheckedColor: semanticColors.listItemBackgroundChecked,
buttonBackgroundCheckedHoveredColor:
semanticColors.listItemBackgroundCheckedHovered,
};
var buttonHighContrastStyles = {
tslib_1.__assign({ backgroundColor: 'Highlight', borderColor: 'Highlight', color:
'HighlightText' }, Styling_1.getHighContrastNoAdjustStyle()),
_a),
};
var styles = {
root: {
color: caret.buttonTextColor,
top: 0,
height: '100%',
lineHeight: ComboBoxLineHeight,
width: ComboBoxCaretDownWidth,
cursor: 'default',
_b[Styling_1.HighContrastSelector] =
tslib_1.__assign({ backgroundColor: 'ButtonFace', borderColor: 'ButtonText', color:
'ButtonText' }, Styling_1.getHighContrastNoAdjustStyle()),
_b),
},
icon: {
},
rootHovered: [
{
backgroundColor: caret.buttonBackgroundHoveredColor,
color: caret.buttonTextHoveredCheckedColor,
cursor: 'pointer',
},
buttonHighContrastStyles,
],
rootPressed: [
{
backgroundColor: caret.buttonBackgroundCheckedColor,
},
],
rootChecked: [
{
backgroundColor: caret.buttonBackgroundCheckedColor,
},
],
rootCheckedHovered: [
{
backgroundColor: caret.buttonBackgroundCheckedHoveredColor,
},
],
rootDisabled: [
getDisabledStyles(theme),
{
},
],
};
return Styling_1.concatStyleSets(styles, customStyles);
});
comboBoxOptionWidth) {
var _a, _b, _c, _d, _e, _f;
var semanticColors = theme.semanticColors, fonts = theme.fonts, effects =
theme.effects;
var root = {
textColor: semanticColors.inputText,
borderColor: semanticColors.inputBorder,
borderHoveredColor: semanticColors.inputBorderHovered,
borderPressedColor: semanticColors.inputFocusBorderAlt,
borderFocusedColor: semanticColors.inputFocusBorderAlt,
backgroundColor: semanticColors.inputBackground,
erroredColor: semanticColors.errorText,
};
var option = {
headerTextColor: semanticColors.menuHeader,
dividerBorderColor: semanticColors.bodyDivider,
};
// placeholder style variables
var placeholderHighContrastStyles = {
color: 'GrayText',
},
_a),
};
var placeholderStyles = [
{
color: semanticColors.inputPlaceholderText,
},
placeholderHighContrastStyles,
];
var placeholderStylesHovered = [
{
color: semanticColors.inputTextHovered,
},
];
var disabledPlaceholderStyles = [
{
},
];
var ComboBoxRootHighContrastFocused =
tslib_1.__assign(tslib_1.__assign({ color: 'HighlightText', backgroundColor:
'Window' }, Styling_1.getHighContrastNoAdjustStyle()), { selectors: {
':after': {
},
} });
var focusBorderStyles = Styling_1.getInputFocusStyle(root.borderPressedColor,
effects.roundedCorner2, 'border', 0);
var styles = {
container: {},
label: {},
labelDisabled: {},
root: [
theme.fonts.medium,
{
boxShadow: 'none',
marginLeft: '0',
paddingRight: ComboBoxCaretDownWidth,
paddingLeft: 9,
color: root.textColor,
outline: '0',
userSelect: 'none',
backgroundColor: root.backgroundColor,
cursor: 'text',
display: 'block',
height: ComboBoxHeight,
selectors: {
'.ms-Label': {
marginBottom: '8px',
},
'&.is-open': {
ComboBoxRootHighContrastFocused,
_b),
},
// setting border using pseudo-element here in order to
// prevent chevron button to overlap ComboBox border under
certain resolutions
':after': {
content: "''",
left: 0,
top: 0,
bottom: 0,
right: 0,
borderWidth: '1px',
borderColor: root.borderColor,
},
},
},
],
rootHovered: {
selectors: (_c = {
':after': {
borderColor: root.borderHoveredColor,
},
'.ms-ComboBox-Input': [
{
},
Styling_1.getPlaceholderStyles(placeholderStylesHovered),
inputHighContrastStyles,
]
},
_c[Styling_1.HighContrastSelector] =
tslib_1.__assign(tslib_1.__assign({ color: 'HighlightText', backgroundColor:
'Window' }, Styling_1.getHighContrastNoAdjustStyle()), { selectors: {
':after': {
},
} }),
_c),
},
rootPressed: [
{
_d[Styling_1.HighContrastSelector] =
_d),
},
],
rootFocused: [
{
selectors: (_e = {
'.ms-ComboBox-Input': [
{
},
]
},
_e),
},
focusBorderStyles,
],
rootDisabled: getDisabledStyles(theme),
rootError: {
selectors: {
':after': {
borderColor: root.erroredColor,
},
':hover:after': {
borderColor: semanticColors.inputBorderHovered,
},
},
},
rootDisallowFreeForm: {},
input: [
Styling_1.getPlaceholderStyles(placeholderStyles),
{
backgroundColor: root.backgroundColor,
color: root.textColor,
width: '100%',
height: '100%',
outline: 'none',
font: 'inherit',
padding: '0',
selectors: {
'::-ms-clear': {
display: 'none',
},
},
},
],
inputDisabled: [getDisabledStyles(theme),
Styling_1.getPlaceholderStyles(disabledPlaceholderStyles)],
errorMessage: [
theme.fonts.small,
{
color: root.erroredColor,
marginTop: '5px',
},
],
callout: {
},
optionsContainerWrapper: {
width: comboBoxOptionWidth,
},
optionsContainer: {
display: 'block',
},
header: [
fonts.medium,
{
color: option.headerTextColor,
backgroundColor: 'none',
height: ComboBoxOptionHeight,
lineHeight: ComboBoxOptionHeight,
cursor: 'default',
padding: '0 8px',
userSelect: 'none',
textAlign: 'left',
_f[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
'GrayText' }, Styling_1.getHighContrastNoAdjustStyle()),
_f),
},
],
divider: {
height: 1,
backgroundColor: option.dividerBorderColor,
},
};
return Styling_1.concatStyleSets(styles, customStyles);
});
//# sourceMappingURL=ComboBox.styles.js.map
/***/ }),
/***/ 7735:
"use strict";

//# sourceMappingURL=ComboBox.types.js.map
/***/ }),
/***/ 30381:
"use strict";

exports.VirtualizedComboBox = void 0;
var ComboBox_1 = __webpack_require__(90912);
var List_1 = __webpack_require__(80618);
var VirtualizedComboBox = /** @class */ (function (_super) {
tslib_1.__extends(VirtualizedComboBox, _super);
function VirtualizedComboBox(props) {
/** The combo box element */
_this._comboBox = React.createRef();
/** The virtualized list element */
_this._list = React.createRef();
var id = props.id, onRenderItem = props.onRenderItem;
// Render virtualized list
return (React.createElement(List_1.List, { componentRef: _this._list,
role: "listbox", id: id + "-list", "aria-labelledby": id + "-label", items:
props.options,
onRenderCell: onRenderItem ? function (item) { return
onRenderItem(item); } : function () { return null; } }));
};
_this._onScrollToItem = function (itemIndex) {
// We are using the List component, call scrollToIndex
_this._list.current && _this._list.current.scrollToIndex(itemIndex);
};
return _this;
}
Object.defineProperty(VirtualizedComboBox.prototype, "selectedOptions", {
/**
*/
get: function () {
if (this._comboBox.current) {
return this._comboBox.current.selectedOptions;
}
return [];
},
enumerable: false,
configurable: true
});
VirtualizedComboBox.prototype.dismissMenu = function () {
return this._comboBox.current.dismissMenu();
}
};
VirtualizedComboBox.prototype.focus = function (shouldOpenOnFocus,
useFocusAsync) {
this._comboBox.current.focus(shouldOpenOnFocus, useFocusAsync);
return true;
}
return false;
};
VirtualizedComboBox.prototype.render = function () {
return (React.createElement(ComboBox_1.ComboBox, tslib_1.__assign({},
this.props, { componentRef: this._comboBox, onRenderList: this._onRenderList,
onScrollToItem: this._onScrollToItem })));
};
return VirtualizedComboBox;
exports.VirtualizedComboBox = VirtualizedComboBox;
//# sourceMappingURL=VirtualizedComboBox.js.map
/***/ }),
/***/ 12495:
"use strict";

/***/ }),
/***/ 71290:
"use strict";

exports.CommandBarBase = void 0;
var OverflowSet_1 = __webpack_require__(65941);
var ResizeGroup_1 = __webpack_require__(93418);
var CommandBar_styles_1 = __webpack_require__(83228);
var CommandBarBase = /** @class */ (function (_super) {
tslib_1.__extends(CommandBarBase, _super);
function CommandBarBase(props) {
_this._overflowSet = React.createRef();
_this._resizeGroup = React.createRef();
_this._onRenderData = function (data) {
var _a = _this.props, ariaLabel = _a.ariaLabel, primaryGroupAriaLabel =
_a.primaryGroupAriaLabel, farItemsGroupAriaLabel = _a.farItemsGroupAriaLabel;
var hasSecondSet = data.farItems && data.farItems.length > 0;
return (React.createElement(FocusZone_1.FocusZone, { className:
Utilities_1.css(_this._classNames.root), direction:
FocusZone_1.FocusZoneDirection.horizontal, role: 'menubar', "aria-label": ariaLabel
},
React.createElement(OverflowSet_1.OverflowSet, { role: hasSecondSet
? 'group' : 'none', "aria-label": hasSecondSet ? primaryGroupAriaLabel : undefined,
componentRef: _this._overflowSet, className:
Utilities_1.css(_this._classNames.primarySet), items: data.primaryItems,
overflowItems: data.overflowItems.length ? data.overflowItems : undefined,
onRenderItem: _this._onRenderItem, onRenderOverflowButton:
_this._onRenderOverflowButton }),
hasSecondSet && (React.createElement(OverflowSet_1.OverflowSet,
{ role: "group", "aria-label": farItemsGroupAriaLabel, className:
Utilities_1.css(_this._classNames.secondarySet), items: data.farItems,
onRenderItem: _this._onRenderItem, onRenderOverflowButton:
Utilities_1.nullRender }))));
};
// These are the top level items, there is no relevant menu
dismissing function to
// provide for the IContextualMenuItem onRender function. Pass in a
no op function instead.
return item.onRender(item, function () { return undefined; });
}
var itemText = item.text || item.name;
var commandButtonProps =
tslib_1.__assign(tslib_1.__assign({ allowDisabledFocus: true, role: 'menuitem' },
item), { styles: CommandBar_styles_1.getCommandButtonStyles(item.buttonStyles),
className: Utilities_1.css('ms-CommandBarItem-link', item.className), text: !
item.iconOnly ? itemText : undefined, menuProps: item.subMenuProps, onClick:
_this._onButtonClick(item) });
if (item.iconOnly && (itemText !== undefined || item.tooltipHostProps))
{
return (React.createElement(Tooltip_1.TooltipHost,
tslib_1.__assign({ role: "none", content: itemText, setAriaDescribedBy: false },
item.tooltipHostProps), _this._commandButton(item, commandButtonProps)));
}
return _this._commandButton(item, commandButtonProps);
};
_this._commandButton = function (item, props) {
var ButtonAs = _this.props.buttonAs;
var CommandBarButtonAs = item.commandBarButtonAs;
var DefaultButtonAs = Button_1.CommandBarButton;
// The prop types between these three possible implementations overlap
enough that a force-cast is safe.
var Type = DefaultButtonAs;
if (CommandBarButtonAs) {
Type = Utilities_1.composeComponentAs(CommandBarButtonAs, Type);
}
if (ButtonAs) {
Type = Utilities_1.composeComponentAs(ButtonAs, Type);
}
// Always pass the default implementation to the override so it may be
composed.
return React.createElement(Type, tslib_1.__assign({}, props));
};
_this._onRenderOverflowButton = function (overflowItems) {
var _a = _this.props.overflowButtonProps, overflowButtonProps = _a ===
void 0 ? {} : _a;
var combinedOverflowItems =
tslib_1.__spreadArray(tslib_1.__spreadArray([], (overflowButtonProps.menuProps ?
overflowButtonProps.menuProps.items : [])), overflowItems);
var overflowProps = tslib_1.__assign(tslib_1.__assign({ role:
'menuitem' }, overflowButtonProps), { styles: tslib_1.__assign({ menuIcon:
{ fontSize: '17px' } }, overflowButtonProps.styles), className:
Utilities_1.css('ms-CommandBar-overflowButton', overflowButtonProps.className),
menuProps: tslib_1.__assign(tslib_1.__assign({}, overflowButtonProps.menuProps),
{ items: combinedOverflowItems }), menuIconProps: tslib_1.__assign({ iconName:
'More' }, overflowButtonProps.menuIconProps) });
var OverflowButtonType = _this.props.overflowButtonAs
? Utilities_1.composeComponentAs(_this.props.overflowButtonAs,
Button_1.CommandBarButton)
: Button_1.CommandBarButton;
return React.createElement(OverflowButtonType, tslib_1.__assign({},
overflowProps));
};
_this._onReduceData = function (data) {
var _a = _this.props, shiftOnReduce = _a.shiftOnReduce, onDataReduced =
_a.onDataReduced;
var primaryItems = data.primaryItems, overflowItems =
data.overflowItems, cacheKey = data.cacheKey;
// Use first item if shiftOnReduce, otherwise use last item
var movedItem = primaryItems[shiftOnReduce ? 0 : primaryItems.length -
1];
if (movedItem !== undefined) {
movedItem.renderedInOverflow = true;
overflowItems = tslib_1.__spreadArray([movedItem], overflowItems);
primaryItems = shiftOnReduce ? primaryItems.slice(1) :
primaryItems.slice(0, -1);
var newData = tslib_1.__assign(tslib_1.__assign({}, data),
{ primaryItems: primaryItems, overflowItems: overflowItems });
cacheKey = _this._computeCacheKey({ primaryItems: primaryItems,
overflow: overflowItems.length > 0 });
if (onDataReduced) {
onDataReduced(movedItem);
}
newData.cacheKey = cacheKey;
return newData;
}
return undefined;
};
_this._onGrowData = function (data) {
var _a = _this.props, shiftOnReduce = _a.shiftOnReduce, onDataGrown =
_a.onDataGrown;
var minimumOverflowItems = data.minimumOverflowItems;
var primaryItems = data.primaryItems, overflowItems =
data.overflowItems, cacheKey = data.cacheKey;
var movedItem = overflowItems[0];
// Make sure that moved item exists and is not one of the original
overflow items
if (movedItem !== undefined && overflowItems.length >
minimumOverflowItems) {
movedItem.renderedInOverflow = false;
overflowItems = overflowItems.slice(1);
// if shiftOnReduce, movedItem goes first, otherwise, last.
primaryItems = shiftOnReduce ? tslib_1.__spreadArray([movedItem],
primaryItems) : tslib_1.__spreadArray(tslib_1.__spreadArray([], primaryItems),
[movedItem]);
var newData = tslib_1.__assign(tslib_1.__assign({}, data),
{ primaryItems: primaryItems, overflowItems: overflowItems });
cacheKey = _this._computeCacheKey({ primaryItems: primaryItems,
overflow: overflowItems.length > 0 });
if (onDataGrown) {
onDataGrown(movedItem);
}
newData.cacheKey = cacheKey;
return newData;
}
return undefined;
};
return _this;
}
CommandBarBase.prototype.render = function () {
var _a = this.props, items = _a.items, overflowItems = _a.overflowItems,
farItems = _a.farItems, styles = _a.styles, theme = _a.theme, dataDidRender =
_a.dataDidRender, _b = _a.onReduceData, onReduceData = _b === void 0 ?
this._onReduceData : _b, _c = _a.onGrowData, onGrowData = _c === void 0 ?
this._onGrowData : _c, _d = _a.resizeGroupAs, ResizeGroupAs = _d === void 0 ?
ResizeGroup_1.ResizeGroup : _d;
var commandBarData = {
primaryItems: tslib_1.__spreadArray([], items),
overflowItems: tslib_1.__spreadArray([], overflowItems),
minimumOverflowItems: tslib_1.__spreadArray([], overflowItems).length,
farItems: farItems,
cacheKey: this._computeCacheKey({
primaryItems: tslib_1.__spreadArray([], items),
overflow: overflowItems && overflowItems.length > 0,
}),
};
this._classNames = getClassNames(styles, { theme: theme });
// ResizeGroup will render these attributes to the root <div>.
// TODO We may need to elevate classNames from <FocusZone> into
<ResizeGroup> ?
Utilities_1.divProperties);
return (React.createElement(ResizeGroupAs, tslib_1.__assign({},
nativeProps, { componentRef: this._resizeGroup, data: commandBarData, onReduceData:
onReduceData, onGrowData: onGrowData, onRenderData: this._onRenderData,
dataDidRender: dataDidRender })));
};
CommandBarBase.prototype.focus = function () {
var overflowSet = this._overflowSet.current;
overflowSet && overflowSet.focus();
};
CommandBarBase.prototype.remeasure = function () {
this._resizeGroup.current && this._resizeGroup.current.remeasure();
};
CommandBarBase.prototype._onButtonClick = function (item) {
// inactive is deprecated. remove check in 7.0
if (item.inactive) {
return;
}
if (item.onClick) {
item.onClick(ev, item);
}
};
};
CommandBarBase.prototype._computeCacheKey = function (data) {
var primaryItems = data.primaryItems, overflow = data.overflow;
var returnKey = function (acc, current) {
var _a = current.cacheKey, cacheKey = _a === void 0 ? current.key : _a;
return acc + cacheKey;
};
var primaryKey = primaryItems && primaryItems.reduce(returnKey, '');
var overflowKey = overflow ? 'overflow' : '';
return [primaryKey, overflowKey].join('');
};
CommandBarBase.defaultProps = {
items: [],
overflowItems: [],
};
return CommandBarBase;
exports.CommandBarBase = CommandBarBase;
//# sourceMappingURL=CommandBar.base.js.map
/***/ }),
/***/ 90582:
"use strict";

exports.CommandBar = void 0;
var CommandBar_base_1 = __webpack_require__(71290);
var CommandBar_styles_1 = __webpack_require__(83228);
// Create a CommandBar variant which uses these default styles and this styled
subcomponent.
exports.CommandBar = Utilities_1.styled(CommandBar_base_1.CommandBarBase,
CommandBar_styles_1.getStyles, undefined, {
scope: 'CommandBar',
});
//# sourceMappingURL=CommandBar.js.map
/***/ }),
/***/ 83228:
"use strict";

exports.getCommandButtonStyles = exports.getStyles = void 0;
var COMMAND_BAR_HEIGHT = 44;
return {
root: [
theme.fonts.medium,
'ms-CommandBar',
{
display: 'flex',
backgroundColor: semanticColors.bodyBackground,
padding: '0 14px 0 24px',
height: COMMAND_BAR_HEIGHT,
},
className,
],
primarySet: [
'ms-CommandBar-primaryCommand',
{
flexGrow: '1',
display: 'flex',
},
],
secondarySet: [
'ms-CommandBar-secondaryCommand',
{
flexShrink: '0',
display: 'flex',
},
],
};
};
exports.getCommandButtonStyles = Utilities_1.memoizeFunction(function
(customStyles) {
var rootStyles = {
height: '100%',
};
var labelStyles = {
};
var _a = customStyles || {}, root = _a.root, label = _a.label, restCustomStyles
= tslib_1.__rest(_a, ["root", "label"]);
return tslib_1.__assign(tslib_1.__assign({}, restCustomStyles), { root: root ?
[rootStyles, root] : rootStyles, label: label ? [labelStyles, label] :
labelStyles });
});
//# sourceMappingURL=CommandBar.styles.js.map
/***/ }),
/***/ 93216:
"use strict";

//# sourceMappingURL=CommandBar.types.js.map
/***/ }),
/***/ 45515:
"use strict";

/***/ }),
/***/ 6667:
"use strict";

exports.ContextualMenuBase = exports.canAnyMenuItemsCheck = exports.getSubmenuItems
= void 0;
var ContextualMenu_types_1 = __webpack_require__(54177);
var ContextualMenuItem_1 = __webpack_require__(28670);
var ContextualMenu_classNames_1 = __webpack_require__(74867);
var ResponsiveMode_1 = __webpack_require__(46395);
var getContextualMenuItemClassNames = Utilities_1.classNamesFunction();
// The default ContextualMenu properties have no items and beak, the default
submenu direction is right and top.
items: [],
shouldFocusOnMount: true,
gapSpace: 0,
beakWidth: 16,
};
function getSubmenuItems(item, options) {
var target = options === null || options === void 0 ? void 0 : options.target;
var items = item.subMenuProps ? item.subMenuProps.items : item.items;
if (items) {
var overrideItems = [];
for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
var subItem = items_1[_i];
if (subItem.preferMenuTargetAsEventTarget) {
// For sub-items which need an overridden target, intercept
ònClick`
var onClick = subItem.onClick, contextItem =
tslib_1.__rest(subItem, ["onClick"]);
overrideItems.push(tslib_1.__assign(tslib_1.__assign({},
contextItem), { onClick: getOnClickWithOverrideTarget(onClick, target) }));
}
else {
overrideItems.push(subItem);
}
}
return overrideItems;
}
}
exports.getSubmenuItems = getSubmenuItems;
/**
* Returns true if a list of menu items can contain a checkbox
*/
function canAnyMenuItemsCheck(items) {
return items.some(function (item) {
if (item.canCheck) {
return true;
}
// If the item is a section, check if any of the items in the section can
check.
if (item.sectionProps && item.sectionProps.items.some(function
(submenuItem) { return submenuItem.canCheck === true; })) {
return true;
}
return false;
});
}
exports.canAnyMenuItemsCheck = canAnyMenuItemsCheck;
var NavigationIdleDelay = 250; /* ms */
var COMPONENT_NAME = 'ContextualMenu';
var _getMenuItemStylesFunction = Utilities_1.memoizeFunction(function () {
var styles = [];
styles[_i] = arguments[_i];
}
return function (styleProps) {
return Styling_1.concatStyleSetsWithProps.apply(void 0,
tslib_1.__spreadArray([styleProps, ContextualMenu_classNames_1.getItemStyles],
styles));
};
});
//#region Custom hooks
function useVisibility(props, targetWindow) {
var _a = props.hidden, hidden = _a === void 0 ? false : _a, onMenuDismissed =
props.onMenuDismissed, onMenuOpened = props.onMenuOpened;
var previousHidden = react_hooks_1.usePrevious(hidden);
var onMenuOpenedRef = React.useRef(onMenuOpened);
var onMenuClosedRef = React.useRef(onMenuDismissed);
var propsRef = React.useRef(props);
onMenuOpenedRef.current = onMenuOpened;
onMenuClosedRef.current = onMenuDismissed;
propsRef.current = props;
var _a, _b;
// Don't issue dismissed callbacks on initial mount
if (hidden && previousHidden === false) {
(_a = onMenuClosedRef.current) === null || _a === void 0 ? void 0 :
_a.call(onMenuClosedRef, propsRef.current);
}
else if (!hidden && previousHidden !== false) {
(_b = onMenuOpenedRef.current) === null || _b === void 0 ? void 0 :
_b.call(onMenuOpenedRef, propsRef.current);
}
}, [hidden, previousHidden]);
// Issue onDismissedCallback on unmount
React.useEffect(function () { return function () { var _a; return (_a =
onMenuClosedRef.current) === null || _a === void 0 ? void 0 :
_a.call(onMenuClosedRef, propsRef.current); }; }, []);
}
function useSubMenuState(_a, dismiss) {
var hidden = _a.hidden, items = _a.items, theme = _a.theme, className =
_a.className, id = _a.id, menuTarget = _a.target;
var _b = React.useState(), expandedMenuItemKey = _b[0], setExpandedMenuItemKey
= _b[1];
var _c = React.useState(), submenuTarget = _c[0], setSubmenuTarget = _c[1];
/** True if the menu was expanded by mouse click OR hover (as opposed to by
keyboard) */
var _d = React.useState(), shouldFocusOnContainer = _d[0],
setShouldFocusOnContainer = _d[1];
var subMenuId = react_hooks_1.useId(COMPONENT_NAME, id);
var closeSubMenu = React.useCallback(function () {
setShouldFocusOnContainer(undefined);
setExpandedMenuItemKey(undefined);
setSubmenuTarget(undefined);
}, []);
var openSubMenu = React.useCallback(function (_a, target, focusContainer) {
var submenuItemKey = _a.key;
if (expandedMenuItemKey === submenuItemKey) {
return;
}
target.focus();
setShouldFocusOnContainer(focusContainer);
setExpandedMenuItemKey(submenuItemKey);
setSubmenuTarget(target);
}, [expandedMenuItemKey]);
if (hidden) {
closeSubMenu();
}
}, [hidden, closeSubMenu]);
var onSubMenuDismiss = useOnSubmenuDismiss(dismiss, closeSubMenu);
var getSubmenuProps = function () {
var item = findItemByKeyFromItems(expandedMenuItemKey, items);
var submenuProps = null;
if (item) {
submenuProps = {
items: getSubmenuItems(item, { target: menuTarget }),
target: submenuTarget,
onDismiss: onSubMenuDismiss,
isSubMenu: true,
id: subMenuId,
shouldFocusOnMount: true,
shouldFocusOnContainer: shouldFocusOnContainer,
directionalHint: Utilities_1.getRTL(theme) ?
DirectionalHint_1.DirectionalHint.leftTopEdge :
DirectionalHint_1.DirectionalHint.rightTopEdge,
gapSpace: 0,
isBeakVisible: false,
};
if (item.subMenuProps) {
Utilities_1.assign(submenuProps, item.subMenuProps);
}
if (item.preferMenuTargetAsEventTarget) {
var onItemClick = item.onItemClick;
submenuProps.onItemClick =
getOnClickWithOverrideTarget(onItemClick, menuTarget);
}
}
return submenuProps;
};
return [expandedMenuItemKey, openSubMenu, getSubmenuProps, onSubMenuDismiss];
}
function useShouldUpdateFocusOnMouseMove(_a) {
var delayUpdateFocusOnHover = _a.delayUpdateFocusOnHover, hidden = _a.hidden;
var shouldUpdateFocusOnMouseEvent = React.useRef(!delayUpdateFocusOnHover);
var gotMouseMove = React.useRef(false);
shouldUpdateFocusOnMouseEvent.current = !delayUpdateFocusOnHover;
gotMouseMove.current = hidden ? false : !delayUpdateFocusOnHover &&
gotMouseMove.current;
}, [delayUpdateFocusOnHover, hidden]);
var onMenuFocusCapture = React.useCallback(function () {
if (delayUpdateFocusOnHover) {
shouldUpdateFocusOnMouseEvent.current = false;
}
}, [delayUpdateFocusOnHover]);
return [shouldUpdateFocusOnMouseEvent, gotMouseMove, onMenuFocusCapture];
}
function usePreviousActiveElement(_a, targetWindow) {
var hidden = _a.hidden, onRestoreFocus = _a.onRestoreFocus;
var previousActiveElement = React.useRef();
var tryFocusPreviousActiveElement = React.useCallback(function (options) {
var _a, _b;
if (onRestoreFocus) {
onRestoreFocus(options);
}
else if (options === null || options === void 0 ? void 0 :
options.documentContainsFocus) {
// Make sure that the focus method actually exists
// In some cases the object might exist but not be a real element.
// This is primarily for IE 11 and should be removed once IE 11 is no
longer in use.
(_b = (_a = previousActiveElement.current) === null || _a === void 0 ?
void 0 : _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
}
}, [onRestoreFocus]);
react_hooks_1.useIsomorphicLayoutEffect(function () {
var _a;
if (!hidden) {
previousActiveElement.current = targetWindow === null || targetWindow
=== void 0 ? void 0 : targetWindow.document.activeElement;
}
else if (previousActiveElement.current) {
tryFocusPreviousActiveElement({
originalElement: previousActiveElement.current,
containsFocus: true,
documentContainsFocus: ((_a = Utilities_1.getDocument()) === null
|| _a === void 0 ? void 0 : _a.hasFocus()) || false,
});
previousActiveElement.current = undefined;
}
}, [hidden, targetWindow === null || targetWindow === void 0 ? void 0 :
targetWindow.document.activeElement, tryFocusPreviousActiveElement]);
return [tryFocusPreviousActiveElement];
}
function useKeyHandlers(_a, dismiss, hostElement, openSubMenu) {
var theme = _a.theme, isSubMenu = _a.isSubMenu, _b = _a.focusZoneProps, _c = _b
=== void 0 ? {} : _b, checkForNoWrap = _c.checkForNoWrap, _d = _c.direction,
focusZoneDirection = _d === void 0 ? FocusZone_1.FocusZoneDirection.vertical : _d;
/** True if the most recent keydown event was for alt (option) or meta
(command). */
var lastKeyDownWasAltOrMeta = React.useRef();
/**
* Calls `shouldHandleKey` to determine whether the keyboard event should be
handled;
* if so, stops event propagation and dismisses menu(s).
* @param ev - The keyboard event.
* @param shouldHandleKey - Returns whether we should handle this keyboard
event.
* @param dismissAllMenus - If true, dismiss all menus. Otherwise, dismiss only
the current menu.
* Only does anything if `shouldHandleKey` returns true.
* @returns Whether the event was handled.
*/
var keyHandler = function (ev, shouldHandleKey, dismissAllMenus) {
var handled = false;
if (shouldHandleKey(ev)) {
dismiss(ev, dismissAllMenus);
handled = true;
}
return handled;
};
/**
* Checks if the submenu should be closed
*/
var shouldCloseSubMenu = function (ev) {
var submenuCloseKey = Utilities_1.getRTL(theme) ?
Utilities_1.KeyCodes.right : Utilities_1.KeyCodes.left;
if (ev.which !== submenuCloseKey || !isSubMenu) {
return false;
}
return !!(focusZoneDirection === FocusZone_1.FocusZoneDirection.vertical ||
(checkForNoWrap && !Utilities_1.shouldWrapFocus(ev.target, 'data-no-
horizontal-wrap')));
};
var shouldHandleKeyDown = function (ev) {
return (
ev.which === Utilities_1.KeyCodes.escape ||
shouldCloseSubMenu(ev) ||
(ev.which === Utilities_1.KeyCodes.up && (ev.altKey || ev.metaKey)));
};
keydown.
// See comment in shouldHandleKeyUp for reasoning.
lastKeyDownWasAltOrMeta.current = isAltOrMeta(ev);
// On Mac, pressing escape dismisses all levels of native context menus
var dismissAllMenus = ev.which === Utilities_1.KeyCodes.escape &&
(Utilities_1.isMac() || Utilities_1.isIOS());
return keyHandler(ev, shouldHandleKeyDown, dismissAllMenus);
};
/**
* We close the menu on key up only if ALL of the following are true:
* - Most recent key down was alt or meta (command)
* - The alt/meta key down was NOT followed by some other key (such as down/up
arrow to
* expand/collapse the menu)
* - We're not on a Mac (or iOS)
*
* This is because on Windows, pressing alt moves focus to the application menu
bar or similar,
* closing any open context menus. There is not a similar behavior on Macs.
*/
var shouldHandleKeyUp = function (ev) {
var keyPressIsAltOrMetaAlone = lastKeyDownWasAltOrMeta.current &&
isAltOrMeta(ev);
lastKeyDownWasAltOrMeta.current = false;
return !!keyPressIsAltOrMetaAlone && !(Utilities_1.isIOS() ||
Utilities_1.isMac());
};
var onKeyUp = function (ev) {
return keyHandler(ev, shouldHandleKeyUp, true /* dismissAllMenus */);
};
var onMenuKeyDown = function (ev) {
// Mark as handled if onKeyDown returns true (for handling collapse cases)
// or if we are attempting to expand a submenu
var handled = onKeyDown(ev);
if (handled || !hostElement.current) {
return;
}
// If we have a modifier key being pressed, we do not want to move focus.
// Otherwise, handle up and down keys.
var hasModifier = !!(ev.altKey || ev.metaKey);
var isUp = ev.which === Utilities_1.KeyCodes.up;
var isDown = ev.which === Utilities_1.KeyCodes.down;
if (!hasModifier && (isUp || isDown)) {
var elementToFocus = isUp
? Utilities_1.getLastFocusable(hostElement.current,
hostElement.current.lastChild, true)
: Utilities_1.getFirstFocusable(hostElement.current,
hostElement.current.firstChild, true);
}
}
};
var onItemKeyDown = function (item, ev) {
var openKey = Utilities_1.getRTL(theme) ? Utilities_1.KeyCodes.left :
Utilities_1.KeyCodes.right;
if (!item.disabled &&
(ev.which === openKey || ev.which === Utilities_1.KeyCodes.enter ||
(ev.which === Utilities_1.KeyCodes.down && (ev.altKey || ev.metaKey)))) {
openSubMenu(item, ev.currentTarget);
}
};
return [onKeyDown, onKeyUp, onMenuKeyDown, onItemKeyDown];
}
function useScrollHandler(asyncTracker) {
var isScrollIdle = React.useRef(true);
var scrollIdleTimeoutId = React.useRef();
/**
*/
var onScroll = function () {
if (!isScrollIdle.current && scrollIdleTimeoutId.current !== undefined) {
asyncTracker.clearTimeout(scrollIdleTimeoutId.current);
scrollIdleTimeoutId.current = undefined;
}
else {
isScrollIdle.current = false;
}
scrollIdleTimeoutId.current = asyncTracker.setTimeout(function () {
isScrollIdle.current = true;
}, NavigationIdleDelay);
};
return [onScroll, isScrollIdle];
}
function useOnSubmenuDismiss(dismiss, closeSubMenu) {
var isMountedRef = React.useRef(false);
isMountedRef.current = true;
isMountedRef.current = false;
};
}, []);
/**
* This function is called ASYNCHRONOUSLY, and so there is a chance it is
called
* after the component is unmounted. The isMountedRef is added to prevent
* from calling setState() after unmount. Do NOT copy this pattern in
synchronous
* code.
*/
var onSubMenuDismiss = function (ev, dismissAll) {
if (dismissAll) {
dismiss(ev, dismissAll);
}
else if (isMountedRef.current) {
closeSubMenu();
}
};
return onSubMenuDismiss;
}
function useSubmenuEnterTimer(_a, asyncTracker) {
var _b = _a.subMenuHoverDelay, subMenuHoverDelay = _b === void 0 ?
NavigationIdleDelay : _b;
var enterTimerRef = React.useRef(undefined);
var cancelSubMenuTimer = function () {
if (enterTimerRef.current !== undefined) {
asyncTracker.clearTimeout(enterTimerRef.current);
enterTimerRef.current = undefined;
}
};
var startSubmenuTimer = function (onTimerExpired) {
enterTimerRef.current = asyncTracker.setTimeout(function () {
onTimerExpired();
cancelSubMenuTimer();
}, subMenuHoverDelay);
};
return [cancelSubMenuTimer, startSubmenuTimer, enterTimerRef];
}
function useMouseHandlers(props, isScrollIdle, subMenuEntryTimer, targetWindow,
shouldUpdateFocusOnMouseEvent, gotMouseMove, expandedMenuItemKey, hostElement,
startSubmenuTimer, cancelSubMenuTimer, openSubMenu, onSubMenuDismiss, dismiss) {
var menuTarget = props.target;
var onItemMouseEnterBase = function (item, ev, target) {
if (shouldUpdateFocusOnMouseEvent.current) {
gotMouseMove.current = true;
}
if (shouldIgnoreMouseEvent()) {
return;
}
updateFocusOnMouseEvent(item, ev, target);
};
var onItemMouseMoveBase = function (item, ev, target) {
var targetElement = ev.currentTarget;
// Always do this check to make sure we record a mouseMove if needed (even
if we are timed out)
if (shouldUpdateFocusOnMouseEvent.current) {
gotMouseMove.current = true;
}
else {
return;
}
if (!isScrollIdle.current ||
subMenuEntryTimer.current !== undefined ||
targetElement === (targetWindow === null || targetWindow === void 0 ?
void 0 : targetWindow.document.activeElement)) {
return;
}
updateFocusOnMouseEvent(item, ev, target);
};
var shouldIgnoreMouseEvent = function () {
return !isScrollIdle.current || !gotMouseMove.current;
};
var onMouseItemLeave = function (item, ev) {
var _a;
if (shouldIgnoreMouseEvent()) {
return;
}
if (expandedMenuItemKey !== undefined) {
return;
}
/**
* IE11 focus() method forces parents to scroll to top of element.
* Edge and IE expose a setActive() function for focusable divs that
* sets the page focus but does not scroll the parent element.
*/
if (hostElement.current.setActive) {
try {
hostElement.current.setActive();
}
catch (e) {
/* no-op */
}
}
else {
(_a = hostElement.current) === null || _a === void 0 ? void 0 :
_a.focus();
}
};
/**
* Handles updating focus when mouseEnter or mouseMove fire.
* As part of updating focus, This function will also update
* the expand/collapse state accordingly.
*/
var updateFocusOnMouseEvent = function (item, ev, target) {
var targetElement = target ? target : ev.currentTarget;
if (item.key === expandedMenuItemKey) {
return;
}
// If the menu is not expanded we can update focus without any delay
if (expandedMenuItemKey === undefined) {
targetElement.focus();
}
// Delay updating expanding/dismissing the submenu
// and only set focus if we have not already done so
if (index_1.hasSubmenu(item)) {
startSubmenuTimer(function () {
openSubMenu(item, targetElement, true);
});
}
else {
startSubmenuTimer(function () {
onSubMenuDismiss(ev);
});
}
};
var onItemClick = function (item, ev) {
onItemClickBase(item, ev, ev.currentTarget);
};
var onItemClickBase = function (item, ev, target) {
var items = getSubmenuItems(item, { target: menuTarget });
// Cancel an async menu item hover timeout action from being taken and
instead
// just trigger the click event instead.
if (!index_1.hasSubmenu(item) && (!items || !items.length)) {
// This is an item without a menu. Click it.
executeItemClick(item, ev);
}
else {
if (item.key !== expandedMenuItemKey) {
// This has a collapsed sub menu. Expand it.
// focus on the container by default when the menu is opened with a
click event
// this differentiates from a keyboard interaction triggering the
click event
var shouldFocusOnContainer = typeof props.shouldFocusOnContainer
=== 'boolean'
? props.shouldFocusOnContainer
: ev.nativeEvent.pointerType === 'mouse';
openSubMenu(item, target, shouldFocusOnContainer);
}
}
};
var onAnchorClick = function (item, ev) {
};
var executeItemClick = function (item, ev) {
if (item.disabled || item.isDisabled) {
return;
}
if (item.preferMenuTargetAsEventTarget) {
overrideTarget(ev, menuTarget);
}
var shouldDismiss = false;
if (item.onClick) {
shouldDismiss = !!item.onClick(ev, item);
}
else if (props.onItemClick) {
shouldDismiss = !!props.onItemClick(ev, item);
}
if (shouldDismiss || !ev.defaultPrevented) {
dismiss(ev, true);
}
};
return [
onItemMouseEnterBase,
onItemMouseMoveBase,
onMouseItemLeave,
onItemClick,
onAnchorClick,
executeItemClick,
onItemClickBase,
];
}
//#endregion
exports.ContextualMenuBase = React.memo(React.forwardRef(function
(propsWithoutDefaults, forwardedRef) {
var _a;
var _b = Utilities_1.getPropsWithDefaults(DEFAULT_PROPS, propsWithoutDefaults),
ref = _b.ref, props = tslib_1.__rest(_b, ["ref"]);
var hostElement = React.useRef(null);
var asyncTracker = react_hooks_1.useAsync();
var menuId = react_hooks_1.useId(COMPONENT_NAME, props.id);
react_hooks_1.useWarnings({
name: COMPONENT_NAME,
props: props,
deprecations: {
getMenuClassNames: 'styles',
},
});
var dismiss = function (ev, dismissAll) { var _a; return (_a = props.onDismiss)
=== null || _a === void 0 ? void 0 : _a.call(props, ev, dismissAll); };
var _c = react_hooks_1.useTarget(props.target, hostElement), targetRef = _c[0],
targetWindow = _c[1];
var tryFocusPreviousActiveElement = usePreviousActiveElement(props,
targetWindow)[0];
var _d = useSubMenuState(props, dismiss), expandedMenuItemKey = _d[0],
openSubMenu = _d[1], getSubmenuProps = _d[2], onSubMenuDismiss = _d[3];
var _e = useShouldUpdateFocusOnMouseMove(props), shouldUpdateFocusOnMouseEvent
= _e[0], gotMouseMove = _e[1], onMenuFocusCapture = _e[2];
var _f = useScrollHandler(asyncTracker), onScroll = _f[0], isScrollIdle =
_f[1];
var _g = useSubmenuEnterTimer(props, asyncTracker), cancelSubMenuTimer = _g[0],
startSubmenuTimer = _g[1], subMenuEntryTimer = _g[2];
var responsiveMode = ResponsiveMode_1.useResponsiveMode(hostElement,
props.responsiveMode);
useVisibility(props, targetWindow);
var _h = useKeyHandlers(props, dismiss, hostElement, openSubMenu), onKeyDown =
_h[0], onKeyUp = _h[1], onMenuKeyDown = _h[2], onItemKeyDown = _h[3];
var _j = useMouseHandlers(props, isScrollIdle, subMenuEntryTimer, targetWindow,
shouldUpdateFocusOnMouseEvent, gotMouseMove, expandedMenuItemKey, hostElement,
startSubmenuTimer, cancelSubMenuTimer, openSubMenu, onSubMenuDismiss, dismiss),
onItemMouseEnterBase = _j[0], onItemMouseMoveBase = _j[1], onMouseItemLeave =
_j[2], onItemClick = _j[3], onAnchorClick = _j[4], executeItemClick = _j[5],
onItemClickBase = _j[6];
//#region Render helpers
var onDefaultRenderMenuList = function (menuListProps,
menuClassNames, defaultRender) {
var indexCorrection = 0;
var items = menuListProps.items, totalItemCount =
menuListProps.totalItemCount, hasCheckmarks = menuListProps.hasCheckmarks, hasIcons
= menuListProps.hasIcons;
return (React.createElement("ul", { className: menuClassNames.list,
onKeyDown: onKeyDown, onKeyUp: onKeyUp, role: 'presentation' }, items.map(function
(item, index) {
var menuItem = renderMenuItem(item, index, indexCorrection,
totalItemCount, hasCheckmarks, hasIcons, menuClassNames);
if (item.itemType !==
ContextualMenu_types_1.ContextualMenuItemType.Divider && item.itemType !==
ContextualMenu_types_1.ContextualMenuItemType.Header) {
var indexIncrease = item.customOnRenderListLength ?
item.customOnRenderListLength : 1;
indexCorrection += indexIncrease;
}
return menuItem;
})));
};
var renderFocusZone = function (children, adjustedFocusZoneProps) {
var _a = props.focusZoneAs, ChildrenRenderer = _a === void 0 ?
FocusZone_1.FocusZone : _a;
return React.createElement(ChildrenRenderer, tslib_1.__assign({},
adjustedFocusZoneProps), children);
};
/**
* !!!IMPORTANT!!! Avoid mutating ìtem: IContextualMenuItem` argument. It will
* cause the menu items to always re-render because the component update is
based on shallow comparison.
*/
var renderMenuItem = function (item, index, focusableElementIndex,
totalItemCount, hasCheckmarks, hasIcons,
menuClassNames) {
var _a;
var renderedItems = [];
var iconProps = item.iconProps || { iconName: 'None' };
var getItemClassNames = item.getItemClassNames, // eslint-disable-line
deprecation/deprecation
itemProps = item.itemProps;
var styles = itemProps ? itemProps.styles : undefined;
// We only send a dividerClassName when the item to be rendered is a
divider.
// For all other cases, the default divider style is used.
var dividerClassName = item.itemType ===
ContextualMenu_types_1.ContextualMenuItemType.Divider ? item.className : undefined;
var subMenuIconClassName = item.submenuIconProps ?
item.submenuIconProps.className : '';
var itemClassNames;
// IContextualMenuItem#getItemClassNames for backwards compatibility
// otherwise uses mergeStyles for class names.
if (getItemClassNames) {
itemClassNames = getItemClassNames(props.theme,
index_1.isItemDisabled(item), expandedMenuItemKey === item.key, !!
index_1.getIsChecked(item), !!item.href, iconProps.iconName !== 'None',
item.className, dividerClassName, iconProps.className, subMenuIconClassName,
item.primaryDisabled);
}
else {
var itemStyleProps = {
theme: props.theme,
disabled: index_1.isItemDisabled(item),
expanded: expandedMenuItemKey === item.key,
checked: !!index_1.getIsChecked(item),
isAnchorLink: !!item.href,
knownIcon: iconProps.iconName !== 'None',
itemClassName: item.className,
dividerClassName: dividerClassName,
iconClassName: iconProps.className,
subMenuClassName: subMenuIconClassName,
primaryDisabled: item.primaryDisabled,
};
// We need to generate default styles then override if styles are
provided
// since the ContextualMenu currently handles item classNames.
itemClassNames =
getContextualMenuItemClassNames(_getMenuItemStylesFunction((_a =
menuClassNames.subComponentStyles) === null || _a === void 0 ? void 0 :
_a.menuItem, styles), itemStyleProps);
}
if (item.text === '-' || item.name === '-') {
item.itemType = ContextualMenu_types_1.ContextualMenuItemType.Divider;
}
case ContextualMenu_types_1.ContextualMenuItemType.Divider:
renderedItems.push(renderSeparator(index, itemClassNames));
break;
case ContextualMenu_types_1.ContextualMenuItemType.Header:
renderedItems.push(renderSeparator(index, itemClassNames));
var headerItem = renderHeaderMenuItem(item, itemClassNames,
menuClassNames, index, hasCheckmarks, hasIcons);
renderedItems.push(renderListItem(headerItem, item.key || index,
itemClassNames, item.title));
break;
case ContextualMenu_types_1.ContextualMenuItemType.Section:
renderedItems.push(renderSectionItem(item, itemClassNames,
menuClassNames, index, hasCheckmarks, hasIcons));
break;
default:
var defaultRenderNormalItem = function () {
return renderNormalItem(item, itemClassNames, index,
focusableElementIndex, totalItemCount, hasCheckmarks, hasIcons);
};
var menuItem = props.onRenderContextualMenuItem
? props.onRenderContextualMenuItem(item,
defaultRenderNormalItem)
: defaultRenderNormalItem();
renderedItems.push(renderListItem(menuItem, item.key || index,
itemClassNames, item.title));
break;
}
// Since multiple nodes *could* be rendered, wrap them all in a fragment
with this item's key.
// This ensures the reconciler handles multi-item output per-node correctly
and does not re-mount content.
return React.createElement(React.Fragment, { key: item.key },
renderedItems);
};
var defaultMenuItemRenderer = function (item,
menuClassNames) {
var index = item.index, focusableElementIndex = item.focusableElementIndex,
totalItemCount = item.totalItemCount, hasCheckmarks = item.hasCheckmarks, hasIcons
= item.hasIcons;
return renderMenuItem(item, index, focusableElementIndex, totalItemCount,
hasCheckmarks, hasIcons, menuClassNames);
};
var renderSectionItem = function (sectionItem,
itemClassNames,
menuClassNames, index, hasCheckmarks, hasIcons) {
var sectionProps = sectionItem.sectionProps;
if (!sectionProps) {
return;
}
var headerItem;
var groupProps;
if (sectionProps.title) {
var headerContextualMenuItem = undefined;
var ariaLabelledby = '';
if (typeof sectionProps.title === 'string') {
// Since title is a user-facing string, it needs to be stripped
// of whitespace in order to build a valid element ID
var id_1 = menuId + sectionProps.title.replace(/\s/g, '');
headerContextualMenuItem = {
key: "section-" + sectionProps.title + "-title",
itemType: ContextualMenu_types_1.ContextualMenuItemType.Header,
text: sectionProps.title,
id: id_1,
};
ariaLabelledby = id_1;
}
else {
var id_2 = sectionProps.title.id || menuId +
sectionProps.title.key.replace(/\s/g, '');
headerContextualMenuItem = tslib_1.__assign(tslib_1.__assign({},
sectionProps.title), { id: id_2 });
ariaLabelledby = id_2;
}
if (headerContextualMenuItem) {
groupProps = {
role: 'group',
'aria-labelledby': ariaLabelledby,
};
headerItem = renderHeaderMenuItem(headerContextualMenuItem,
itemClassNames, menuClassNames, index, hasCheckmarks, hasIcons);
}
}
if (sectionProps.items && sectionProps.items.length > 0) {
return (React.createElement("li", { role: "presentation", key:
sectionProps.key || sectionItem.key || "section-" + index },
React.createElement("div", tslib_1.__assign({}, groupProps),
React.createElement("ul", { className: menuClassNames.list,
role: "presentation" },
sectionProps.topDivider && renderSeparator(index,
itemClassNames, true, true),
headerItem && renderListItem(headerItem, sectionItem.key ||
index, itemClassNames, sectionItem.title),
sectionProps.items.map(function (contextualMenuItem,
itemsIndex) {
return renderMenuItem(contextualMenuItem, itemsIndex,
itemsIndex, sectionProps.items.length, hasCheckmarks, hasIcons, menuClassNames);
}),
sectionProps.bottomDivider && renderSeparator(index,
itemClassNames, false, true)))));
}
};
var renderListItem = function (content, key, classNames, // eslint-disable-line
title) {
return (React.createElement("li", { role: "presentation", title: title,
key: key, className: classNames.item }, content));
};
var renderSeparator = function (index, classNames, // eslint-disable-line
top, fromSection) {
if (fromSection || index > 0) {
return (React.createElement("li", { role: "separator", key:
'separator-' + index + (top === undefined ? '' : top ? '-top' : '-bottom'),
className: classNames.divider, "aria-hidden": "true" }));
}
return null;
};
var renderNormalItem = function (item, classNames, // eslint-disable-line
index, focusableElementIndex, totalItemCount, hasCheckmarks, hasIcons) {
return item.onRender(tslib_1.__assign({ 'aria-posinset':
focusableElementIndex + 1, 'aria-setsize': totalItemCount }, item), dismiss);
}
var contextualMenuItemAs = props.contextualMenuItemAs;
var commonProps = {
item: item,
index: index,
focusableElementIndex: focusableElementIndex,
totalItemCount: totalItemCount,
hasCheckmarks: hasCheckmarks,
hasIcons: hasIcons,
contextualMenuItemAs: contextualMenuItemAs,
onItemMouseEnter: onItemMouseEnterBase,
onItemMouseLeave: onMouseItemLeave,
onItemMouseMove: onItemMouseMoveBase,
onItemMouseDown: onItemMouseDown,
executeItemClick: executeItemClick,
onItemKeyDown: onItemKeyDown,
expandedMenuItemKey: expandedMenuItemKey,
openSubMenu: openSubMenu,
dismissSubMenu: onSubMenuDismiss,
dismissMenu: dismiss,
};
if (item.href) {
return React.createElement(index_2.ContextualMenuAnchor,
tslib_1.__assign({}, commonProps, { onItemClick: onAnchorClick }));
}
if (item.split && index_1.hasSubmenu(item)) {
return (React.createElement(index_2.ContextualMenuSplitButton,
tslib_1.__assign({}, commonProps, { onItemClick: onItemClick, onItemClickBase:
onItemClickBase, onTap: cancelSubMenuTimer })));
}
return React.createElement(index_2.ContextualMenuButton,
tslib_1.__assign({}, commonProps, { onItemClick: onItemClick, onItemClickBase:
onItemClickBase }));
};
var renderHeaderMenuItem = function (item,
itemClassNames,
menuClassNames, index, hasCheckmarks, hasIcons) {
var _a = props.contextualMenuItemAs, ChildrenRenderer = _a === void 0 ?
ContextualMenuItem_1.ContextualMenuItem : _a;
var itemProps = item.itemProps, id = item.id;
var divHtmlProperties = itemProps && Utilities_1.getNativeProps(itemProps,
return (
React.createElement("div", tslib_1.__assign({ id: id, className:
menuClassNames.header }, divHtmlProperties, { style: item.style }),
React.createElement(ChildrenRenderer, tslib_1.__assign({ item: item,
classNames: itemClassNames, index: index, onCheckmarkClick: hasCheckmarks ?
onItemClick : undefined, hasIcons: hasIcons }, itemProps))));
};
//#endregion
//#region Main render
var isBeakVisible = props.isBeakVisible;
var items = props.items, labelElementId = props.labelElementId, id = props.id,
className = props.className, beakWidth = props.beakWidth, directionalHint =
props.directionalHint, directionalHintForRTL = props.directionalHintForRTL,
alignTargetEdge = props.alignTargetEdge, gapSpace = props.gapSpace, coverTarget =
props.coverTarget, ariaLabel = props.ariaLabel, doNotLayer = props.doNotLayer,
target = props.target, bounds = props.bounds, useTargetWidth =
props.useTargetWidth, useTargetAsMinWidth = props.useTargetAsMinWidth,
directionalHintFixed = props.directionalHintFixed, shouldFocusOnMount =
props.shouldFocusOnMount, shouldFocusOnContainer = props.shouldFocusOnContainer,
title = props.title, styles = props.styles, theme = props.theme, calloutProps =
props.calloutProps, _k = props.onRenderSubMenu, onRenderSubMenu = _k === void 0 ?
onDefaultRenderSubMenu : _k, _l = props.onRenderMenuList, onRenderMenuList = _l ===
void 0 ? function (menuListProps, defaultRender) { return
onDefaultRenderMenuList(menuListProps, classNames, defaultRender); } : _l,
focusZoneProps = props.focusZoneProps,
getMenuClassNames = props.getMenuClassNames;
var classNames = getMenuClassNames
? getMenuClassNames(theme, className)
: getClassNames(styles, {
theme: theme,
});
var hasIcons = itemsHaveIcons(items);
function itemsHaveIcons(contextualMenuItems) {
for (var _i = 0, contextualMenuItems_1 = contextualMenuItems; _i <
contextualMenuItems_1.length; _i++) {
var item = contextualMenuItems_1[_i];
if (item.iconProps) {
return true;
}
if (item.itemType ===
ContextualMenu_types_1.ContextualMenuItemType.Section &&
item.sectionProps &&
itemsHaveIcons(item.sectionProps.items)) {
return true;
}
}
return false;
}
var adjustedFocusZoneProps = tslib_1.__assign(tslib_1.__assign({ direction:
FocusZone_1.FocusZoneDirection.vertical, handleTabKey:
FocusZone_1.FocusZoneTabbableElements.all, isCircularNavigation: true },
focusZoneProps), { className: Utilities_1.css(classNames.root, (_a =
props.focusZoneProps) === null || _a === void 0 ? void 0 : _a.className) });
var hasCheckmarks = canAnyMenuItemsCheck(items);
var submenuProps = expandedMenuItemKey && props.hidden !== true ?
getSubmenuProps() : null;
isBeakVisible = isBeakVisible === undefined ? responsiveMode <=
ResponsiveMode_1.ResponsiveMode.medium : isBeakVisible;
/**
* When useTargetWidth is true, get the width of the target element and apply
it for the context menu container
*/
var contextMenuStyle;
var targetAsHtmlElement = targetRef.current;
if ((useTargetWidth || useTargetAsMinWidth) && targetAsHtmlElement &&
targetAsHtmlElement.offsetWidth) {
var targetBoundingRect = targetAsHtmlElement.getBoundingClientRect();
var targetWidth = targetBoundingRect.width - 2; /* Accounts for 1px border
*/
if (useTargetWidth) {
contextMenuStyle = {
width: targetWidth,
};
}
else if (useTargetAsMinWidth) {
contextMenuStyle = {
minWidth: targetWidth,
};
}
}
// The menu should only return if items were provided, if no items were
provided then it should not appear.
if (items && items.length > 0) {
var totalItemCount_1 = 0;
var item = items_2[_i];
if (item.itemType !==
ContextualMenu_types_1.ContextualMenuItemType.Divider && item.itemType !==
ContextualMenu_types_1.ContextualMenuItemType.Header) {
var itemCount = item.customOnRenderListLength ?
item.customOnRenderListLength : 1;
totalItemCount_1 += itemCount;
}
}
var calloutStyles_1 = classNames.subComponentStyles
? classNames.subComponentStyles.callout
: undefined;
return (React.createElement(index_3.MenuContext.Consumer, null, function
(menuContext) { return (React.createElement(Callout_1.Callout,
tslib_1.__assign({ styles: calloutStyles_1, onRestoreFocus:
tryFocusPreviousActiveElement }, calloutProps, { target: target ||
menuContext.target, isBeakVisible: isBeakVisible, beakWidth: beakWidth,
directionalHint: directionalHint, directionalHintForRTL: directionalHintForRTL,
gapSpace: gapSpace, coverTarget: coverTarget, doNotLayer: doNotLayer, className:
Utilities_1.css('ms-ContextualMenu-Callout', calloutProps &&
calloutProps.className), setInitialFocus: shouldFocusOnMount, onDismiss:
props.onDismiss || menuContext.onDismiss, onScroll: onScroll, bounds: bounds,
directionalHintFixed: directionalHintFixed, alignTargetEdge: alignTargetEdge,
hidden: props.hidden || menuContext.hidden, ref: forwardedRef }),
React.createElement("div", { style: contextMenuStyle, ref: hostElement,
id: id, className: classNames.container, tabIndex: shouldFocusOnContainer ? 0 : -1,
onKeyDown: onMenuKeyDown, onKeyUp: onKeyUp, onFocusCapture: onMenuFocusCapture,
"aria-label": ariaLabel, "aria-labelledby": labelElementId, role: 'menu' },
title && React.createElement("div", { className:
classNames.title },
" ",
title,
" "),
items && items.length
? renderFocusZone(onRenderMenuList({
ariaLabel: ariaLabel,
items: items,
totalItemCount: totalItemCount_1,
hasCheckmarks: hasCheckmarks,
hasIcons: hasIcons,
defaultMenuItemRenderer: function (item) {
return defaultMenuItemRenderer(item, classNames);
},
labelElementId: labelElementId,
}, function (menuListProps, defaultRender) { return
onDefaultRenderMenuList(menuListProps, classNames, defaultRender); }),
adjustedFocusZoneProps)
: null,
submenuProps && onRenderSubMenu(submenuProps,
onDefaultRenderSubMenu)))); }));
}
else {
return null;
}
//#endregion
}), function (prevProps, newProps) {
if (!newProps.shouldUpdateWhenHidden && prevProps.hidden && newProps.hidden) {
// Do not update when hidden.
return true;
}
return Utilities_1.shallowCompare(prevProps, newProps);
});
exports.ContextualMenuBase.displayName = 'ContextualMenuBase';
/**
* Returns true if the key for the event is alt (Mac option) or meta (Mac command).
*/
function isAltOrMeta(ev) {
}
function onItemMouseDown(item, ev) {
var _a;
(_a = item.onMouseDown) === null || _a === void 0 ? void 0 : _a.call(item,
item, ev);
}
function onDefaultRenderSubMenu(subMenuProps, defaultRender) {
throw Error('ContextualMenuBase: onRenderSubMenu callback is null or undefined.
' +
'Please ensure to set ònRenderSubMenu` property either manually or with
`styled` helper.');
}
/**
* Returns the item that matches a given key if any.
* @param key - The key of the item to match
* @param items - The items to look for the key
*/
function findItemByKeyFromItems(key, items) {
var item = items_3[_i];
if (item.itemType === ContextualMenu_types_1.ContextualMenuItemType.Section
&& item.sectionProps) {
var match = findItemByKeyFromItems(key, item.sectionProps.items);
if (match) {
return match;
}
}
else if (item.key && item.key === key) {
return item;
}
}
}
function getOnClickWithOverrideTarget(onClick, target) {
return onClick
? function (ev, item) {
overrideTarget(ev, target);
return onClick(ev, item);
}
: onClick;
}
function overrideTarget(ev, target) {
if (ev && target) {
ev.persist();
if (target instanceof Event) {
ev.target = target.target;
}
else if (target instanceof Element) {
ev.target = target;
}
}
}
//# sourceMappingURL=ContextualMenu.base.js.map
/***/ }),
/***/ 74867:
"use strict";

exports.getItemStyles = exports.getItemClassNames =
exports.getSplitButtonVerticalDividerClassNames = void 0;
var VerticalDivider_classNames_1 = __webpack_require__(1342);
var ContextualMenu_cnstyles_1 = __webpack_require__(20941);
var CONTEXTUAL_SPLIT_MENU_MINWIDTH = '28px';
var MediumScreenSelector = Styling_1.getScreenSelector(0,
exports.getSplitButtonVerticalDividerClassNames = Utilities_1.memoizeFunction(
function (theme) {
var _a;
return
Styling_1.mergeStyleSets(VerticalDivider_classNames_1.getDividerClassNames(theme),
{
wrapper: {
right: 28,
_a[MediumScreenSelector] = {
right: 32, // fontSize of the icon increased from 12px to 16px
},
_a),
},
divider: {
height: 16,
width: 1,
},
});
});
item: 'ms-ContextualMenu-item',
divider: 'ms-ContextualMenu-divider',
root: 'ms-ContextualMenu-link',
isChecked: 'is-checked',
isExpanded: 'is-expanded',
isDisabled: 'is-disabled',
linkContent: 'ms-ContextualMenu-linkContent',
linkContentMenu: 'ms-ContextualMenu-linkContent',
icon: 'ms-ContextualMenu-icon',
iconColor: 'ms-ContextualMenu-iconColor',
checkmarkIcon: 'ms-ContextualMenu-checkmarkIcon',
subMenuIcon: 'ms-ContextualMenu-submenuIcon',
label: 'ms-ContextualMenu-itemText',
secondaryText: 'ms-ContextualMenu-secondaryText',
splitMenu: 'ms-ContextualMenu-splitMenu',
screenReaderText: 'ms-ContextualMenu-screenReaderText',
};
/**
* @deprecated Will be removed in \>= 7.0.
* This is a package-internal method that has been depended on.
* It is being kept in this form for backwards compatibility.
* @internal
*/
// TODO: Audit perf. impact of and potentially remove memoizeFunction.
// https://github.com/microsoft/fluentui/issues/5534
exports.getItemClassNames = Utilities_1.memoizeFunction(function (theme, disabled,
expanded, checked, isAnchorLink, knownIcon, itemClassName, dividerClassName,
iconClassName, subMenuClassName, primaryDisabled, className) {
var _a, _b, _c, _d;
var styles = ContextualMenu_cnstyles_1.getMenuItemStyles(theme);
item: [classNames.item, styles.item, itemClassName],
divider: [classNames.divider, styles.divider, dividerClassName],
root: [
classNames.root,
styles.root,
checked && [classNames.isChecked, styles.rootChecked],
isAnchorLink && styles.anchorLink,
expanded && [classNames.isExpanded, styles.rootExpanded],
disabled && [classNames.isDisabled, styles.rootDisabled],
!disabled &&
!expanded && [
{
selectors: (_a = {
':active': styles.rootPressed
},
_a["." + Utilities_1.IsFocusVisibleClassName + "
&:focus, ." + Utilities_1.IsFocusVisibleClassName + " &:focus:hover"] =
styles.rootFocused,
_a["." + Utilities_1.IsFocusVisibleClassName + " &:hover"]
= { background: 'inherit;' },
_a),
},
],
className,
],
splitPrimary: [
styles.root,
{
width: "calc(100% - " + CONTEXTUAL_SPLIT_MENU_MINWIDTH + ")",
},
(disabled || primaryDisabled) && ['is-disabled', styles.rootDisabled],
!(disabled || primaryDisabled) &&
!checked && [
{
selectors: (_b = {
':hover': styles.rootHovered
},
// when hovering over the splitPrimary also affect the
splitMenu
_b[":hover ~ ." + classNames.splitMenu] =
styles.rootHovered,
_b[':active'] = styles.rootPressed,
_b["." + Utilities_1.IsFocusVisibleClassName + "
styles.rootFocused,
_b["." + Utilities_1.IsFocusVisibleClassName + " &:hover"]
_b),
},
],
],
splitMenu: [
classNames.splitMenu,
styles.root,
{
flexBasis: '0',
padding: '0 8px',
minWidth: CONTEXTUAL_SPLIT_MENU_MINWIDTH,
},
expanded && ['is-expanded', styles.rootExpanded],
!disabled &&
!expanded && [
{
selectors: (_c = {
':active': styles.rootPressed
},
_c["." + Utilities_1.IsFocusVisibleClassName + "
styles.rootFocused,
_c["." + Utilities_1.IsFocusVisibleClassName + " &:hover"]
_c),
},
],
],
anchorLink: styles.anchorLink,
linkContent: [classNames.linkContent, styles.linkContent],
linkContentMenu: [
classNames.linkContentMenu,
styles.linkContent,
{
},
],
icon: [
classNames.icon,
knownIcon && styles.iconColor,
styles.icon,
iconClassName,
disabled && [classNames.isDisabled, styles.iconDisabled],
],
iconColor: styles.iconColor,
checkmarkIcon: [classNames.checkmarkIcon, knownIcon &&
styles.checkmarkIcon, styles.icon, iconClassName],
subMenuIcon: [
classNames.subMenuIcon,
styles.subMenuIcon,
subMenuClassName,
expanded && { color: theme.palette.neutralPrimary },
disabled && [styles.iconDisabled],
],
label: [classNames.label, styles.label],
secondaryText: [classNames.secondaryText, styles.secondaryText],
splitContainer: [
styles.splitButtonFlexContainer,
!disabled &&
!checked && [
{
_d["." + Utilities_1.IsFocusVisibleClassName + "
styles.rootFocused,
_d),
},
],
],
screenReaderText: [
classNames.screenReaderText,
styles.screenReaderText,
Styling_1.hiddenContentStyle,
{ visibility: 'hidden' },
],
});
});
/**
* Wrapper function for generating ContextualMenuItem classNames which adheres to
* the getStyles API, but invokes memoized className generator function with
* primitive values.
*
* @param props the ContextualMenuItem style props used to generate its styles.
*/
var getItemStyles = function (props) {
var theme = props.theme, disabled = props.disabled, expanded = props.expanded,
checked = props.checked, isAnchorLink = props.isAnchorLink, knownIcon =
props.knownIcon, itemClassName = props.itemClassName, dividerClassName =
props.dividerClassName, iconClassName = props.iconClassName, subMenuClassName =
props.subMenuClassName, primaryDisabled = props.primaryDisabled, className =
props.className;
return exports.getItemClassNames(theme, disabled, expanded, checked,
isAnchorLink, knownIcon, itemClassName, dividerClassName, iconClassName,
subMenuClassName, primaryDisabled, className);
};
exports.getItemStyles = getItemStyles;
//# sourceMappingURL=ContextualMenu.classNames.js.map
/***/ }),
/***/ 20941:
"use strict";

exports.getMenuItemStyles = exports.CONTEXTUAL_MENU_ITEM_HEIGHT = void 0;
exports.CONTEXTUAL_MENU_ITEM_HEIGHT = 36;
var MediumScreenSelector = Styling_1.getScreenSelector(0,
exports.getMenuItemStyles = Utilities_1.memoizeFunction(function (theme) {
var _a, _b, _c, _d, _e;
var semanticColors = theme.semanticColors, fonts = theme.fonts, palette =
theme.palette;
var ContextualMenuItemBackgroundHoverColor =
semanticColors.menuItemBackgroundHovered;
var ContextualMenuItemTextHoverColor = semanticColors.menuItemTextHovered;
var ContextualMenuItemBackgroundSelectedColor =
semanticColors.menuItemBackgroundPressed;
var ContextualMenuItemDividerColor = semanticColors.bodyDivider;
var menuItemStyles = {
item: [
fonts.medium,
{
},
],
divider: {
display: 'block',
height: '1px',
backgroundColor: ContextualMenuItemDividerColor,
},
root: [
fonts.medium,
{
border: 'none',
width: '100%',
height: exports.CONTEXTUAL_MENU_ITEM_HEIGHT,
lineHeight: exports.CONTEXTUAL_MENU_ITEM_HEIGHT,
display: 'block',
cursor: 'pointer',
padding: '0px 8px 0 4px',
textAlign: 'left',
},
],
rootDisabled: {
cursor: 'default',
// ensure disabled text looks different than enabled
color: 'GrayText',
opacity: 1,
},
_a),
},
rootHovered: {
backgroundColor: ContextualMenuItemBackgroundHoverColor,
color: ContextualMenuItemTextHoverColor,
selectors: {
'.ms-ContextualMenu-icon': {
color: palette.themeDarkAlt,
},
'.ms-ContextualMenu-submenuIcon': {
},
},
},
rootFocused: {
},
rootChecked: {
selectors: {
'.ms-ContextualMenu-checkmarkIcon': {
},
},
},
rootPressed: {
backgroundColor: ContextualMenuItemBackgroundSelectedColor,
selectors: {
'.ms-ContextualMenu-icon': {
},
'.ms-ContextualMenu-submenuIcon': {
},
},
},
rootExpanded: {
backgroundColor: ContextualMenuItemBackgroundSelectedColor,
color: semanticColors.bodyTextChecked,
selectors: (_b = {
'.ms-ContextualMenu-submenuIcon': (_c = {},
// icons inside of anchor tags are not properly
inheriting color in high contrast
color: 'inherit',
},
_c)
},
_b[Styling_1.HighContrastSelector] = tslib_1.__assign({},
_b),
},
linkContent: {
height: 'inherit',
display: 'flex',
maxWidth: '100%',
},
anchorLink: {
textRendering: 'auto',
color: 'inherit',
letterSpacing: 'normal',
wordSpacing: 'normal',
textTransform: 'none',
textIndent: '0px',
textShadow: 'none',
},
label: {
margin: '0 4px',
flexGrow: '1',
},
secondaryText: {
textAlign: 'right',
},
icon: {
minHeight: '1px',
maxHeight: exports.CONTEXTUAL_MENU_ITEM_HEIGHT,
width: Styling_1.IconFontSizes.medium,
margin: '0 4px',
flexShrink: '0',
_d[MediumScreenSelector] = {
fontSize: Styling_1.IconFontSizes.large,
width: Styling_1.IconFontSizes.large,
},
_d),
},
iconColor: {
color: semanticColors.menuIcon,
},
iconDisabled: {
},
checkmarkIcon: {
color: semanticColors.bodySubtext,
},
subMenuIcon: {
lineHeight: exports.CONTEXTUAL_MENU_ITEM_HEIGHT,
flexShrink: '0',
fontSize: Styling_1.IconFontSizes.small,
selectors: (_e = {
':hover': {
},
':active': {
}
},
_e[MediumScreenSelector] = {
fontSize: Styling_1.IconFontSizes.medium, // 16px
},
_e),
},
splitButtonFlexContainer: [
{
display: 'flex',
flexWrap: 'nowrap',
},
],
};
return Styling_1.concatStyleSets(menuItemStyles);
});
//# sourceMappingURL=ContextualMenu.cnstyles.js.map
/***/ }),
/***/ 97282:
"use strict";

exports.ContextualMenu = void 0;
var ContextualMenu_base_1 = __webpack_require__(6667);
var ContextualMenu_styles_1 = __webpack_require__(5790);
function onRenderSubMenu(subMenuProps) {
return React.createElement(LocalContextualMenu, tslib_1.__assign({},
subMenuProps));
}
// This is to prevent cyclic import with ContextualMenu.base.tsx.
var LocalContextualMenu =
Utilities_1.styled(ContextualMenu_base_1.ContextualMenuBase,
ContextualMenu_styles_1.getStyles, function (props) { return ({
onRenderSubMenu: props.onRenderSubMenu
? Utilities_1.composeRenderFunction(props.onRenderSubMenu, onRenderSubMenu)
: onRenderSubMenu,
}); }, { scope: 'ContextualMenu' });
/**
* ContextualMenu description
*/
exports.ContextualMenu = LocalContextualMenu;
exports.ContextualMenu.displayName = 'ContextualMenu';
//# sourceMappingURL=ContextualMenu.js.map
/***/ }),
/***/ 5790:
"use strict";

root: 'ms-ContextualMenu',
container: 'ms-ContextualMenu-container',
list: 'ms-ContextualMenu-list',
header: 'ms-ContextualMenu-header',
title: 'ms-ContextualMenu-title',
isopen: 'is-open',
};
var fonts = theme.fonts, semanticColors = theme.semanticColors, effects =
theme.effects;
return {
root: [
theme.fonts.medium,
classNames.root,
classNames.isopen,
{
minWidth: '180px',
},
className,
],
container: [
{
selectors: {
':focus': { outline: 0 },
},
},
],
list: [
classNames.list,
classNames.isopen,
{
margin: '0',
padding: '0',
},
],
header: [
classNames.header,
fonts.small,
{
color: semanticColors.menuHeader,
background: 'none',
border: 'none',
height: ContextualMenu_cnstyles_1.CONTEXTUAL_MENU_ITEM_HEIGHT,
lineHeight: ContextualMenu_cnstyles_1.CONTEXTUAL_MENU_ITEM_HEIGHT,
cursor: 'default',
padding: '0px 6px',
userSelect: 'none',
textAlign: 'left',
},
],
title: [
classNames.title,
{
paddingBottom: '5px',
paddingTop: '5px',
backgroundColor: semanticColors.menuItemBackgroundPressed,
},
],
subComponentStyles: {
callout: {
root: {
},
},
menuItem: {},
},
};
};
//# sourceMappingURL=ContextualMenu.styles.js.map
/***/ }),
/***/ 54177:
"use strict";

exports.ContextualMenuItemType = exports.DirectionalHint = void 0;
Object.defineProperty(exports, "DirectionalHint", ({ enumerable: true, get:
function () { return DirectionalHint_1.DirectionalHint; } }));
/**
* {@docCategory ContextualMenu}
*/
var ContextualMenuItemType;
(function (ContextualMenuItemType) {
ContextualMenuItemType[ContextualMenuItemType["Normal"] = 0] = "Normal";
ContextualMenuItemType[ContextualMenuItemType["Divider"] = 1] = "Divider";
ContextualMenuItemType[ContextualMenuItemType["Header"] = 2] = "Header";
ContextualMenuItemType[ContextualMenuItemType["Section"] = 3] = "Section";
})(ContextualMenuItemType = exports.ContextualMenuItemType ||
(exports.ContextualMenuItemType = {}));
//# sourceMappingURL=ContextualMenu.types.js.map
/***/ }),
/***/ 7391:
"use strict";

exports.ContextualMenuItemBase = void 0;
var defaultIconRenderer = function (props) {
var item = props.item, classNames = props.classNames;
var iconProps = item.iconProps;
return React.createElement(Icon_1.Icon, tslib_1.__assign({}, iconProps,
{ className: classNames.icon }));
};
var renderItemIcon = function (props) {
var item = props.item, hasIcons = props.hasIcons;
if (!hasIcons) {
return null;
}
if (item.onRenderIcon) {
return item.onRenderIcon(props, defaultIconRenderer);
}
return defaultIconRenderer(props);
};
var renderCheckMarkIcon = function (_a) {
var onCheckmarkClick = _a.onCheckmarkClick, item = _a.item, classNames =
_a.classNames;
var isItemChecked = index_1.getIsChecked(item);
if (onCheckmarkClick) {
// Ensures that the item is passed as the first argument to the checkmark
click callback.
var onClick = function (e) { return onCheckmarkClick(item, e); };
return (React.createElement(Icon_1.Icon, { iconName: item.canCheck !==
false && isItemChecked ? 'CheckMark' : '', className: classNames.checkmarkIcon,
onClick: onClick }));
}
return null;
};
var renderItemName = function (_a) {
var item = _a.item, classNames = _a.classNames;
if (item.text || item.name) {
return React.createElement("span", { className: classNames.label },
item.text || item.name);
}
return null;
};
var renderSecondaryText = function (_a) {
var item = _a.item, classNames = _a.classNames;
if (item.secondaryText) {
return React.createElement("span", { className: classNames.secondaryText },
item.secondaryText);
}
return null;
};
var renderSubMenuIcon = function (_a) {
var item = _a.item, classNames = _a.classNames, theme = _a.theme;
if (index_1.hasSubmenu(item)) {
return (React.createElement(Icon_1.Icon, tslib_1.__assign({ iconName:
Utilities_1.getRTL(theme) ? 'ChevronLeft' : 'ChevronRight' },
item.submenuIconProps, { className: classNames.subMenuIcon })));
}
return null;
};
var ContextualMenuItemBase = /** @class */ (function (_super) {
tslib_1.__extends(ContextualMenuItemBase, _super);
function ContextualMenuItemBase(props) {
_this.openSubMenu = function () {
var _a = _this.props, item = _a.item, openSubMenu = _a.openSubMenu,
getSubmenuTarget = _a.getSubmenuTarget;
if (getSubmenuTarget) {
var submenuTarget = getSubmenuTarget();
if (index_1.hasSubmenu(item) && openSubMenu && submenuTarget) {
openSubMenu(item, submenuTarget);
}
}
};
_this.dismissSubMenu = function () {
var _a = _this.props, item = _a.item, dismissSubMenu =
_a.dismissSubMenu;
if (index_1.hasSubmenu(item) && dismissSubMenu) {
dismissSubMenu();
}
};
_this.dismissMenu = function (dismissAll) {
var dismissMenu = _this.props.dismissMenu;
if (dismissMenu) {
dismissMenu(undefined /* ev */, dismissAll);
}
};
return _this;
}
ContextualMenuItemBase.prototype.render = function () {
var _a = this.props, item = _a.item, classNames = _a.classNames;
var renderContent = item.onRenderContent || this._renderLayout;
return (React.createElement("div", { className: item.split ?
classNames.linkContentMenu : classNames.linkContent }, renderContent(this.props, {
renderCheckMarkIcon: renderCheckMarkIcon,
renderItemIcon: renderItemIcon,
renderItemName: renderItemName,
renderSecondaryText: renderSecondaryText,
renderSubMenuIcon: renderSubMenuIcon,
})));
};
ContextualMenuItemBase.prototype._renderLayout = function (props,
defaultRenders) {
defaultRenders.renderCheckMarkIcon(props),
defaultRenders.renderItemIcon(props),
defaultRenders.renderItemName(props),
defaultRenders.renderSecondaryText(props),
defaultRenders.renderSubMenuIcon(props)));
};
return ContextualMenuItemBase;
exports.ContextualMenuItemBase = ContextualMenuItemBase;
//# sourceMappingURL=ContextualMenuItem.base.js.map
/***/ }),
/***/ 28670:
"use strict";
exports.ContextualMenuItem = void 0;
var ContextualMenuItem_base_1 = __webpack_require__(7391);
/**
* ContextualMenuItem description
*/
exports.ContextualMenuItem =
Utilities_1.styled(ContextualMenuItem_base_1.ContextualMenuItemBase,
ContextualMenu_classNames_1.getItemStyles, undefined, { scope: 'ContextualMenuItem'
});
//# sourceMappingURL=ContextualMenuItem.js.map
/***/ }),
/***/ 26905:
"use strict";

//# sourceMappingURL=ContextualMenuItem.types.js.map
/***/ }),
/***/ 97100:
"use strict";

exports.ContextualMenuAnchor = void 0;
var ContextualMenuItemWrapper_1 = __webpack_require__(19932);
var ContextualMenuAnchor = /** @class */ (function (_super) {
tslib_1.__extends(ContextualMenuAnchor, _super);
function ContextualMenuAnchor() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this._anchor = React.createRef();
true });
});
_this._getSubmenuTarget = function () {
return _this._anchor.current ? _this._anchor.current : undefined;
};
_this._onItemClick = function (ev) {
var _a = _this.props, item = _a.item, onItemClick = _a.onItemClick;
if (onItemClick) {
onItemClick(item, ev);
}
};
_this._renderAriaDescription = function (ariaDescription, className) {
ariaDescriptionSpan
return ariaDescription ? (React.createElement("span", { id:
_this._ariaDescriptionId, className: className }, ariaDescription)) : null;
};
return _this;
}
ContextualMenuAnchor.prototype.render = function () {
var _this = this;
var _a = this.props, item = _a.item, classNames = _a.classNames, index =
_a.index, focusableElementIndex = _a.focusableElementIndex, totalItemCount =
_a.totalItemCount, hasCheckmarks = _a.hasCheckmarks, hasIcons = _a.hasIcons, _b =
_a.contextualMenuItemAs, ChildrenRenderer = _b === void 0 ?
ContextualMenuItem_1.ContextualMenuItem : _b, expandedMenuItemKey =
_a.expandedMenuItemKey, onItemClick = _a.onItemClick, openSubMenu = _a.openSubMenu,
dismissSubMenu = _a.dismissSubMenu, dismissMenu = _a.dismissMenu;
var anchorRel = item.rel;
if (item.target && item.target.toLowerCase() === '_blank') {
anchorRel = anchorRel ? anchorRel : 'nofollow noopener noreferrer'; //
Safe default to prevent tabjacking
}
var itemHasSubmenu = index_1.hasSubmenu(item);
var nativeProps = Utilities_1.getNativeProps(item,
Utilities_1.anchorProperties);
var disabled = index_1.isItemDisabled(item);
var itemProps = item.itemProps, ariaDescription = item.ariaDescription;
var keytipProps = item.keytipProps;
if (keytipProps && itemHasSubmenu) {
}
// Check for ariaDescription to set the _ariaDescriptionId and render a
hidden span with
// the description in it to be added to ariaDescribedBy
this._ariaDescriptionId = Utilities_1.getId();
}
var ariaDescribedByIds =
Utilities_1.mergeAriaAttributeValues(item.ariaDescribedBy, ariaDescription ?
this._ariaDescriptionId : undefined, nativeProps['aria-describedby']);
var additionalItemProperties = {
'aria-describedby': ariaDescribedByIds,
};
return (React.createElement("div", null,
React.createElement(KeytipData_1.KeytipData, { keytipProps:
item.keytipProps, ariaDescribedBy: ariaDescribedByIds, disabled: disabled },
function (keytipAttributes) { return (React.createElement("a", tslib_1.__assign({},
additionalItemProperties, nativeProps, keytipAttributes, { ref: _this._anchor,
href: item.href, target: item.target, rel: anchorRel, className: classNames.root,
role: "menuitem", "aria-haspopup": itemHasSubmenu || undefined, "aria-expanded":
itemHasSubmenu ? item.key === expandedMenuItemKey : undefined, "aria-posinset":
focusableElementIndex + 1, "aria-setsize": totalItemCount, "aria-disabled":
index_1.isItemDisabled(item),
style: item.style, onClick: _this._onItemClick, onMouseEnter:
_this._onItemMouseEnter, onMouseLeave: _this._onItemMouseLeave, onMouseMove:
_this._onItemMouseMove, onKeyDown: itemHasSubmenu ? _this._onItemKeyDown :
undefined }),
React.createElement(ChildrenRenderer,
tslib_1.__assign({ componentRef: item.componentRef, item: item, classNames:
classNames, index: index, onCheckmarkClick: hasCheckmarks && onItemClick ?
onItemClick : undefined, hasIcons: hasIcons, openSubMenu: openSubMenu,
dismissSubMenu: dismissSubMenu, dismissMenu: dismissMenu, getSubmenuTarget:
_this._getSubmenuTarget }, itemProps)),
_this._renderAriaDescription(ariaDescription,
classNames.screenReaderText))); })));
};
return ContextualMenuAnchor;
}(ContextualMenuItemWrapper_1.ContextualMenuItemWrapper));
exports.ContextualMenuAnchor = ContextualMenuAnchor;
//# sourceMappingURL=ContextualMenuAnchor.js.map
/***/ }),
/***/ 4140:
"use strict";

exports.ContextualMenuButton = void 0;
var ContextualMenuButton = /** @class */ (function (_super) {
tslib_1.__extends(ContextualMenuButton, _super);
function ContextualMenuButton() {
_this._btn = React.createRef();
true });
});
ariaDescriptionSpan
};
return _this._btn.current ? _this._btn.current : undefined;
};
return _this;
}
ContextualMenuButton.prototype.render = function () {
var _this = this;
_a.totalItemCount, hasCheckmarks = _a.hasCheckmarks, hasIcons = _a.hasIcons, _b =
_a.contextualMenuItemAs, ChildrenRenderer = _b === void 0 ?
ContextualMenuItem_1.ContextualMenuItem : _b, expandedMenuItemKey =
_a.expandedMenuItemKey, onItemMouseDown = _a.onItemMouseDown, onItemClick =
_a.onItemClick, openSubMenu = _a.openSubMenu, dismissSubMenu = _a.dismissSubMenu,
dismissMenu = _a.dismissMenu;
var isChecked = index_1.getIsChecked(item);
var canCheck = isChecked !== null;
var defaultRole = index_1.getMenuItemAriaRole(item);
var itemProps = item.itemProps, ariaLabel = item.ariaLabel, ariaDescription
= item.ariaDescription;
var buttonNativeProperties = Utilities_1.getNativeProps(item,
Utilities_1.buttonProperties);
// Do not add the disabled attribute to the button so that it is focusable
delete buttonNativeProperties.disabled;
var itemRole = item.role || defaultRole;
hidden span with
}
var ariaDescribedByIds =
this._ariaDescriptionId : undefined, buttonNativeProperties['aria-describedby']);
var itemButtonProperties = {
className: classNames.root,
onClick: this._onItemClick,
onKeyDown: itemHasSubmenu ? this._onItemKeyDown : undefined,
onMouseEnter: this._onItemMouseEnter,
onMouseLeave: this._onItemMouseLeave,
onMouseDown: function (ev) {
return onItemMouseDown ? onItemMouseDown(item, ev) : undefined;
},
onMouseMove: this._onItemMouseMove,
href: item.href,
title: item.title,
'aria-label': ariaLabel,
'aria-describedby': ariaDescribedByIds,
'aria-haspopup': itemHasSubmenu || undefined,
'aria-expanded': itemHasSubmenu ? item.key === expandedMenuItemKey :
undefined,
'aria-posinset': focusableElementIndex + 1,
'aria-setsize': totalItemCount,
'aria-disabled': index_1.isItemDisabled(item),
'aria-checked': (itemRole === 'menuitemcheckbox' || itemRole ===
'menuitemradio') && canCheck ? !!isChecked : undefined,
'aria-selected': itemRole === 'menuitem' && canCheck ? !!isChecked :
undefined,
role: itemRole,
style: item.style,
};
if (keytipProps && itemHasSubmenu) {
}
return (React.createElement(KeytipData_1.KeytipData, { keytipProps:
keytipProps, ariaDescribedBy: ariaDescribedByIds, disabled:
index_1.isItemDisabled(item) }, function (keytipAttributes) { return
(React.createElement("button", tslib_1.__assign({ ref: _this._btn },
buttonNativeProperties, itemButtonProperties, keytipAttributes),
React.createElement(ChildrenRenderer, tslib_1.__assign({ componentRef:
item.componentRef, item: item, classNames: classNames, index: index,
onCheckmarkClick: hasCheckmarks && onItemClick ? onItemClick : undefined, hasIcons:
hasIcons, openSubMenu: openSubMenu, dismissSubMenu: dismissSubMenu, dismissMenu:
dismissMenu, getSubmenuTarget: _this._getSubmenuTarget }, itemProps)),
classNames.screenReaderText))); }));
};
return ContextualMenuButton;
exports.ContextualMenuButton = ContextualMenuButton;
//# sourceMappingURL=ContextualMenuButton.js.map
/***/ }),
/***/ 19932:
"use strict";

exports.ContextualMenuItemWrapper = void 0;
var ContextualMenuItemWrapper = /** @class */ (function (_super) {
tslib_1.__extends(ContextualMenuItemWrapper, _super);
function ContextualMenuItemWrapper(props) {
_this._onItemMouseEnter = function (ev) {
var _a = _this.props, item = _a.item, onItemMouseEnter =
_a.onItemMouseEnter;
if (onItemMouseEnter) {
onItemMouseEnter(item, ev, ev.currentTarget);
}
};
_this._onItemClick = function (ev) {
var _a = _this.props, item = _a.item, onItemClickBase =
_a.onItemClickBase;
if (onItemClickBase) {
onItemClickBase(item, ev, ev.currentTarget);
}
};
_this._onItemMouseLeave = function (ev) {
var _a = _this.props, item = _a.item, onItemMouseLeave =
_a.onItemMouseLeave;
if (onItemMouseLeave) {
onItemMouseLeave(item, ev);
}
};
_this._onItemKeyDown = function (ev) {
var _a = _this.props, item = _a.item, onItemKeyDown = _a.onItemKeyDown;
if (onItemKeyDown) {
onItemKeyDown(item, ev);
}
};
_this._onItemMouseMove = function (ev) {
var _a = _this.props, item = _a.item, onItemMouseMove =
_a.onItemMouseMove;
if (onItemMouseMove) {
onItemMouseMove(item, ev, ev.currentTarget);
}
};
return undefined;
};
return _this;
}
ContextualMenuItemWrapper.prototype.shouldComponentUpdate = function (newProps)
{
return !Utilities_1.shallowCompare(newProps, this.props);
};
return ContextualMenuItemWrapper;
exports.ContextualMenuItemWrapper = ContextualMenuItemWrapper;
//# sourceMappingURL=ContextualMenuItemWrapper.js.map
/***/ }),
/***/ 77728:
"use strict";

//# sourceMappingURL=ContextualMenuItemWrapper.types.js.map
/***/ }),
/***/ 56441:
"use strict";

exports.ContextualMenuSplitButton = void 0;
var Divider_1 = __webpack_require__(80028);
var ContextualMenuSplitButton = /** @class */ (function (_super) {
tslib_1.__extends(ContextualMenuSplitButton, _super);
function ContextualMenuSplitButton(props) {
true });
});
_this._onItemKeyDown = function (ev) {
var _a = _this.props, item = _a.item, onItemKeyDown = _a.onItemKeyDown;
_this._executeItemClick(ev);
}
else if (onItemKeyDown) {
onItemKeyDown(item, ev);
}
};
return _this._splitButton;
};
ariaDescriptionSpan
};
_this._onItemMouseEnterPrimary = function (ev) {
onItemMouseEnter(tslib_1.__assign(tslib_1.__assign({}, item),
{ subMenuProps: undefined, items: undefined }), ev, _this._splitButton);
}
};
_this._onItemMouseEnterIcon = function (ev) {
onItemMouseEnter(item, ev, _this._splitButton);
}
};
_this._onItemMouseMovePrimary = function (ev) {
_a.onItemMouseMove;
onItemMouseMove(tslib_1.__assign(tslib_1.__assign({}, item),
{ subMenuProps: undefined, items: undefined }), ev, _this._splitButton);
}
};
_this._onItemMouseMoveIcon = function (ev) {
_a.onItemMouseMove;
onItemMouseMove(item, ev, _this._splitButton);
}
};
_this._onIconItemClick = function (ev) {
var _a = _this.props, item = _a.item, onItemClickBase =
_a.onItemClickBase;
if (onItemClickBase) {
onItemClickBase(item, ev, (_this._splitButton ?
_this._splitButton : ev.currentTarget));
}
};
_this._executeItemClick = function (ev) {
var _a = _this.props, item = _a.item, executeItemClick =
_a.executeItemClick, onItemClick = _a.onItemClick;
if (item.disabled || item.isDisabled) {
return;
}
if (_this._processingTouch && onItemClick) {
return onItemClick(item, ev);
}
if (executeItemClick) {
}
};
_this._onTouchStart = function (ev) {
if (_this._splitButton && !('onpointerdown' in _this._splitButton)) {
_this._handleTouchAndPointerEvent(ev);
}
};
_this._handleTouchAndPointerEvent(ev);
}
};
return _this;
}
ContextualMenuSplitButton.prototype.componentDidMount = function () {
if (this._splitButton && 'onpointerdown' in this._splitButton) {
this._events.on(this._splitButton, 'pointerdown', this._onPointerDown,
true);
}
};
ContextualMenuSplitButton.prototype.componentWillUnmount = function () {
};
ContextualMenuSplitButton.prototype.render = function () {
var _this = this;
_a.totalItemCount, hasCheckmarks = _a.hasCheckmarks, hasIcons = _a.hasIcons,
onItemMouseLeave = _a.onItemMouseLeave, expandedMenuItemKey =
_a.expandedMenuItemKey;
if (keytipProps) {
}
hidden span with
var ariaDescription = item.ariaDescription;
}
return (React.createElement(KeytipData_1.KeytipData, { keytipProps:
keytipProps, disabled: index_1.isItemDisabled(item) }, function (keytipAttributes)
{ return (React.createElement("div", { "data-ktp-target": keytipAttributes['data-
ktp-target'], ref: function (splitButton) { return (_this._splitButton =
splitButton); }, role: index_1.getMenuItemAriaRole(item), "aria-label":
item.ariaLabel, className: classNames.splitContainer, "aria-disabled":
index_1.isItemDisabled(item), "aria-expanded": itemHasSubmenu ? item.key ===
expandedMenuItemKey : undefined, "aria-haspopup": true, "aria-describedby":
_this._ariaDescriptionId : undefined, keytipAttributes['aria-describedby']), "aria-
checked": item.isChecked || item.checked, "aria-posinset": focusableElementIndex +
1, "aria-setsize": totalItemCount, onMouseEnter: _this._onItemMouseEnterPrimary,
onMouseLeave: onItemMouseLeave ? onItemMouseLeave.bind(_this,
tslib_1.__assign(tslib_1.__assign({}, item), { subMenuProps: null, items:
null })) : undefined, onMouseMove: _this._onItemMouseMovePrimary, onKeyDown:
_this._onItemKeyDown, onClick: _this._executeItemClick, onTouchStart:
_this._onTouchStart, tabIndex: 0, "data-is-focusable": true, "aria-
roledescription": item['aria-roledescription'] },
_this._renderSplitPrimaryButton(item, classNames, index, hasCheckmarks,
hasIcons),
_this._renderSplitDivider(item),
_this._renderSplitIconButton(item, classNames, index,
keytipAttributes),
classNames.screenReaderText))); }));
};
ContextualMenuSplitButton.prototype._renderSplitPrimaryButton = function (item,
classNames, index, hasCheckmarks, hasIcons) {
var _a = this.props, _b = _a.contextualMenuItemAs, ChildrenRenderer = _b
=== void 0 ? ContextualMenuItem_1.ContextualMenuItem : _b, onItemClick =
_a.onItemClick;
var itemProps = {
key: item.key,
disabled: index_1.isItemDisabled(item) || item.primaryDisabled,
name: item.name,
text: item.text || item.name,
secondaryText: item.secondaryText,
className: classNames.splitPrimary,
canCheck: item.canCheck,
isChecked: item.isChecked,
checked: item.checked,
iconProps: item.iconProps,
onRenderIcon: item.onRenderIcon,
data: item.data,
};
var itemComponentProps = item.itemProps;
return (React.createElement("button", tslib_1.__assign({},
Utilities_1.getNativeProps(itemProps, Utilities_1.buttonProperties)),
React.createElement(ChildrenRenderer, tslib_1.__assign({ "data-is-
focusable": false, item: itemProps, classNames: classNames, index: index,
onCheckmarkClick: hasCheckmarks && onItemClick ? onItemClick : undefined, hasIcons:
hasIcons }, itemComponentProps))));
};
ContextualMenuSplitButton.prototype._renderSplitDivider = function (item) {
var getDividerClassNames = item.getSplitButtonVerticalDividerClassNames ||
ContextualMenu_classNames_1.getSplitButtonVerticalDividerClassNames;
return React.createElement(Divider_1.VerticalDivider, { getClassNames:
getDividerClassNames });
};
ContextualMenuSplitButton.prototype._renderSplitIconButton = function (item,
classNames, // eslint-disable-line deprecation/deprecation
index, keytipAttributes) {
var _a = this.props, _b = _a.contextualMenuItemAs, ChildrenRenderer = _b
=== void 0 ? ContextualMenuItem_1.ContextualMenuItem : _b, onItemMouseLeave =
_a.onItemMouseLeave, onItemMouseDown = _a.onItemMouseDown, openSubMenu =
_a.openSubMenu, dismissSubMenu = _a.dismissSubMenu, dismissMenu = _a.dismissMenu;
var itemProps = {
onClick: this._onIconItemClick,
disabled: index_1.isItemDisabled(item),
className: classNames.splitMenu,
subMenuProps: item.subMenuProps,
submenuIconProps: item.submenuIconProps,
split: true,
key: item.key,
};
var buttonProps = tslib_1.__assign(tslib_1.__assign({},
Utilities_1.getNativeProps(itemProps, Utilities_1.buttonProperties)), {
onMouseEnter: this._onItemMouseEnterIcon,
onMouseLeave: onItemMouseLeave ? onItemMouseLeave.bind(this, item) :
undefined,
onMouseDown: function (ev) {
return onItemMouseDown ? onItemMouseDown(item, ev) : undefined;
},
onMouseMove: this._onItemMouseMoveIcon,
'data-ktp-execute-target': keytipAttributes['data-ktp-execute-target'],
'aria-hidden': true,
});
var itemComponentProps = item.itemProps;
return (React.createElement("button", tslib_1.__assign({}, buttonProps),
React.createElement(ChildrenRenderer, tslib_1.__assign({ componentRef:
item.componentRef, item: itemProps, classNames: classNames, index: index, hasIcons:
false, openSubMenu: openSubMenu, dismissSubMenu: dismissSubMenu, dismissMenu:
dismissMenu, getSubmenuTarget: this._getSubmenuTarget }, itemComponentProps))));
};
ContextualMenuSplitButton.prototype._handleTouchAndPointerEvent = function (ev)
{
var _this = this;
var onTap = this.props.onTap;
if (onTap) {
onTap(ev);
}
// If we already have an existing timeout from a previous touch/pointer
event
// cancel that timeout so we can set a new one.
if (this._lastTouchTimeoutId) {
}
}, TouchIdleDelay);
};
return ContextualMenuSplitButton;
exports.ContextualMenuSplitButton = ContextualMenuSplitButton;
//# sourceMappingURL=ContextualMenuSplitButton.js.map
/***/ }),
/***/ 46728:
"use strict";

/***/ }),
/***/ 33813:
"use strict";

exports.getMenuItemStyles = void 0;
Object.defineProperty(exports, "getMenuItemStyles", ({ enumerable: true, get:
function () { return ContextualMenu_cnstyles_1.getMenuItemStyles; } }));
/***/ }),
/***/ 94723:
"use strict";

exports.DatePickerBase = void 0;
var Calendar_1 = __webpack_require__(88210);
allowTextInput: false,
formatDate: function (date) { return (date ? date.toDateString() : ''); },
parseDateFromString: function (dateStr) {
var date = Date.parse(dateStr);
return date ? new Date(date) : null;
},
initialPickerDate: new Date(),
isRequired: false,
isMonthPickerVisible: true,
showMonthPickerAsOverlay: false,
strings: defaults_1.defaultDatePickerStrings,
highlightCurrentMonth: false,
highlightSelectedMonth: false,
borderless: false,
pickerAriaLabel: 'Calendar',
showWeekNumbers: false,
firstWeekOfYear: date_time_utilities_1.FirstWeekOfYear.FirstDay,
showGoToToday: true,
underlined: false,
allFocusable: false,
};
function useFocusLogic() {
var textFieldRef = React.useRef(null);
var preventFocusOpeningPicker = React.useRef(false);
var focus = function () {
var _a, _b;
(_b = (_a = textFieldRef.current) === null || _a === void 0 ? void 0 :
};
var preventNextFocusOpeningPicker = function () {
preventFocusOpeningPicker.current = true;
};
return [textFieldRef, focus, preventFocusOpeningPicker,
preventNextFocusOpeningPicker];
}
function useCalendarVisibility(_a, focus) {
var allowTextInput = _a.allowTextInput, onAfterMenuDismiss =
_a.onAfterMenuDismiss;
var _b = React.useState(false), isCalendarShown = _b[0], setIsCalendarShown =
_b[1];
var isMounted = React.useRef(false);
if (isMounted.current && !isCalendarShown) {
// In browsers like IE, textfield gets unfocused when datepicker is
collapsed
if (allowTextInput) {
async.requestAnimationFrame(focus);
}
// If DatePicker's menu (Calendar) is closed, run onAfterMenuDismiss
onAfterMenuDismiss === null || onAfterMenuDismiss === void 0 ? void 0 :
onAfterMenuDismiss();
}
isMounted.current = true;
}, [isCalendarShown]);
return [isCalendarShown, setIsCalendarShown];
}
function useSelectedDate(_a) {
var formatDate = _a.formatDate, value = _a.value, onSelectDate =
_a.onSelectDate;
var _b = react_hooks_1.useControllableValue(value, undefined, function (ev,
newValue) {
return onSelectDate === null || onSelectDate === void 0 ? void 0 :
onSelectDate(newValue);
}), selectedDate = _b[0], setSelectedDateState = _b[1];
var _c = React.useState(function () { return (value && formatDate ?
formatDate(value) : ''); }), formattedDate = _c[0], setFormattedDate = _c[1];
var setSelectedDate = function (newDate) {
setSelectedDateState(newDate);
setFormattedDate(newDate && formatDate ? formatDate(newDate) : '');
};
setFormattedDate(value && formatDate ? formatDate(value) : '');
}, [formatDate, value]);
return [selectedDate, formattedDate, setSelectedDate, setFormattedDate];
}
function useErrorMessage(_a, selectedDate, setSelectedDate, inputValue,
isCalendarShown) {
var isRequired = _a.isRequired, allowTextInput = _a.allowTextInput, strings =
_a.strings, parseDateFromString = _a.parseDateFromString, onSelectDate =
_a.onSelectDate, formatDate = _a.formatDate, minDate = _a.minDate, maxDate =
_a.maxDate;
var _b = React.useState(), errorMessage = _b[0], setErrorMessage = _b[1];
var _c = React.useState(), statusMessage = _c[0], setStatusMessage = _c[1];
var validateTextInput = function (date) {
if (date === void 0) { date = null; }
if (inputValue || date) {
// Don't parse if the selected date has the same formatted string
as what we're about to parse.
// The formatted string might be ambiguous (ex: "1/2/3" or "New
Year Eve") and the parser might
// not be able to come up with the exact same date.
if (selectedDate && !errorMessage && formatDate &&
formatDate(date !== null && date !== void 0 ? date : selectedDate) === inputValue)
{
return;
}
date = date || parseDateFromString(inputValue);
// Check if date is null, or date is Invalid Date
if (!date || isNaN(date.getTime())) {
// Reset invalid input field, if formatting is available
setSelectedDate(selectedDate);
// default the newer isResetStatusMessage string to
invalidInputErrorMessage for legacy support
var selectedText = formatDate ? formatDate(selectedDate) : '';
var statusText = strings.isResetStatusMessage
? utilities_1.format(strings.isResetStatusMessage,
inputValue, selectedText)
: strings.invalidInputErrorMessage || '';
setStatusMessage(statusText);
}
else {
// Check against optional date boundaries
if (isDateOutOfBounds(date, minDate, maxDate)) {
setErrorMessage(strings.isOutOfBoundsErrorMessage || ' ');
}
else {
setSelectedDate(date);
setErrorMessage(undefined);
setStatusMessage(undefined);
}
}
}
else {
// Only show error for empty inputValue if it is a required field
setErrorMessage(isRequired ? strings.isRequiredErrorMessage || '
' : undefined);
// If no input date string or input date string is invalid
// date variable will be null, callback should expect null value
for this case
onSelectDate(date);
}
}
else if (isRequired && !inputValue) {
// Check when DatePicker is a required field but has NO input value
setErrorMessage(strings.isRequiredErrorMessage || ' ');
}
else {
// Cleanup the error message and status message
}
};
if (isRequired && !selectedDate) {
setErrorMessage(strings.isRequiredErrorMessage || ' ');
}
else if (selectedDate && isDateOutOfBounds(selectedDate, minDate, maxDate))
{
setErrorMessage(strings.isOutOfBoundsErrorMessage || ' ');
}
else {
}
}, [
// We don't want to compare the date itself, since two instances of date at
the same time are not equal
minDate && date_time_utilities_1.getDatePartHashValue(minDate),
maxDate && date_time_utilities_1.getDatePartHashValue(maxDate),
selectedDate && date_time_utilities_1.getDatePartHashValue(selectedDate),
isRequired,
]);
return [
isCalendarShown ? undefined : errorMessage,
validateTextInput,
setErrorMessage,
isCalendarShown ? undefined : statusMessage,
setStatusMessage,
];
}
exports.DatePickerBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
var firstDayOfWeek = props.firstDayOfWeek, strings = props.strings, label =
props.label, theme = props.theme, className = props.className, styles =
props.styles, initialPickerDate = props.initialPickerDate, isRequired =
props.isRequired, disabled = props.disabled, ariaLabel = props.ariaLabel,
pickerAriaLabel = props.pickerAriaLabel, placeholder = props.placeholder,
allowTextInput = props.allowTextInput, borderless = props.borderless, minDate =
props.minDate, maxDate = props.maxDate, showCloseButton = props.showCloseButton,
calendarProps = props.calendarProps, calloutProps = props.calloutProps,
textFieldProps = props.textField, underlined = props.underlined, allFocusable =
props.allFocusable, _a = props.calendarAs, CalendarType = _a === void 0 ?
Calendar_1.Calendar : _a, tabIndex = props.tabIndex, _b = props.disableAutoFocus,
disableAutoFocus = _b === void 0 ? true : _b;
var id = react_hooks_1.useId('DatePicker', props.id);
var calloutId = react_hooks_1.useId('DatePicker-Callout');
var calendar = React.useRef(null);
var datePickerDiv = React.useRef(null);
var _c = useFocusLogic(), textFieldRef = _c[0], focus = _c[1],
preventFocusOpeningPicker = _c[2], preventNextFocusOpeningPicker = _c[3];
var _d = useCalendarVisibility(props, focus), isCalendarShown = _d[0],
setIsCalendarShown = _d[1];
var _e = useSelectedDate(props), selectedDate = _e[0], formattedDate = _e[1],
setSelectedDate = _e[2], setFormattedDate = _e[3];
var _f = useErrorMessage(props, selectedDate, setSelectedDate, formattedDate,
isCalendarShown), errorMessage = _f[0], validateTextInput = _f[1], setErrorMessage
= _f[2], statusMessage = _f[3], setStatusMessage = _f[4];
var showDatePickerPopup = React.useCallback(function () {
if (!isCalendarShown) {
preventNextFocusOpeningPicker();
setIsCalendarShown(true);
}
}, [isCalendarShown, preventNextFocusOpeningPicker, setIsCalendarShown]);
focus: focus,
reset: function () {
setIsCalendarShown(false);
setSelectedDate(undefined);
},
showDatePickerPopup: showDatePickerPopup,
}); }, [focus, setErrorMessage, setIsCalendarShown, setSelectedDate,
setStatusMessage, showDatePickerPopup]);
var onTextFieldFocus = function () {
if (disableAutoFocus) {
return;
}
if (!allowTextInput) {
if (!preventFocusOpeningPicker.current) {
showDatePickerPopup();
}
preventFocusOpeningPicker.current = false;
}
};
var onSelectDate = function (date) {
if (props.calendarProps && props.calendarProps.onSelectDate) {
props.calendarProps.onSelectDate(date);
}
calendarDismissed(date);
};
var onCalloutPositioned = function () {
var shouldFocus = true;
// If the user has specified that the callout shouldn't use initial focus,
then respect
// that and don't attempt to set focus. That will default to true within
the callout
// so we need to check if it's undefined here.
if (props.calloutProps && props.calloutProps.setInitialFocus !== undefined)
{
shouldFocus = props.calloutProps.setInitialFocus;
}
if (calendar.current && shouldFocus) {
calendar.current.focus();
}
};
var onTextFieldBlur = function (ev) {
validateTextInput();
};
var onTextFieldChanged = function (ev, newValue) {
var _a;
var textField = props.textField;
if (isCalendarShown) {
dismissDatePickerPopup();
}
setFormattedDate(newValue);
}
(_a = textField === null || textField === void 0 ? void 0 :
textField.onChange) === null || _a === void 0 ? void 0 : _a.call(textField, ev,
newValue);
};
var onTextFieldKeyDown = function (ev) {
switch (ev.which) {
if (!isCalendarShown) {
validateTextInput();
}
else {
// When DatePicker allows input date string directly,
// it is expected to hit another enter to close the popup
if (props.allowTextInput) {
}
}
break;
case utilities_1.KeyCodes.escape:
handleEscKey(ev);
break;
if (ev.altKey && !isCalendarShown) {
}
break;
default:
break;
}
};
var onTextFieldClick = function (ev) {
// default openOnClick to !props.disableAutoFocus for legacy support of
disableAutoFocus behavior
var openOnClick = props.openOnClick || !props.disableAutoFocus;
if (openOnClick && !isCalendarShown && !props.disabled) {
return;
}
if (props.allowTextInput) {
}
};
var onIconClick = function (ev) {
if (!isCalendarShown && !props.disabled) {
}
else if (props.allowTextInput) {
}
};
var dismissDatePickerPopup = function (newlySelectedDate) {
setIsCalendarShown(false);
validateTextInput(newlySelectedDate);
if (!allowTextInput && newlySelectedDate) {
setSelectedDate(newlySelectedDate);
}
}
};
var renderTextfieldDescription = function (inputProps, defaultRender) {
inputProps.description ? defaultRender(inputProps) : null,
React.createElement("div", { "aria-live": "assertive", className:
classNames.statusMessage }, statusMessage)));
};
var renderReadOnlyInput = function (inputProps) {
var divProps = utilities_1.getNativeProps(inputProps,
utilities_1.divProperties);
// Talkback on Android treats readonly inputs as disabled, so swipe
gestures to open the Calendar
// don't register. Workaround is rendering a div with role="combobox"
(passed in via TextField props).
return (React.createElement("div", tslib_1.__assign({}, divProps,
{ className: utilities_1.css(divProps.className, classNames.readOnlyTextField),
tabIndex: tabIndex || 0 }), formattedDate || (
// Putting the placeholder in a separate span fixes specificity issues for
the text color
React.createElement("span", { className: classNames.readOnlyPlaceholder },
placeholder))));
};
/**
* Callback for closing the calendar callout
*/
var calendarDismissed = function (newlySelectedDate) {
preventNextFocusOpeningPicker();
dismissDatePickerPopup(newlySelectedDate);
// don't need to focus the text box, if necessary the focusTrapZone will do
it
};
var calloutDismissed = function (ev) {
calendarDismissed();
};
var handleEscKey = function (ev) {
calendarDismissed();
}
};
theme: theme,
disabled: disabled,
underlined: underlined,
label: !!label,
isDatePickerShown: isCalendarShown,
});
var nativeProps = utilities_1.getNativeProps(props, utilities_1.divProperties,
['value']);
var iconProps = textFieldProps && textFieldProps.iconProps;
var textFieldId = textFieldProps && textFieldProps.id && textFieldProps.id !==
id ? textFieldProps.id : id + '-label';
var readOnly = !allowTextInput && !disabled;
return (React.createElement("div", tslib_1.__assign({}, nativeProps,
{ className: classNames.root, ref: forwardedRef }),
React.createElement("div", { ref: datePickerDiv, "aria-owns":
isCalendarShown ? calloutId : undefined, className: classNames.wrapper },
React.createElement(TextField_1.TextField, tslib_1.__assign({ role:
"combobox", label: label, "aria-expanded": isCalendarShown, ariaLabel: ariaLabel,
"aria-haspopup": "dialog", "aria-controls": isCalendarShown ? calloutId :
undefined, required: isRequired, disabled: disabled, errorMessage: errorMessage,
placeholder: placeholder, borderless: borderless, value: formattedDate,
componentRef: textFieldRef, underlined: underlined, tabIndex: tabIndex, readOnly: !
allowTextInput }, textFieldProps, { id: textFieldId, className:
utilities_1.css(classNames.textField, textFieldProps && textFieldProps.className),
iconProps: tslib_1.__assign(tslib_1.__assign({ iconName: 'Calendar' }, iconProps),
{ className: utilities_1.css(classNames.icon, iconProps && iconProps.className),
onClick: onIconClick }),
onRenderDescription: renderTextfieldDescription,
onKeyDown: onTextFieldKeyDown,
onFocus: onTextFieldFocus,
onBlur: onTextFieldBlur,
onClick: onTextFieldClick,
onChange: onTextFieldChanged, onRenderInput: readOnly ?
renderReadOnlyInput : undefined }))),
isCalendarShown && (React.createElement(Callout_1.Callout,
tslib_1.__assign({ id: calloutId, role: "dialog", ariaLabel: pickerAriaLabel,
isBeakVisible: false, gapSpace: 0, doNotLayer: false, target:
datePickerDiv.current, directionalHint: Callout_1.DirectionalHint.bottomLeftEdge },
calloutProps, { className: utilities_1.css(classNames.callout, calloutProps &&
calloutProps.className),
onDismiss: calloutDismissed,
onPositioned: onCalloutPositioned }),
{ isClickableOutsideFocusTrap: true, disableFirstFocus: disableAutoFocus },
React.createElement(CalendarType, tslib_1.__assign({},
calendarProps, {
onSelectDate: onSelectDate,
onDismiss: calendarDismissed, isMonthPickerVisible:
props.isMonthPickerVisible, showMonthPickerAsOverlay:
props.showMonthPickerAsOverlay, today: props.today, value: selectedDate ||
initialPickerDate, firstDayOfWeek: firstDayOfWeek, strings: strings,
highlightCurrentMonth: props.highlightCurrentMonth, highlightSelectedMonth:
props.highlightSelectedMonth, showWeekNumbers: props.showWeekNumbers,
firstWeekOfYear: props.firstWeekOfYear, showGoToToday: props.showGoToToday,
dateTimeFormatter: props.dateTimeFormatter, minDate: minDate, maxDate: maxDate,
componentRef: calendar, showCloseButton: showCloseButton, allFocusable:
allFocusable })))))));
});
exports.DatePickerBase.displayName = 'DatePickerBase';
function isDateOutOfBounds(date, minDate, maxDate) {
return (!!minDate && date_time_utilities_1.compareDatePart(minDate, date) > 0)
|| (!!maxDate && date_time_utilities_1.compareDatePart(maxDate, date) < 0);
}
//# sourceMappingURL=DatePicker.base.js.map
/***/ }),
/***/ 74832:
"use strict";

exports.DatePicker = void 0;
var DatePicker_base_1 = __webpack_require__(94723);
var DatePicker_styles_1 = __webpack_require__(68717);
exports.DatePicker = utilities_1.styled(DatePicker_base_1.DatePickerBase,
DatePicker_styles_1.styles, undefined, {
scope: 'DatePicker',
});
//# sourceMappingURL=DatePicker.js.map
/***/ }),
/***/ 68717:
"use strict";

root: 'ms-DatePicker',
callout: 'ms-DatePicker-callout',
withLabel: 'ms-DatePicker-event--with-label',
withoutLabel: 'ms-DatePicker-event--without-label',
disabled: 'msDatePickerDisabled ',
};
var TEXTFIELD_HEIGHT = 32;
var _a;
var className = props.className, theme = props.theme, disabled =
props.disabled, underlined = props.underlined, label = props.label,
isDatePickerShown = props.isDatePickerShown;
theme.fonts;
theme);
var DatePickerIcon = {
fontSize: style_utilities_1.FontSizes.icon,
lineHeight: '18px',
right: '4px',
padding: '5px',
};
return {
root: [classNames.root, theme.fonts.large, isDatePickerShown && 'is-open',
style_utilities_1.normalize, className],
textField: [
{
selectors: {
'& input[readonly]': {
cursor: 'pointer',
},
input: {
selectors: {
'::-ms-clear': {
display: 'none',
},
},
},
},
},
disabled && {
selectors: {
'& input[readonly]': {
cursor: 'default',
},
},
},
],
callout: [classNames.callout],
icon: [
DatePickerIcon,
label ? classNames.withLabel : classNames.withoutLabel,
{ paddingTop: '7px' },
!disabled && [
classNames.disabled,
{
pointerEvents: 'initial',
cursor: 'pointer',
},
],
disabled && {
cursor: 'default',
},
],
statusMessage: [
fonts.small,
{
color: semanticColors.errorText,
marginTop: 5,
},
],
readOnlyTextField: [
{
cursor: 'pointer',
height: TEXTFIELD_HEIGHT,
lineHeight: TEXTFIELD_HEIGHT - 2,
overflow: 'hidden',
},
underlined && {
lineHeight: TEXTFIELD_HEIGHT + 2,
},
],
readOnlyPlaceholder: (_a = {
color: semanticColors.inputPlaceholderText
},
color: 'GrayText',
},
_a),
};
};
//# sourceMappingURL=DatePicker.styles.js.map
/***/ }),
/***/ 66372:
"use strict";

//# sourceMappingURL=DatePicker.types.js.map
/***/ }),
/***/ 5998:
"use strict";

exports.defaultDatePickerStrings = void 0;
var Calendar_1 = __webpack_require__(88210);
exports.defaultDatePickerStrings = tslib_1.__assign(tslib_1.__assign({},
Calendar_1.defaultCalendarStrings), { prevMonthAriaLabel: 'Go to previous month',
nextMonthAriaLabel: 'Go to next month', prevYearAriaLabel: 'Go to previous year',
nextYearAriaLabel: 'Go to next year', closeButtonAriaLabel: 'Close date picker',
isRequiredErrorMessage: 'Field is required', invalidInputErrorMessage: 'Invalid
date format', isResetStatusMessage: 'Invalid entry "{0}", date reset to "{1}"' });
/***/ }),
/***/ 36656:
"use strict";

/***/ }),
/***/ 29663:
"use strict";

exports.DetailsColumnBase = void 0;
var DetailsList_types_1 = __webpack_require__(709);
var DetailsRow_styles_1 = __webpack_require__(57495);
var MOUSEDOWN_PRIMARY_BUTTON = 0; // for mouse down event we are using ev.button
property, 0 means left button
var TRANSITION_DURATION_DRAG = 200; // ms
var TRANSITION_DURATION_DROP = 1500; // ms
var CLASSNAME_ADD_INTERVAL = 20; // ms
var defaultOnRenderHeader = function (classNames) { return function (props) {
if (!props) {
return null;
}
if (props.column.isIconOnly) {
classNames.accessibleLabel }, props.column.name);
}
return React.createElement(React.Fragment, null, props.column.name);
}; };
/**
* Component for rendering columns in a `DetailsList`.
*
* {@docCategory DetailsList}
*/
var DetailsColumnBase = /** @class */ (function (_super) {
tslib_1.__extends(DetailsColumnBase, _super);
function DetailsColumnBase(props) {
_this._onRenderFilterIcon = function (classNames) { return function (props)
{
var columnProps = props.columnProps, iconProps = tslib_1.__rest(props,
["columnProps"]);
var IconComponent = (columnProps === null || columnProps === void 0 ?
void 0 : columnProps.useFastIcons) ? Icon_1.FontIcon : Icon_1.Icon;
return React.createElement(IconComponent, tslib_1.__assign({},
iconProps));
}; };
_this._onRenderColumnHeaderTooltip = function (tooltipHostProps) {
tooltipHostProps.hostClassName }, tooltipHostProps.children);
};
_this._onColumnClick = function (ev) {
var _a = _this.props, onColumnClick = _a.onColumnClick, column =
_a.column;
if (column.columnActionsMode ===
DetailsList_types_1.ColumnActionsMode.disabled) {
return;
}
if (column.onColumnClick) {
column.onColumnClick(ev, column);
}
if (onColumnClick) {
onColumnClick(ev, column);
}
};
_this._onDragStart = function (item, itemIndex, selectedItems, event) {
var classNames = _this._classNames;
if (itemIndex) {
_this._updateHeaderDragInfo(itemIndex);
_this._root.current.classList.add(classNames.borderWhileDragging);
if (_this._root.current) {
_this._root.current.classList.add(classNames.noBorderWhileDragging);
}
}, CLASSNAME_ADD_INTERVAL);
}
};
_this._onDragEnd = function (item, event) {
if (event) {
_this._updateHeaderDragInfo(-1, event);
}
_this._root.current.classList.remove(classNames.borderWhileDragging);
_this._root.current.classList.remove(classNames.noBorderWhileDragging);
};
_this._updateHeaderDragInfo = function (itemIndex, event) {
if (_this.props.setDraggedItemIndex) {
_this.props.setDraggedItemIndex(itemIndex);
}
if (_this.props.updateDragInfo) {
_this.props.updateDragInfo({ itemIndex: itemIndex }, event);
}
};
_this._onColumnContextMenu = function (ev) {
var _a = _this.props, onColumnContextMenu = _a.onColumnContextMenu,
column = _a.column;
if (column.onColumnContextMenu) {
column.onColumnContextMenu(column, ev);
}
if (onColumnContextMenu) {
onColumnContextMenu(column, ev);
}
};
_this._onRootMouseDown = function (ev) {
var isDraggable = _this.props.isDraggable;
// Ignore anything except the primary button.
if (isDraggable && ev.button === MOUSEDOWN_PRIMARY_BUTTON) {
}
};
return _this;
}
DetailsColumnBase.prototype.render = function () {
var _a = this.props, column = _a.column, parentId = _a.parentId,
isDraggable = _a.isDraggable, styles = _a.styles, theme = _a.theme, _b =
_a.cellStyleProps, cellStyleProps = _b === void 0 ?
DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _b, _c = _a.useFastIcons,
useFastIcons = _c === void 0 ? true : _c;
var _d = this.props.onRenderColumnHeaderTooltip,
onRenderColumnHeaderTooltip = _d === void 0 ? this._onRenderColumnHeaderTooltip :
_d;
theme: theme,
headerClassName: column.headerClassName,
iconClassName: column.iconClassName,
isActionable: column.columnActionsMode !==
DetailsList_types_1.ColumnActionsMode.disabled,
isEmpty: !column.name,
isIconVisible: column.isSorted || column.isGrouped ||
column.isFiltered,
isPadded: column.isPadded,
isIconOnly: column.isIconOnly,
cellStyleProps: cellStyleProps,
transitionDurationDrag: TRANSITION_DURATION_DRAG,
transitionDurationDrop: TRANSITION_DURATION_DROP,
});
var classNames = this._classNames;
var onRenderFilterIcon = column.onRenderFilterIcon
? Utilities_1.composeRenderFunction(column.onRenderFilterIcon,
this._onRenderFilterIcon(this._classNames))
: this._onRenderFilterIcon(this._classNames);
var onRenderHeader = column.onRenderHeader
? Utilities_1.composeRenderFunction(column.onRenderHeader,
defaultOnRenderHeader(this._classNames))
: defaultOnRenderHeader(this._classNames);
var hasInnerButton = column.columnActionsMode !==
DetailsList_types_1.ColumnActionsMode.disabled &&
(column.onColumnClick !== undefined || this.props.onColumnClick !==
undefined);
var accNameDescription = {
'aria-label': column.ariaLabel ? column.ariaLabel : column.isIconOnly ?
column.name : undefined,
'aria-labelledby': column.ariaLabel || column.isIconOnly ? undefined :
parentId + "-" + column.key + "-name",
'aria-describedby': !this.props.onRenderColumnHeaderTooltip &&
this._hasAccessibleDescription()
? parentId + "-" + column.key + "-tooltip"
: undefined,
};
React.createElement("div", tslib_1.__assign({ key: column.key, ref:
this._root, role: 'columnheader' }, (!hasInnerButton && accNameDescription),
{ "aria-sort": column.isSorted ? (column.isSortedDescending ? 'descending' :
'ascending') : 'none', "data-is-focusable": !hasInnerButton &&
column.columnActionsMode !== DetailsList_types_1.ColumnActionsMode.disabled ?
'true' : undefined, className: classNames.root, "data-is-draggable": isDraggable,
draggable: isDraggable, style: {
width: column.calculatedWidth +
cellStyleProps.cellLeftPadding +
cellStyleProps.cellRightPadding +
(column.isPadded ? cellStyleProps.cellExtraRightPadding :
0),
}, "data-automationid": 'ColumnsHeaderColumn', "data-item-key":
column.key }),
isDraggable && (React.createElement(IconComponent, { iconName:
"GripperBarVertical", className: classNames.gripperBarVerticalStyle })),
onRenderColumnHeaderTooltip({
hostClassName: classNames.cellTooltip,
id: parentId + "-" + column.key + "-tooltip",
setAriaDescribedBy: false,
column: column,
content: column.columnActionsMode !==
DetailsList_types_1.ColumnActionsMode.disabled ? column.ariaLabel : '',
children: (React.createElement("span", tslib_1.__assign({ id:
parentId + "-" + column.key, className: classNames.cellTitle, "data-is-focusable":
hasInnerButton && column.columnActionsMode !==
DetailsList_types_1.ColumnActionsMode.disabled ? 'true' : undefined, role:
hasInnerButton ? 'button' : undefined }, (hasInnerButton && accNameDescription),
{ onContextMenu: this._onColumnContextMenu, onClick: this._onColumnClick, "aria-
haspopup": column.columnActionsMode ===
DetailsList_types_1.ColumnActionsMode.hasDropdown ? 'menu' : undefined, "aria-
expanded": column.columnActionsMode ===
DetailsList_types_1.ColumnActionsMode.hasDropdown ? !!column.isMenuOpen : undefined
}),
React.createElement("span", { id: parentId + "-" +
column.key + "-name", className: classNames.cellName },
(column.iconName || column.iconClassName) &&
(React.createElement(IconComponent, { className: classNames.iconClassName,
iconName: column.iconName })),
onRenderHeader(this.props)),
column.isFiltered && React.createElement(IconComponent,
{ className: classNames.nearIcon, iconName: "Filter" }),
(column.isSorted || column.showSortIconWhenUnsorted) &&
(React.createElement(IconComponent, { className: classNames.sortIcon, iconName:
column.isSorted ? (column.isSortedDescending ? 'SortDown' : 'SortUp') : 'Sort' })),
column.isGrouped && React.createElement(IconComponent,
{ className: classNames.nearIcon, iconName: "GroupedDescending" }),
column.columnActionsMode ===
DetailsList_types_1.ColumnActionsMode.hasDropdown &&
!column.isIconOnly &&
onRenderFilterIcon({
columnProps: this.props,
className: classNames.filterChevron,
iconName: 'ChevronDown',
}))),
}, this._onRenderColumnHeaderTooltip)),
!this.props.onRenderColumnHeaderTooltip ?
this._renderAccessibleDescription() : null));
};
DetailsColumnBase.prototype.componentDidMount = function () {
var _this = this;
if (this.props.dragDropHelper && this.props.isDraggable) {
this._addDragDropHandling();
}
if (this.props.isDropped) {
this._root.current.classList.add(classNames.borderAfterDropping);
this._async.setTimeout(function () {
_this._root.current.classList.add(classNames.noBorderAfterDropping);
}
}, CLASSNAME_ADD_INTERVAL);
}
_this._root.current.classList.remove(classNames.borderAfterDropping);
_this._root.current.classList.remove(classNames.noBorderAfterDropping);
}
}, TRANSITION_DURATION_DROP + CLASSNAME_ADD_INTERVAL);
}
};
DetailsColumnBase.prototype.componentWillUnmount = function () {
if (this._dragDropSubscription) {
this._dragDropSubscription.dispose();
delete this._dragDropSubscription;
}
};
DetailsColumnBase.prototype.componentDidUpdate = function () {
if (!this._dragDropSubscription && this.props.dragDropHelper &&
this.props.isDraggable) {
this._addDragDropHandling();
}
if (this._dragDropSubscription && !this.props.isDraggable) {
this._events.off(this._root.current, 'mousedown');
}
};
DetailsColumnBase.prototype._getColumnDragDropOptions = function () {
var _this = this;
var columnIndex = this.props.columnIndex;
var options = {
selectionIndex: columnIndex,
context: { data: columnIndex, index: columnIndex },
canDrag: function () { return _this.props.isDraggable; },
canDrop: function () { return false; },
onDragStart: this._onDragStart,
updateDropState: function () { return undefined; },
onDrop: function () { return undefined; },
onDragEnd: this._onDragEnd,
};
return options;
};
DetailsColumnBase.prototype._hasAccessibleDescription = function () {
var column = this.props.column;
return !!(column.filterAriaLabel ||
column.sortAscendingAriaLabel ||
column.sortDescendingAriaLabel ||
column.groupAriaLabel ||
column.sortableAriaLabel);
};
DetailsColumnBase.prototype._renderAccessibleDescription = function () {
var _a = this.props, column = _a.column, parentId = _a.parentId;
return this._hasAccessibleDescription() && !
this.props.onRenderColumnHeaderTooltip ? (React.createElement("label", { key:
column.key + "_label", id: parentId + "-" + column.key + "-tooltip", className:
classNames.accessibleLabel, hidden: true },
(column.isFiltered && column.filterAriaLabel) || null,
((column.isSorted || column.showSortIconWhenUnsorted) &&
(column.isSorted
? column.isSortedDescending
? column.sortDescendingAriaLabel
: column.sortAscendingAriaLabel
: column.sortableAriaLabel)) ||
null,
(column.isGrouped && column.groupAriaLabel) || null)) : null;
};
DetailsColumnBase.prototype._addDragDropHandling = function () {
this._dragDropSubscription =
this.props.dragDropHelper.subscribe(this._root.current, this._events,
this._getColumnDragDropOptions());
// We need to use native on this to prevent MarqueeSelection from handling
the event before us.
this._events.on(this._root.current, 'mousedown', this._onRootMouseDown);
};
return DetailsColumnBase;
exports.DetailsColumnBase = DetailsColumnBase;
//# sourceMappingURL=DetailsColumn.base.js.map
/***/ }),
/***/ 10093:
"use strict";

exports.DetailsColumn = void 0;
var DetailsColumn_base_1 = __webpack_require__(29663);
var DetailsColumn_styles_1 = __webpack_require__(3667);
exports.DetailsColumn = Utilities_1.styled(DetailsColumn_base_1.DetailsColumnBase,
DetailsColumn_styles_1.getDetailsColumnStyles, undefined, { scope:
'DetailsColumn' });
//# sourceMappingURL=DetailsColumn.js.map
/***/ }),
/***/ 3667:
"use strict";

exports.getDetailsColumnStyles = void 0;
var DetailsHeader_styles_1 = __webpack_require__(74057);
isActionable: 'is-actionable',
cellIsCheck: 'ms-DetailsHeader-cellIsCheck',
collapseButton: 'ms-DetailsHeader-collapseButton',
isCollapsed: 'is-collapsed',
isAllSelected: 'is-allSelected',
isSelectAllHidden: 'is-selectAllHidden',
isResizingColumn: 'is-resizingColumn',
isEmpty: 'is-empty',
isIconVisible: 'is-icon-visible',
cellSizer: 'ms-DetailsHeader-cellSizer',
isResizing: 'is-resizing',
dropHintCircleStyle: 'ms-DetailsHeader-dropHintCircleStyle',
dropHintLineStyle: 'ms-DetailsHeader-dropHintLineStyle',
cellTitle: 'ms-DetailsHeader-cellTitle',
cellName: 'ms-DetailsHeader-cellName',
filterChevron: 'ms-DetailsHeader-filterChevron',
gripperBarVerticalStyle: 'ms-DetailsColumn-gripperBar',
nearIcon: 'ms-DetailsColumn-nearIcon',
};
var getDetailsColumnStyles = function (props) {
var _a;
var theme = props.theme, headerClassName = props.headerClassName, iconClassName
= props.iconClassName, isActionable = props.isActionable, isEmpty = props.isEmpty,
isIconVisible = props.isIconVisible, isPadded = props.isPadded, isIconOnly =
props.isIconOnly, _b = props.cellStyleProps, cellStyleProps = _b === void 0 ?
DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _b, transitionDurationDrag =
props.transitionDurationDrag, transitionDurationDrop =
props.transitionDurationDrop;
var semanticColors = theme.semanticColors, palette = theme.palette, fonts =
theme.fonts;
var colors = {
iconForegroundColor: semanticColors.bodySubtext,
headerForegroundColor: semanticColors.bodyText,
headerBackgroundColor: semanticColors.bodyBackground,
dropdownChevronForegroundColor: palette.neutralSecondary,
resizerColor: palette.neutralTertiaryAlt,
};
var nearIconStyle = {
color: colors.iconForegroundColor,
opacity: 1,
paddingLeft: 8,
};
var borderWhileDragging = {
outline: "1px solid " + palette.themePrimary,
};
var borderAfterDragOrDrop = {
outlineColor: 'transparent',
};
return {
root: [
DetailsHeader_styles_1.getCellStyles(props),
fonts.small,
isActionable && [
classNames.isActionable,
{
selectors: {
':hover': {
background: semanticColors.listHeaderBackgroundHovered,
},
':active': {
background: semanticColors.listHeaderBackgroundPressed,
},
},
},
],
isEmpty && [
classNames.isEmpty,
{
},
],
isIconVisible && classNames.isIconVisible,
isPadded && {
paddingRight: cellStyleProps.cellExtraRightPadding +
cellStyleProps.cellRightPadding,
},
{
selectors: {
':hover i[data-icon-name="GripperBarVertical"]': {
display: 'block',
},
},
},
headerClassName,
],
gripperBarVerticalStyle: {
display: 'none',
textAlign: 'left',
color: palette.neutralTertiary,
left: 1,
},
nearIcon: [classNames.nearIcon, nearIconStyle],
sortIcon: [
nearIconStyle,
{
paddingLeft: 4,
top: 1,
},
],
iconClassName: [
{
color: colors.iconForegroundColor,
opacity: 1,
},
iconClassName,
],
filterChevron: [
classNames.filterChevron,
{
color: colors.dropdownChevronForegroundColor,
paddingLeft: 6,
},
],
cellTitle: [
classNames.cellTitle,
tslib_1.__assign({ display: 'flex', flexDirection: 'row',
justifyContent: 'flex-start', alignItems: 'stretch', boxSizing: 'border-box',
overflow: 'hidden', padding: "0 " + cellStyleProps.cellRightPadding + "px 0 " +
cellStyleProps.cellLeftPadding + "px" }, (isIconOnly
? {
alignContent: 'flex-end',
maxHeight: '100%',
flexWrap: 'wrap-reverse',
}
: {})),
],
cellName: [
classNames.cellName,
{
flex: '0 1 auto',
overflow: 'hidden',
},
isIconOnly && {
_a["." + classNames.nearIcon] = {
paddingLeft: 0,
},
_a),
},
],
cellTooltip: {
display: 'block',
top: 0,
left: 0,
bottom: 0,
right: 0,
},
accessibleLabel: Styling_1.hiddenContentStyle,
borderWhileDragging: borderWhileDragging,
noBorderWhileDragging: [borderAfterDragOrDrop, { transition: "outline " +
transitionDurationDrag + "ms ease" }],
borderAfterDropping: borderWhileDragging,
noBorderAfterDropping: [borderAfterDragOrDrop, { transition: "outline " +
transitionDurationDrop + "ms ease" }],
};
};
exports.getDetailsColumnStyles = getDetailsColumnStyles;
//# sourceMappingURL=DetailsColumn.styles.js.map
/***/ }),
/***/ 46526:
"use strict";

//# sourceMappingURL=DetailsColumn.types.js.map
/***/ }),
/***/ 47776:
"use strict";

//# sourceMappingURL=DetailsFooter.types.js.map
/***/ }),
/***/ 59307:
"use strict";

exports.DetailsHeaderBase = void 0;
var GroupSpacer_1 = __webpack_require__(56388);
var GroupedList_1 = __webpack_require__(33893);
var DetailsRowCheck_1 = __webpack_require__(62570);
var Selection_1 = __webpack_require__(59398);
var DragDrop_1 = __webpack_require__(67337);
var DetailsColumn_1 = __webpack_require__(10093);
var DetailsHeader_types_1 = __webpack_require__(22403);
var MOUSEMOVE_PRIMARY_BUTTON = 1; // for mouse move event we are using ev.buttons
var NO_COLUMNS = [];
var DetailsHeaderBase = /** @class */ (function (_super) {
tslib_1.__extends(DetailsHeaderBase, _super);
function DetailsHeaderBase(props) {
_this._rootElement = React.createRef();
_this._rootComponent = React.createRef();
_this._draggedColumnIndex = -1;
_this._dropHintDetails = {};
_this._updateDroppingState = function (newValue, event) {
if (_this._draggedColumnIndex >= 0 && event.type !== 'drop' && !
newValue) {
_this._resetDropHints();
}
};
_this._onDragOver = function (item, event) {
if (_this._draggedColumnIndex >= 0) {
_this._computeDropHintToBeShown(event.clientX);
}
};
_this._onDrop = function (item, event) {
// Safe to assume this is defined since we're handling a drop event
var columnReorderProps = _this._getColumnReorderProps();
// Target index will not get changed if draggeditem is after target
item.
if (_this._draggedColumnIndex >= 0 && event) {
var targetIndex = _this._draggedColumnIndex >
_this._currentDropHintIndex
? _this._currentDropHintIndex
: _this._currentDropHintIndex - 1;
var isValidDrop = _this._isValidCurrentDropHintIndex();
if (isValidDrop) {
_this._onDropIndexInfo.sourceIndex = _this._draggedColumnIndex;
_this._onDropIndexInfo.targetIndex = targetIndex;
if (columnReorderProps.onColumnDrop) {
var dragDropDetails = {
draggedIndex: _this._draggedColumnIndex,
targetIndex: targetIndex,
};
columnReorderProps.onColumnDrop(dragDropDetails);
}
else if (columnReorderProps.handleColumnReorder) {
columnReorderProps.handleColumnReorder(_this._draggedColumnIndex, targetIndex);
}
}
}
};
_this._updateDragInfo = function (props, event) {
// Safe to assume this is defined since we're handling a drag event
var itemIndex = props.itemIndex;
if (itemIndex >= 0) {
// Column index is set based on the checkbox
_this._draggedColumnIndex = _this._isCheckboxColumnHidden() ?
itemIndex - 1 : itemIndex - 2;
_this._getDropHintPositions();
if (columnReorderProps.onColumnDragStart) {
columnReorderProps.onColumnDragStart(true);
}
}
else if (event && _this._draggedColumnIndex >= 0) {
if (columnReorderProps.onColumnDragEnd) {
var columnDragEndLocation = _this._isEventOnHeader(event);
columnReorderProps.onColumnDragEnd({ dropLocation:
columnDragEndLocation }, event);
}
}
};
_this._getDropHintPositions = function () {
var _a = _this.props.columns, columns = _a === void 0 ? NO_COLUMNS :
_a;
// Safe to assume this is defined since we're handling a drag/drop
event
var prevX = 0;
var prevMid = 0;
var prevRef;
var frozenColumnCountFromStart =
columnReorderProps.frozenColumnCountFromStart || 0;
var frozenColumnCountFromEnd =
columnReorderProps.frozenColumnCountFromEnd || 0;
for (var i = frozenColumnCountFromStart; i < columns.length -
frozenColumnCountFromEnd + 1; i++) {
if (_this._rootElement.current) {
var dropHintElement =
_this._rootElement.current.querySelectorAll('#columnDropHint_' + i)[0];
if (dropHintElement) {
if (i === frozenColumnCountFromStart) {
prevX = dropHintElement.offsetLeft;
prevMid = dropHintElement.offsetLeft;
prevRef = dropHintElement;
}
else {
var newMid = (dropHintElement.offsetLeft + prevX) / 2;
_this._dropHintDetails[i - 1] = {
originX: prevX,
startX: prevMid,
endX: newMid,
dropHintElementRef: prevRef,
};
prevMid = newMid;
prevRef = dropHintElement;
prevX = dropHintElement.offsetLeft;
if (i === columns.length - frozenColumnCountFromEnd) {
_this._dropHintDetails[i] = {
originX: prevX,
startX: prevMid,
endX: dropHintElement.offsetLeft,
dropHintElementRef: prevRef,
};
}
}
}
}
}
};
/**
* Based on the given cursor position, finds the nearest drop hint and
updates the state to make it visible
*/
_this._computeDropHintToBeShown = function (clientX) {
var isRtl = Utilities_1.getRTL(_this.props.theme);
if (_this._rootElement.current) {
var clientRect =
_this._rootElement.current.getBoundingClientRect();
var headerOriginX = clientRect.left;
var eventXRelativePosition = clientX - headerOriginX;
var currentDropHintIndex = _this._currentDropHintIndex;
if (_this._isValidCurrentDropHintIndex()) {
if (_liesBetween(isRtl, eventXRelativePosition,
_this._dropHintDetails[currentDropHintIndex].startX,
_this._dropHintDetails[currentDropHintIndex].endX)) {
return;
}
}
var _a = _this.props.columns, columns = _a === void 0 ?
NO_COLUMNS : _a;
// Safe to assume this is defined since we're handling a drag/drop
event
var frozenColumnCountFromStart =
columnReorderProps.frozenColumnCountFromStart || 0;
var frozenColumnCountFromEnd =
columnReorderProps.frozenColumnCountFromEnd || 0;
var currentIndex = frozenColumnCountFromStart;
var lastValidColumn = columns.length - frozenColumnCountFromEnd;
var indexToUpdate = -1;
if (_isBefore(isRtl, eventXRelativePosition,
_this._dropHintDetails[currentIndex].endX)) {
indexToUpdate = currentIndex;
}
else if (_isAfter(isRtl, eventXRelativePosition,
_this._dropHintDetails[lastValidColumn].startX)) {
indexToUpdate = lastValidColumn;
}
else if (_this._isValidCurrentDropHintIndex()) {
if (_this._dropHintDetails[currentDropHintIndex + 1] &&
_liesBetween(isRtl, eventXRelativePosition,
_this._dropHintDetails[currentDropHintIndex + 1].startX,
_this._dropHintDetails[currentDropHintIndex + 1].endX)) {
indexToUpdate = currentDropHintIndex + 1;
}
else if (_this._dropHintDetails[currentDropHintIndex - 1] &&
_liesBetween(isRtl, eventXRelativePosition,
_this._dropHintDetails[currentDropHintIndex - 1].startX,
_this._dropHintDetails[currentDropHintIndex - 1].endX)) {
indexToUpdate = currentDropHintIndex - 1;
}
}
if (indexToUpdate === -1) {
var startIndex = frozenColumnCountFromStart;
var endIndex = lastValidColumn;
while (startIndex < endIndex) {
var middleIndex = Math.ceil((endIndex + startIndex) / 2);
if (_liesBetween(isRtl, eventXRelativePosition,
_this._dropHintDetails[middleIndex].startX,
_this._dropHintDetails[middleIndex].endX)) {
indexToUpdate = middleIndex;
break;
}
else if (_isBefore(isRtl, eventXRelativePosition,
_this._dropHintDetails[middleIndex].originX)) {
endIndex = middleIndex;
}
else if (_isAfter(isRtl, eventXRelativePosition,
_this._dropHintDetails[middleIndex].originX)) {
startIndex = middleIndex;
}
}
}
if (indexToUpdate === _this._draggedColumnIndex || indexToUpdate
=== _this._draggedColumnIndex + 1) {
if (_this._isValidCurrentDropHintIndex()) {
}
}
else if (currentDropHintIndex !== indexToUpdate && indexToUpdate >=
0) {
_this._updateDropHintElement(_this._dropHintDetails[indexToUpdate].dropHintElementR
ef, 'inline-block');
_this._currentDropHintIndex = indexToUpdate;
}
}
};
_this._renderColumnSizer = function (_a) {
var _b;
var columnIndex = _a.columnIndex;
var _c = _this.props.columns, columns = _c === void 0 ? NO_COLUMNS :
_c;
var column = columns[columnIndex];
var columnResizeDetails = _this.state.columnResizeDetails;
return column.isResizable ? (React.createElement("div", { key:
column.key + "_sizer", "aria-hidden": true, role: "button", "data-is-focusable":
false, onClick: _stopPropagation, "data-sizer-index": columnIndex, onBlur:
_this._onSizerBlur, className: Utilities_1.css(classNames.cellSizer, columnIndex <
columns.length - 1 ? classNames.cellSizerStart : classNames.cellSizerEnd, (_b = {},
_b[classNames.cellIsResizing] = columnResizeDetails &&
columnResizeDetails.columnIndex === columnIndex,
_b)), onDoubleClick: _this._onSizerDoubleClick.bind(_this,
columnIndex) })) : null;
};
_this._onRenderColumnHeaderTooltip = function (tooltipHostProps) {
tooltipHostProps.hostClassName }, tooltipHostProps.children);
};
/**
* Called when the select all toggle is clicked.
*/
_this._onSelectAllClicked = function () {
var selection = _this.props.selection;
if (selection) {
selection.toggleAllSelected();
}
};
_this._onRootMouseDown = function (ev) {
var columnIndexAttr = ev.target.getAttribute('data-sizer-index');
var columnIndex = Number(columnIndexAttr);
var _a = _this.props.columns, columns = _a === void 0 ? NO_COLUMNS :
_a;
if (columnIndexAttr === null || ev.button !== MOUSEDOWN_PRIMARY_BUTTON)
{
return;
}
_this.setState({
columnResizeDetails: {
columnIndex: columnIndex,
columnMinWidth: columns[columnIndex].calculatedWidth,
originX: ev.clientX,
},
});
};
_this._onRootMouseMove = function (ev) {
var _a = _this.state, columnResizeDetails = _a.columnResizeDetails,
isSizing = _a.isSizing;
if (columnResizeDetails && !isSizing && ev.clientX !==
columnResizeDetails.originX) {
_this.setState({ isSizing: true });
}
};
_this._onRootKeyDown = function (ev) {
var _a = _this.state, columnResizeDetails = _a.columnResizeDetails,
isSizing = _a.isSizing;
var _b = _this.props, _c = _b.columns, columns = _c === void 0 ?
NO_COLUMNS : _c, onColumnResized = _b.onColumnResized;
var columnIndexAttr = ev.target.getAttribute('data-sizer-index');
if (!columnIndexAttr || isSizing) {
return;
}
var columnIndex = Number(columnIndexAttr);
if (!columnResizeDetails) {
_this.setState({
columnResizeDetails: {
columnIndex: columnIndex,
columnMinWidth: columns[columnIndex].calculatedWidth,
},
});
}
}
else {
var increment = void 0;
_this.setState({
columnResizeDetails: undefined,
});
}
else if (ev.which === Utilities_1.KeyCodes.left) {
increment = Utilities_1.getRTL(_this.props.theme) ? 1 : -1;
}
else if (ev.which === Utilities_1.KeyCodes.right) {
increment = Utilities_1.getRTL(_this.props.theme) ? -1 : 1;
}
if (increment) {
if (!ev.shiftKey) {
increment *= 10;
}
_this.setState({
columnResizeDetails: tslib_1.__assign(tslib_1.__assign({},
columnResizeDetails), { columnMinWidth: columnResizeDetails.columnMinWidth +
increment }),
});
if (onColumnResized) {
onColumnResized(columns[columnIndex],
columnResizeDetails.columnMinWidth + increment, columnIndex);
}
}
}
};
/**
* mouse move event handler in the header
* it will set isSizing state to true when user clicked on the sizer and
move the mouse.
*
* @param ev - mouse move event
*/
_this._onSizerMouseMove = function (ev) {
var
// use buttons property here since ev.button in some edge case is not
upding well during the move.
// but firefox doesn't support it, so we set the default value when it
is not defined.
buttons = ev.buttons;
var _a = _this.props, onColumnIsSizingChanged =
_a.onColumnIsSizingChanged, onColumnResized = _a.onColumnResized, _b = _a.columns,
columns = _b === void 0 ? NO_COLUMNS : _b;
if (buttons !== undefined && buttons !== MOUSEMOVE_PRIMARY_BUTTON) {
// cancel mouse down event and return early when the primary button
is not pressed
_this._onSizerMouseUp(ev);
return;
}
if (ev.clientX !== columnResizeDetails.originX) {
if (onColumnIsSizingChanged) {
onColumnIsSizingChanged(columns[columnResizeDetails.columnIndex], true);
}
}
if (onColumnResized) {
var movement = ev.clientX - columnResizeDetails.originX;
if (Utilities_1.getRTL(_this.props.theme)) {
movement = -movement;
}
onColumnResized(columns[columnResizeDetails.columnIndex],
columnResizeDetails.columnMinWidth + movement, columnResizeDetails.columnIndex);
}
};
_this._onSizerBlur = function (ev) {
if (columnResizeDetails) {
_this.setState({
isSizing: false,
});
}
};
/**
* mouse up event handler in the header
* clear the resize related state.
* This is to ensure we can catch double click event
*
* @param ev - mouse up event
*/
_this._onSizerMouseUp = function (ev) {
var _a = _this.props, _b = _a.columns, columns = _b === void 0 ?
NO_COLUMNS : _b, onColumnIsSizingChanged = _a.onColumnIsSizingChanged;
_this.setState({
isSizing: false,
});
if (onColumnIsSizingChanged) {
onColumnIsSizingChanged(columns[columnResizeDetails.columnIndex],
false);
}
};
_this._onToggleCollapseAll = function () {
var onToggleCollapseAll = _this.props.onToggleCollapseAll;
var newCollapsed = !_this.state.isAllCollapsed;
_this.setState({
isAllCollapsed: newCollapsed,
});
if (onToggleCollapseAll) {
onToggleCollapseAll(newCollapsed);
}
};
_this.state = {
isAllCollapsed: _this.props.isAllCollapsed,
isAllSelected: !!_this.props.selection &&
_this.props.selection.isAllSelected(),
};
_this._onDropIndexInfo = {
sourceIndex: -1,
targetIndex: -1,
};
_this._id = Utilities_1.getId('header');
_this._currentDropHintIndex = -1;
// The drag drop handler won't do any work until subscribe() is called,
// so always set it up for convenience
_this._dragDropHelper = new DragDrop_1.DragDropHelper({
selection: {
getSelection: function () {
return;
},
},
minimumPixelsForDrag: _this.props.minimumPixelsForDrag,
});
return _this;
}
DetailsHeaderBase.prototype.componentDidMount = function () {
var selection = this.props.selection;
this._events.on(selection, Selection_1.SELECTION_CHANGE,
this._onSelectionChanged);
// this._rootElement.current will be null in tests using react-test-
renderer
if (this._rootElement.current) {
// We need to use native on this to prevent MarqueeSelection from
handling the event before us.
this._events.on(this._rootElement.current, 'mousedown',
this._onRootMouseDown);
this._events.on(this._rootElement.current, 'keydown',
this._onRootKeyDown);
if (this._getColumnReorderProps()) {
this._subscriptionObject =
this._dragDropHelper.subscribe(this._rootElement.current, this._events,
this._getHeaderDragDropOptions());
}
}
};
DetailsHeaderBase.prototype.componentDidUpdate = function (prevProps) {
if (this._getColumnReorderProps()) {
if (!this._subscriptionObject && this._rootElement.current) {
this._subscriptionObject =
this._dragDropHelper.subscribe(this._rootElement.current, this._events,
this._getHeaderDragDropOptions());
}
}
else if (this._subscriptionObject) {
this._subscriptionObject.dispose();
delete this._subscriptionObject;
}
if (this.props !== prevProps && this._onDropIndexInfo.sourceIndex >= 0 &&
this._onDropIndexInfo.targetIndex >= 0) {
var _a = prevProps.columns, previousColumns = _a === void 0 ?
NO_COLUMNS : _a;
var _b = this.props.columns, columns = _b === void 0 ? NO_COLUMNS : _b;
if (previousColumns[this._onDropIndexInfo.sourceIndex].key ===
columns[this._onDropIndexInfo.targetIndex].key) {
this._onDropIndexInfo = {
sourceIndex: -1,
targetIndex: -1,
};
}
}
if (this.props.isAllCollapsed !== prevProps.isAllCollapsed) {
this.setState({ isAllCollapsed: this.props.isAllCollapsed });
}
};
DetailsHeaderBase.prototype.componentWillUnmount = function () {
if (this._subscriptionObject) {
this._subscriptionObject.dispose();
delete this._subscriptionObject;
}
this._dragDropHelper.dispose();
};
DetailsHeaderBase.prototype.render = function () {
var _this = this;
var _a = this.props, _b = _a.columns, columns = _b === void 0 ?
NO_COLUMNS : _b, ariaLabel = _a.ariaLabel, ariaLabelForToggleAllGroupsButton =
_a.ariaLabelForToggleAllGroupsButton, ariaLabelForSelectAllCheckbox =
_a.ariaLabelForSelectAllCheckbox, selectAllVisibility = _a.selectAllVisibility,
ariaLabelForSelectionColumn = _a.ariaLabelForSelectionColumn, indentWidth =
_a.indentWidth, onColumnClick = _a.onColumnClick, onColumnContextMenu =
_a.onColumnContextMenu, _c = _a.onRenderColumnHeaderTooltip,
onRenderColumnHeaderTooltip = _c === void 0 ? this._onRenderColumnHeaderTooltip :
_c, styles = _a.styles, selectionMode = _a.selectionMode, theme = _a.theme,
onRenderDetailsCheckbox = _a.onRenderDetailsCheckbox, groupNestingDepth =
_a.groupNestingDepth, useFastIcons = _a.useFastIcons, checkboxVisibility =
_a.checkboxVisibility, className = _a.className;
var _d = this.state, isAllSelected = _d.isAllSelected, columnResizeDetails
= _d.columnResizeDetails, isSizing = _d.isSizing, isAllCollapsed =
_d.isAllCollapsed;
var showCheckbox = selectAllVisibility !==
DetailsHeader_types_1.SelectAllVisibility.none;
var isCheckboxHidden = selectAllVisibility ===
DetailsHeader_types_1.SelectAllVisibility.hidden;
var isCheckboxAlwaysVisible = checkboxVisibility ===
DetailsList_types_1.CheckboxVisibility.always;
var columnReorderProps = this._getColumnReorderProps();
var frozenColumnCountFromStart = columnReorderProps &&
columnReorderProps.frozenColumnCountFromStart
? columnReorderProps.frozenColumnCountFromStart
: 0;
var frozenColumnCountFromEnd = columnReorderProps &&
columnReorderProps.frozenColumnCountFromEnd
? columnReorderProps.frozenColumnCountFromEnd
: 0;
theme: theme,
isAllSelected: isAllSelected,
isSelectAllHidden: selectAllVisibility ===
DetailsHeader_types_1.SelectAllVisibility.hidden,
isResizingColumn: !!columnResizeDetails && isSizing,
isSizing: isSizing,
isAllCollapsed: isAllCollapsed,
isCheckboxHidden: isCheckboxHidden,
});
var showGroupExpander = groupNestingDepth > 0 &&
this.props.collapseAllVisibility === GroupedList_1.CollapseAllVisibility.visible;
var columnIndexOffset = 1 + (showCheckbox ? 1 : 0) + (showGroupExpander ? 1
: 0);
return (React.createElement(FocusZone_1.FocusZone, { role: "row", "aria-
label": ariaLabel, className: classNames.root, componentRef: this._rootComponent,
elementRef: this._rootElement, onMouseMove: this._onRootMouseMove, "data-
automationid": "DetailsHeader", direction:
FocusZone_1.FocusZoneDirection.horizontal },
showCheckbox
? [
React.createElement("div", { key: "__checkbox", className:
classNames.cellIsCheck, "aria-labelledby": this._id + "-checkTooltip", onClick: !
isCheckboxHidden ? this._onSelectAllClicked : undefined, role: 'columnheader' },
onRenderColumnHeaderTooltip({
hostClassName: classNames.checkTooltip,
id: this._id + "-checkTooltip",
setAriaDescribedBy: false,
content: ariaLabelForSelectAllCheckbox,
children:
(React.createElement(DetailsRowCheck_1.DetailsRowCheck, { id: this._id + "-check",
"aria-label": selectionMode === Selection_1.SelectionMode.multiple
? ariaLabelForSelectAllCheckbox
: ariaLabelForSelectionColumn, "data-is-focusable":
!isCheckboxHidden || undefined, isHeader: true, selected: isAllSelected,
anySelected: false, canSelect: !isCheckboxHidden, className: classNames.check,
onRenderDetailsCheckbox: onRenderDetailsCheckbox, useFastIcons: useFastIcons,
isVisible: isCheckboxAlwaysVisible })),
}, this._onRenderColumnHeaderTooltip)),
!this.props.onRenderColumnHeaderTooltip ?
(ariaLabelForSelectAllCheckbox && !isCheckboxHidden ? (React.createElement("label",
{ key: "__checkboxLabel", id: this._id + "-checkTooltip", className:
classNames.accessibleLabel, "aria-hidden": true },
ariaLabelForSelectAllCheckbox)) : ariaLabelForSelectionColumn && isCheckboxHidden ?
(React.createElement("label", { key: "__checkboxLabel", id: this._id + "-
checkTooltip", className: classNames.accessibleLabel, "aria-hidden": true },
ariaLabelForSelectionColumn)) : null) : null,
]
: null,
showGroupExpander ? (React.createElement("div", { className:
classNames.cellIsGroupExpander, onClick: this._onToggleCollapseAll, "data-is-
focusable": true, "aria-label": ariaLabelForToggleAllGroupsButton, "aria-expanded":
!isAllCollapsed, role: "columnheader" },
React.createElement(IconComponent, { className:
classNames.collapseButton, iconName: isRTL ? 'ChevronLeftMed' :
'ChevronRightMed' }),
React.createElement("span", { className: classNames.accessibleLabel
}, ariaLabelForToggleAllGroupsButton))) : null,
React.createElement(GroupSpacer_1.GroupSpacer, { indentWidth:
indentWidth, role: "gridcell", count: groupNestingDepth - 1 }),
columns.map(function (column, columnIndex) {
var _isDraggable = columnReorderProps
? columnIndex >= frozenColumnCountFromStart && columnIndex <
columns.length - frozenColumnCountFromEnd
: false;
return [
columnReorderProps &&
(_isDraggable || columnIndex === columns.length -
frozenColumnCountFromEnd) &&
_this._renderDropHint(columnIndex),
React.createElement(DetailsColumn_1.DetailsColumn, { column:
column, styles: column.styles, key: column.key, columnIndex: columnIndexOffset +
columnIndex, parentId: _this._id, isDraggable: _isDraggable, updateDragInfo:
_this._updateDragInfo, dragDropHelper: _this._dragDropHelper, onColumnClick:
onColumnClick, onColumnContextMenu: onColumnContextMenu,
// Do not render tooltips by default, but allow for
override via props.
onRenderColumnHeaderTooltip:
_this.props.onRenderColumnHeaderTooltip, isDropped:
_this._onDropIndexInfo.targetIndex === columnIndex, cellStyleProps:
_this.props.cellStyleProps, useFastIcons: useFastIcons }),
_this._renderColumnDivider(columnIndex),
];
}),
columnReorderProps && frozenColumnCountFromEnd === 0 &&
this._renderDropHint(columns.length),
isSizing && (React.createElement(Layer_1.Layer, null,
React.createElement("div", { className: classNames.sizingOverlay,
onMouseMove: this._onSizerMouseMove, onMouseUp: this._onSizerMouseUp })))));
};
/** Set focus to the active thing in the focus area. */
DetailsHeaderBase.prototype.focus = function () {
var _a;
return !!((_a = this._rootComponent.current) === null || _a === void 0 ?
void 0 : _a.focus());
};
/**
* Gets column reorder props from this.props. If the calling code is part of
setting up or
* handling drag/drop events, it's safe to assume that this method's return
value is defined
* (because drag/drop handling will only be set up if reorder props are given).
*/
DetailsHeaderBase.prototype._getColumnReorderProps = function () {
var _a = this.props, columnReorderOptions = _a.columnReorderOptions,
columnReorderProps = _a.columnReorderProps;
return columnReorderProps || (columnReorderOptions &&
tslib_1.__assign(tslib_1.__assign({}, columnReorderOptions), { onColumnDragEnd:
undefined }));
};
DetailsHeaderBase.prototype._getHeaderDragDropOptions = function () {
var options = {
selectionIndex: 1,
context: { data: this, index: 0 },
canDrag: function () { return false; },
canDrop: function () { return true; },
onDragStart: function () { return undefined; },
updateDropState: this._updateDroppingState,
onDrop: this._onDrop,
onDragEnd: function () { return undefined; },
onDragOver: this._onDragOver,
};
return options;
};
DetailsHeaderBase.prototype._isValidCurrentDropHintIndex = function () {
return this._currentDropHintIndex >= 0;
};
/**
* @returns whether or not the "Select All" checkbox column is hidden.
*/
DetailsHeaderBase.prototype._isCheckboxColumnHidden = function () {
var _a = this.props, selectionMode = _a.selectionMode, checkboxVisibility =
_a.checkboxVisibility;
return selectionMode === Selection_1.SelectionMode.none ||
checkboxVisibility === DetailsList_types_1.CheckboxVisibility.hidden;
};
DetailsHeaderBase.prototype._resetDropHints = function () {
if (this._currentDropHintIndex >= 0) {
this._updateDropHintElement(this._dropHintDetails[this._currentDropHintIndex].dropH
intElementRef, 'none');
this._currentDropHintIndex = -1;
}
};
DetailsHeaderBase.prototype._updateDropHintElement = function (element,
displayProperty) {
element.childNodes[1].style.display = displayProperty;
element.childNodes[0].style.display = displayProperty;
};
DetailsHeaderBase.prototype._isEventOnHeader = function (event) {
var clientRect = this._rootElement.current.getBoundingClientRect();
if (event.clientX > clientRect.left &&
event.clientX < clientRect.right &&
event.clientY > clientRect.top &&
event.clientY < clientRect.bottom) {
return DetailsList_types_1.ColumnDragEndLocation.header;
}
}
};
DetailsHeaderBase.prototype._renderColumnDivider = function (columnIndex) {
var _a = this.props.columns, columns = _a === void 0 ? NO_COLUMNS : _a;
var column = columns[columnIndex];
var onRenderDivider = column.onRenderDivider;
return onRenderDivider
? onRenderDivider({ column: column, columnIndex: columnIndex },
this._renderColumnSizer)
: this._renderColumnSizer({ column: column, columnIndex:
columnIndex });
};
DetailsHeaderBase.prototype._renderDropHint = function (dropHintIndex) {
var IconComponent = this.props.useFastIcons ? Icon_1.FontIcon :
Icon_1.Icon;
return (React.createElement("div", { key: 'dropHintKey', className:
classNames.dropHintStyle, id: "columnDropHint_" + dropHintIndex },
React.createElement("div", { role: "presentation", key:
"dropHintCircleKey", className: classNames.dropHintCaretStyle, "data-is-focusable":
false, "data-sizer-index": dropHintIndex, "aria-hidden": true },
React.createElement(IconComponent, { iconName:
'CircleShapeSolid' })),
React.createElement("div", { key: "dropHintLineKey", "aria-hidden":
true, "data-is-focusable": false, "data-sizer-index": dropHintIndex, className:
classNames.dropHintLineStyle })));
};
/**
* double click on the column sizer will auto ajust column width
* to fit the longest content among current rendered rows.
*
* @param columnIndex - index of the column user double clicked
* @param ev - mouse double click event
*/
DetailsHeaderBase.prototype._onSizerDoubleClick = function (columnIndex, ev) {
var _a = this.props, onColumnAutoResized = _a.onColumnAutoResized, _b =
_a.columns, columns = _b === void 0 ? NO_COLUMNS : _b;
if (onColumnAutoResized) {
onColumnAutoResized(columns[columnIndex], columnIndex);
}
};
DetailsHeaderBase.prototype._onSelectionChanged = function () {
var isAllSelected = !!this.props.selection &&
this.props.selection.isAllSelected();
if (this.state.isAllSelected !== isAllSelected) {
this.setState({
isAllSelected: isAllSelected,
});
}
};
DetailsHeaderBase.defaultProps = {
selectAllVisibility: DetailsHeader_types_1.SelectAllVisibility.visible,
collapseAllVisibility: GroupedList_1.CollapseAllVisibility.visible,
useFastIcons: true,
};
return DetailsHeaderBase;
exports.DetailsHeaderBase = DetailsHeaderBase;
function _liesBetween(rtl, target, left, right) {
return rtl ? target <= left && target >= right : target >= left && target <=
right;
}
function _isBefore(rtl, a, b) {
return rtl ? a >= b : a <= b;
}
function _isAfter(rtl, a, b) {
return rtl ? a <= b : a >= b;
}
function _stopPropagation(ev) {
}
//# sourceMappingURL=DetailsHeader.base.js.map
/***/ }),
/***/ 71015:
"use strict";

exports.DetailsHeader = void 0;
var DetailsHeader_base_1 = __webpack_require__(59307);
exports.DetailsHeader = Utilities_1.styled(DetailsHeader_base_1.DetailsHeaderBase,
DetailsHeader_styles_1.getDetailsHeaderStyles, undefined, { scope:
'DetailsHeader' });
//# sourceMappingURL=DetailsHeader.js.map
/***/ }),
/***/ 74057:
"use strict";

exports.getDetailsHeaderStyles = exports.getCellStyles = exports.HEADER_HEIGHT =
void 0;
// For every group level there is a GroupSpacer added. Importing this const to have
the source value in one place.
tooltipHost: 'ms-TooltipHost',
root: 'ms-DetailsHeader',
cell: 'ms-DetailsHeader-cell',
cellIsCheck: 'ms-DetailsHeader-cellIsCheck',
collapseButton: 'ms-DetailsHeader-collapseButton',
isAllSelected: 'is-allSelected',
isSelectAllHidden: 'is-selectAllHidden',
isResizingColumn: 'is-resizingColumn',
cellSizer: 'ms-DetailsHeader-cellSizer',
isResizing: 'is-resizing',
dropHintCircleStyle: 'ms-DetailsHeader-dropHintCircleStyle',
dropHintCaretStyle: 'ms-DetailsHeader-dropHintCaretStyle',
dropHintLineStyle: 'ms-DetailsHeader-dropHintLineStyle',
cellTitle: 'ms-DetailsHeader-cellTitle',
cellName: 'ms-DetailsHeader-cellName',
filterChevron: 'ms-DetailsHeader-filterChevron',
gripperBarVertical: 'ms-DetailsColumn-gripperBarVertical',
checkTooltip: 'ms-DetailsHeader-checkTooltip',
check: 'ms-DetailsHeader-check',
};
exports.HEADER_HEIGHT = 42;
var getCellStyles = function (props) {
var theme = props.theme, _a = props.cellStyleProps, cellStyleProps = _a ===
void 0 ? DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _a;
return [
classNames.cell,
{
padding: "0 " + cellStyleProps.cellRightPadding + "px 0 " +
cellStyleProps.cellLeftPadding + "px",
lineHeight: 'inherit',
margin: '0',
height: exports.HEADER_HEIGHT,
textAlign: 'left',
},
];
};
exports.getCellStyles = getCellStyles;
var getDetailsHeaderStyles = function (props) {
var _a, _b, _c, _d;
var theme = props.theme, className = props.className, isAllSelected =
props.isAllSelected, isResizingColumn = props.isResizingColumn, isSizing =
props.isSizing, isAllCollapsed = props.isAllCollapsed, _e = props.cellStyleProps,
cellStyleProps = _e === void 0 ? DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _e;
theme.fonts;
var colors = {
iconForegroundColor: semanticColors.bodySubtext,
headerForegroundColor: semanticColors.bodyText,
headerBackgroundColor: semanticColors.bodyBackground,
resizerColor: palette.neutralTertiaryAlt,
};
var cellSizerFadeInStyles = {
opacity: 1,
transition: 'opacity 0.3s linear',
};
var cellStyles = exports.getCellStyles(props);
return {
root: [
classNames.root,
fonts.small,
{
background: colors.headerBackgroundColor,
minWidth: '100%',
lineHeight: exports.HEADER_HEIGHT,
paddingTop: '16px',
borderBottom: "1px solid " + semanticColors.bodyDivider,
cursor: 'default',
userSelect: 'none',
_a["&:hover ." + classNames.check] = {
opacity: 1,
},
_a["& ." + classNames.tooltipHost + " ." +
classNames.checkTooltip] = {
display: 'block',
},
_a),
},
isAllSelected && classNames.isAllSelected,
isResizingColumn && classNames.isResizingColumn,
className,
],
check: [
classNames.check,
{
},
{
_b["." + Utilities_1.IsFocusVisibleClassName + " &:focus"] = {
opacity: 1,
},
_b),
},
],
cellWrapperPadded: {
cellStyleProps.cellRightPadding,
},
cellIsCheck: [
cellStyles,
classNames.cellIsCheck,
{
padding: 0,
margin: 0,
border: 'none',
},
isAllSelected && {
opacity: 1,
},
],
cellIsGroupExpander: [
cellStyles,
{
padding: 0,
border: 'none',
width: GroupSpacer_1.SPACER_WIDTH,
selectors: {
':hover': {
},
':active': {
},
},
},
],
cellIsActionable: {
selectors: {
':hover': {
background: semanticColors.listHeaderBackgroundHovered,
},
':active': {
background: semanticColors.listHeaderBackgroundPressed,
},
},
},
cellIsEmpty: {
},
cellSizer: [
classNames.cellSizer,
{
cursor: 'ew-resize',
bottom: 0,
top: 0,
overflow: 'hidden',
height: 'inherit',
background: 'transparent',
zIndex: 1,
width: 16,
selectors: (_c = {
':after': {
content: '""',
top: 0,
bottom: 0,
width: 1,
background: colors.resizerColor,
opacity: 0,
left: '50%',
},
':focus:after': cellSizerFadeInStyles,
':hover:after': cellSizerFadeInStyles
},
_c["&." + classNames.isResizing + ":after"] = [
cellSizerFadeInStyles,
{
boxShadow: '0 0 5px 0 rgba(0, 0, 0, 0.4)',
},
],
_c),
},
],
cellIsResizing: classNames.isResizing,
cellSizerStart: {
margin: '0 -8px',
},
cellSizerEnd: {
margin: 0,
marginLeft: -16,
},
collapseButton: [
classNames.collapseButton,
{
transformOrigin: '50% 50%',
transition: 'transform .1s linear',
},
isAllCollapsed
? [
classNames.isCollapsed,
{
},
]
: {
transform: Utilities_1.getRTL(theme) ? 'rotate(-90deg)' :
'rotate(90deg)',
},
],
checkTooltip: classNames.checkTooltip,
sizingOverlay: isSizing && {
left: 0,
top: 0,
right: 0,
bottom: 0,
cursor: 'ew-resize',
background: 'rgba(255, 255, 255, 0)',
_d[Styling_1.HighContrastSelector] = tslib_1.__assign({ background:
'transparent' }, Styling_1.getHighContrastNoAdjustStyle()),
_d),
},
accessibleLabel: Styling_1.hiddenContentStyle,
dropHintCircleStyle: [
classNames.dropHintCircleStyle,
{
bottom: 0,
height: 9,
width: 9,
marginLeft: -5,
top: 34,
zIndex: 10,
border: "1px solid " + palette.themePrimary,
background: palette.white,
},
],
dropHintCaretStyle: [
classNames.dropHintCaretStyle,
{
display: 'none',
top: -28,
left: -6.5,
zIndex: 10,
},
],
dropHintLineStyle: [
classNames.dropHintLineStyle,
{
display: 'none',
bottom: 0,
top: 0,
overflow: 'hidden',
height: 42,
width: 1,
zIndex: 10,
},
],
dropHintStyle: {
},
};
};
exports.getDetailsHeaderStyles = getDetailsHeaderStyles;
//# sourceMappingURL=DetailsHeader.styles.js.map
/***/ }),
/***/ 22403:
"use strict";

exports.SelectAllVisibility = void 0;
/**
*/
var SelectAllVisibility;
(function (SelectAllVisibility) {
SelectAllVisibility[SelectAllVisibility["none"] = 0] = "none";
SelectAllVisibility[SelectAllVisibility["hidden"] = 1] = "hidden";
SelectAllVisibility[SelectAllVisibility["visible"] = 2] = "visible";
})(SelectAllVisibility = exports.SelectAllVisibility ||
(exports.SelectAllVisibility = {}));
//# sourceMappingURL=DetailsHeader.types.js.map
/***/ }),
/***/ 61925:
"use strict";

exports.buildColumns = exports.DetailsListBase = void 0;
var DetailsHeader_1 = __webpack_require__(71015);
var DetailsHeader_types_1 = __webpack_require__(22403);
var DetailsRow_1 = __webpack_require__(14696);
var DragDrop_1 = __webpack_require__(67337);
var withViewport_1 = __webpack_require__(38685);
var GroupedListUtility_1 = __webpack_require__(71289);
var DetailsRowCheck_styles_1 = __webpack_require__(32979);
var MIN_COLUMN_WIDTH = 100; // this is the global min width
var DEFAULT_RENDERED_WINDOWS_AHEAD = 2;
var DEFAULT_RENDERED_WINDOWS_BEHIND = 2;
/**
* Hooks-based implementation of DetailsList.
* Since many existing consumers of DetailsList expect `ref` to return a
`DetailsList`,
* this inner component handles rendering while the outer maintains compatibility.
*/
var DetailsListInner = function (props) {
var selection = props.selection;
var ariaLabelForListHeader = props.ariaLabelForListHeader,
ariaLabelForSelectAllCheckbox = props.ariaLabelForSelectAllCheckbox,
ariaLabelForSelectionColumn = props.ariaLabelForSelectionColumn, className =
props.className, checkboxVisibility = props.checkboxVisibility, compact =
props.compact, constrainMode = props.constrainMode, dragDropEvents =
props.dragDropEvents, groups = props.groups, groupProps = props.groupProps,
indentWidth = props.indentWidth, items = props.items, isPlaceholderData =
props.isPlaceholderData, isHeaderVisible = props.isHeaderVisible, layoutMode =
props.layoutMode, onItemInvoked = props.onItemInvoked, onItemContextMenu =
props.onItemContextMenu, onColumnHeaderClick = props.onColumnHeaderClick,
onColumnHeaderContextMenu = props.onColumnHeaderContextMenu, _a =
props.selectionMode, selectionMode = _a === void 0 ? selection.mode : _a,
selectionPreservedOnEmptyClick = props.selectionPreservedOnEmptyClick,
selectionZoneProps = props.selectionZoneProps,
ariaLabel = props.ariaLabel, ariaLabelForGrid = props.ariaLabelForGrid,
rowElementEventMap = props.rowElementEventMap,
_b = props.shouldApplyApplicationRole,
shouldApplyApplicationRole = _b === void 0 ? false : _b, getKey = props.getKey,
listProps = props.listProps, usePageCache = props.usePageCache, onShouldVirtualize
= props.onShouldVirtualize, viewport = props.viewport, minimumPixelsForDrag =
props.minimumPixelsForDrag, getGroupHeight = props.getGroupHeight, styles =
props.styles, theme = props.theme, _c = props.cellStyleProps, cellStyleProps = _c
=== void 0 ? DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _c, onRenderCheckbox =
props.onRenderCheckbox, useFastIcons = props.useFastIcons, dragDropHelper =
props.dragDropHelper, adjustedColumns = props.adjustedColumns, isCollapsed =
props.isCollapsed, isSizing = props.isSizing, isSomeGroupExpanded =
props.isSomeGroupExpanded, version = props.version, rootRef = props.rootRef,
listRef = props.listRef, focusZoneRef = props.focusZoneRef, columnReorderOptions =
props.columnReorderOptions, groupedListRef = props.groupedListRef, headerRef =
props.headerRef, onGroupExpandStateChanged = props.onGroupExpandStateChanged,
onColumnIsSizingChanged = props.onColumnIsSizingChanged, onRowDidMount =
props.onRowDidMount, onRowWillUnmount = props.onRowWillUnmount,
disableSelectionZone = props.disableSelectionZone, _d = props.isSelectedOnFocus,
isSelectedOnFocus = _d === void 0 ? true : _d, onColumnResized =
props.onColumnResized, onColumnAutoResized = props.onColumnAutoResized,
onToggleCollapse = props.onToggleCollapse, onActiveRowChanged =
props.onActiveRowChanged, onBlur = props.onBlur, eventsToRegister =
props.rowElementEventMap, onRenderMissingItem = props.onRenderMissingItem,
onRenderItemColumn = props.onRenderItemColumn, onRenderField = props.onRenderField,
getCellValueKey = props.getCellValueKey, getRowAriaLabel = props.getRowAriaLabel,
getRowAriaDescribedBy = props.getRowAriaDescribedBy, checkButtonAriaLabel =
props.checkButtonAriaLabel, checkButtonGroupAriaLabel =
props.checkButtonGroupAriaLabel, checkboxCellClassName =
props.checkboxCellClassName, useReducedRowRenderer = props.useReducedRowRenderer,
enableUpdateAnimations = props.enableUpdateAnimations, enterModalSelectionOnTouch =
props.enterModalSelectionOnTouch, onRenderDefaultRow = props.onRenderDefaultRow,
selectionZoneRef = props.selectionZoneRef, focusZoneProps = props.focusZoneProps;
var defaultRole = 'grid';
var role = props.role ? props.role : defaultRole;
var rowId = utilities_1.getId('row');
var groupNestingDepth = getGroupNestingDepth(groups);
var groupedDetailsListIndexMap = useGroupedDetailsListIndexMap(groups);
var additionalListProps = React.useMemo(function () {
return tslib_1.__assign({ renderedWindowsAhead: isSizing ? 0 :
DEFAULT_RENDERED_WINDOWS_AHEAD, renderedWindowsBehind: isSizing ? 0 :
DEFAULT_RENDERED_WINDOWS_BEHIND, getKey: getKey, version: version }, listProps);
}, [isSizing, getKey, version, listProps]);
var selectAllVisibility = DetailsHeader_types_1.SelectAllVisibility.none; //
for SelectionMode.none
if (selectionMode === Selection_1.SelectionMode.single) {
selectAllVisibility = DetailsHeader_types_1.SelectAllVisibility.hidden;
}
if (selectionMode === Selection_1.SelectionMode.multiple) {
// if isCollapsedGroupSelectVisible is false, disable select all when the
list has all collapsed groups
var isCollapsedGroupSelectVisible = groupProps && groupProps.headerProps &&
groupProps.headerProps.isCollapsedGroupSelectVisible;
if (isCollapsedGroupSelectVisible === undefined) {
isCollapsedGroupSelectVisible = true;
}
var isSelectAllVisible = isCollapsedGroupSelectVisible || !groups ||
isSomeGroupExpanded;
selectAllVisibility = isSelectAllVisible ?
DetailsHeader_types_1.SelectAllVisibility.visible :
DetailsHeader_types_1.SelectAllVisibility.hidden;
}
if (checkboxVisibility === DetailsList_types_1.CheckboxVisibility.hidden) {
selectAllVisibility = DetailsHeader_types_1.SelectAllVisibility.none;
}
var defaultOnRenderDetailsHeader = React.useCallback(function
(detailsHeaderProps) {
return React.createElement(DetailsHeader_1.DetailsHeader,
tslib_1.__assign({}, detailsHeaderProps));
}, []);
var defaultOnRenderDetailsFooter = React.useCallback(function () {
return null;
}, []);
var propsOnRenderDetailsHeader = props.onRenderDetailsHeader;
var onRenderDetailsHeader = React.useMemo(function () {
return propsOnRenderDetailsHeader
? utilities_1.composeRenderFunction(propsOnRenderDetailsHeader,
defaultOnRenderDetailsHeader)
: defaultOnRenderDetailsHeader;
}, [propsOnRenderDetailsHeader, defaultOnRenderDetailsHeader]);
var propsOnRenderDetailsFooter = props.onRenderDetailsFooter;
var onRenderDetailsFooter = React.useMemo(function () {
return propsOnRenderDetailsFooter
? utilities_1.composeRenderFunction(propsOnRenderDetailsFooter,
defaultOnRenderDetailsFooter)
: defaultOnRenderDetailsFooter;
}, [propsOnRenderDetailsFooter, defaultOnRenderDetailsFooter]);
var detailsFooterProps = React.useMemo(function () {
return {
columns: adjustedColumns,
groupNestingDepth: groupNestingDepth,
selection: selection,
selectionMode: selectionMode,
viewport: viewport,
checkboxVisibility: checkboxVisibility,
indentWidth: indentWidth,
};
}, [
adjustedColumns,
groupNestingDepth,
selection,
selectionMode,
viewport,
checkboxVisibility,
indentWidth,
cellStyleProps,
]);
var columnReorderOnDragEnd = columnReorderOptions &&
columnReorderOptions.onDragEnd;
var onColumnDragEnd = React.useCallback(function (_a, event) {
var dropLocation = _a.dropLocation;
var finalDropLocation = DetailsList_types_1.ColumnDragEndLocation.outside;
if (columnReorderOnDragEnd) {
if (dropLocation && dropLocation !==
DetailsList_types_1.ColumnDragEndLocation.header) {
finalDropLocation = dropLocation;
}
else if (rootRef.current) {
var clientRect = rootRef.current.getBoundingClientRect();
if (event.clientX > clientRect.left &&
event.clientX < clientRect.right &&
event.clientY > clientRect.top &&
event.clientY < clientRect.bottom) {
finalDropLocation =
DetailsList_types_1.ColumnDragEndLocation.surface;
}
}
columnReorderOnDragEnd(finalDropLocation);
}
}, [columnReorderOnDragEnd, rootRef]);
var columnReorderProps = React.useMemo(function () {
if (columnReorderOptions) {
return tslib_1.__assign(tslib_1.__assign({}, columnReorderOptions),
{ onColumnDragEnd: onColumnDragEnd });
}
}, [columnReorderOptions, onColumnDragEnd]);
var rowCount = (isHeaderVisible ? 1 : 0) +
GroupedListUtility_1.GetGroupCount(groups) + (items ? items.length : 0);
var colCount = (selectAllVisibility !==
DetailsHeader_types_1.SelectAllVisibility.none ? 1 : 0) +
(adjustedColumns ? adjustedColumns.length : 0) +
(groups ? 1 : 0);
var classNames = React.useMemo(function () {
return getClassNames(styles, {
theme: theme,
compact: compact,
isFixed: layoutMode ===
DetailsList_types_1.DetailsListLayoutMode.fixedColumns,
isHorizontalConstrained: constrainMode ===
DetailsList_types_1.ConstrainMode.horizontalConstrained,
});
}, [styles, theme, compact, layoutMode, constrainMode, className]);
var onRenderDetailsGroupFooter = groupProps && groupProps.onRenderFooter;
var finalOnRenderDetailsGroupFooter = React.useMemo(function () {
return onRenderDetailsGroupFooter
? function (groupFooterProps, defaultRender) {
return
onRenderDetailsGroupFooter(tslib_1.__assign(tslib_1.__assign({}, groupFooterProps),
{ columns: adjustedColumns, groupNestingDepth: groupNestingDepth, indentWidth:
indentWidth, selection: selection, selectionMode: selectionMode, viewport:
viewport, checkboxVisibility: checkboxVisibility, cellStyleProps:
cellStyleProps }), defaultRender);
}
: undefined;
}, [
onRenderDetailsGroupFooter,
adjustedColumns,
groupNestingDepth,
indentWidth,
selection,
selectionMode,
viewport,
checkboxVisibility,
cellStyleProps,
]);
var onRenderDetailsGroupHeader = groupProps && groupProps.onRenderHeader;
var finalOnRenderDetailsGroupHeader = React.useMemo(function () {
return onRenderDetailsGroupHeader
? function (groupHeaderProps, defaultRender) {
var _a, _b;
var groupIndex = groupHeaderProps.groupIndex;
var groupKey = groupIndex !== undefined ? (_b = (_a =
groupHeaderProps.groups) === null || _a === void 0 ? void 0 : _a[groupIndex]) ===
null || _b === void 0 ? void 0 : _b.key : undefined;
var totalRowCount = groupKey !== undefined &&
groupedDetailsListIndexMap[groupKey]
? groupedDetailsListIndexMap[groupKey].totalRowCount
: 0;
return
onRenderDetailsGroupHeader(tslib_1.__assign(tslib_1.__assign({}, groupHeaderProps),
{ columns: adjustedColumns, groupNestingDepth: groupNestingDepth, indentWidth:
indentWidth, selection: selection, selectionMode: checkboxVisibility !==
DetailsList_types_1.CheckboxVisibility.hidden ? selectionMode :
Selection_1.SelectionMode.none, viewport: viewport, checkboxVisibility:
checkboxVisibility, cellStyleProps: cellStyleProps, ariaColSpan:
adjustedColumns.length, ariaPosInSet: undefined, ariaSetSize: undefined,
ariaRowCount: undefined, ariaRowIndex: groupIndex !== undefined ? totalRowCount +
(isHeaderVisible ? 1 : 0) : undefined }), defaultRender);
}
: function (groupHeaderProps, defaultRender) {
var _a, _b;
var groupIndex = groupHeaderProps.groupIndex;
var groupKey = groupIndex !== undefined ? (_b = (_a =
groupHeaderProps.groups) === null || _a === void 0 ? void 0 : _a[groupIndex]) ===
null || _b === void 0 ? void 0 : _b.key : undefined;
var totalRowCount = groupKey !== undefined &&
? groupedDetailsListIndexMap[groupKey].totalRowCount
: 0;
return defaultRender(tslib_1.__assign(tslib_1.__assign({},
groupHeaderProps), { ariaColSpan: adjustedColumns.length, ariaPosInSet: undefined,
ariaSetSize: undefined, ariaRowCount: undefined, ariaRowIndex: groupIndex !==
undefined ? totalRowCount + (isHeaderVisible ? 1 : 0) : undefined }));
};
}, [
onRenderDetailsGroupHeader,
adjustedColumns,
groupNestingDepth,
indentWidth,
isHeaderVisible,
selection,
selectionMode,
viewport,
checkboxVisibility,
cellStyleProps,
groupedDetailsListIndexMap,
]);
var finalGroupProps = React.useMemo(function () {
var _a;
return tslib_1.__assign(tslib_1.__assign({}, groupProps), { role: role ===
defaultRole ? 'rowgroup' : 'presentation', onRenderFooter:
finalOnRenderDetailsGroupFooter, onRenderHeader: finalOnRenderDetailsGroupHeader,
// pass through custom group header checkbox label
headerProps: tslib_1.__assign(tslib_1.__assign({}, groupProps === null
|| groupProps === void 0 ? void 0 : groupProps.headerProps),
{ selectAllButtonProps: tslib_1.__assign({ 'aria-label':
checkButtonGroupAriaLabel }, (_a = groupProps === null || groupProps === void 0 ?
void 0 : groupProps.headerProps) === null || _a === void 0 ? void 0 :
_a.selectAllButtonProps) }) });
}, [groupProps, finalOnRenderDetailsGroupFooter,
finalOnRenderDetailsGroupHeader, checkButtonGroupAriaLabel, role]);
var sumColumnWidths = react_hooks_1.useConst(function () {
return Utilities_1.memoizeFunction(function (columns) {
var totalWidth = 0;
columns.forEach(function (column) { return (totalWidth +=
column.calculatedWidth || column.minWidth); });
return totalWidth;
});
});
var collapseAllVisibility = groupProps && groupProps.collapseAllVisibility;
var rowWidth = React.useMemo(function () {
return sumColumnWidths(adjustedColumns);
}, [adjustedColumns, sumColumnWidths]);
var onRenderCell = React.useCallback(function (nestingDepth, item, index,
group) {
var finalOnRenderRow = props.onRenderRow
? utilities_1.composeRenderFunction(props.onRenderRow,
onRenderDefaultRow)
: onRenderDefaultRow;
var groupKey = group ? group.key : undefined;
var numOfGroupHeadersBeforeItem = groupKey &&
? groupedDetailsListIndexMap[groupKey].numOfGroupHeadersBeforeItem
: 0;
var rowRole = role === defaultRole ? undefined : 'presentation';
var rowProps = {
item: item,
itemIndex: index,
flatIndexOffset: (isHeaderVisible ? 2 : 1) +
numOfGroupHeadersBeforeItem,
compact: compact,
groupNestingDepth: nestingDepth,
id: rowId + "-" + index,
onDidMount: onRowDidMount,
onWillUnmount: onRowWillUnmount,
onRenderItemColumn: onRenderItemColumn,
onRenderField: onRenderField,
getCellValueKey: getCellValueKey,
eventsToRegister: eventsToRegister,
dragDropEvents: dragDropEvents,
dragDropHelper: dragDropHelper,
viewport: viewport,
collapseAllVisibility: collapseAllVisibility,
getRowAriaLabel: getRowAriaLabel,
getRowAriaDescribedBy: getRowAriaDescribedBy,
checkButtonAriaLabel: checkButtonAriaLabel,
checkboxCellClassName: checkboxCellClassName,
useReducedRowRenderer: useReducedRowRenderer,
onRenderDetailsCheckbox: onRenderCheckbox,
enableUpdateAnimations: enableUpdateAnimations,
rowWidth: rowWidth,
useFastIcons: useFastIcons,
role: rowRole,
};
if (!item) {
if (onRenderMissingItem) {
return onRenderMissingItem(index, rowProps);
}
return null;
}
return finalOnRenderRow(rowProps);
}, [
compact,
adjustedColumns,
selectionMode,
selection,
rowId,
onRowDidMount,
onRowWillUnmount,
onRenderItemColumn,
onRenderField,
getCellValueKey,
eventsToRegister,
dragDropEvents,
dragDropHelper,
viewport,
checkboxVisibility,
collapseAllVisibility,
getRowAriaLabel,
getRowAriaDescribedBy,
isHeaderVisible,
checkButtonAriaLabel,
checkboxCellClassName,
useReducedRowRenderer,
indentWidth,
cellStyleProps,
onRenderCheckbox,
enableUpdateAnimations,
useFastIcons,
onRenderDefaultRow,
onRenderMissingItem,
props.onRenderRow,
rowWidth,
role,
groupedDetailsListIndexMap,
]);
var onRenderListCell = React.useCallback(function (nestingDepth) {
return function (item, itemIndex) {
return onRenderCell(nestingDepth, item, itemIndex);
};
}, [onRenderCell]);
var isRightArrow = React.useCallback(function (event) {
return event.which ===
Utilities_1.getRTLSafeKeyCode(Utilities_1.KeyCodes.right, theme);
}, [theme]);
var focusZoneInnerProps = tslib_1.__assign(tslib_1.__assign({},
focusZoneProps), { componentRef: focusZoneProps && focusZoneProps.componentRef ?
focusZoneProps.componentRef : focusZoneRef, className: classNames.focusZone,
direction: focusZoneProps ? focusZoneProps.direction :
FocusZone_1.FocusZoneDirection.vertical, shouldEnterInnerZone: focusZoneProps &&
focusZoneProps.shouldEnterInnerZone ? focusZoneProps.shouldEnterInnerZone :
isRightArrow, onActiveElementChanged: focusZoneProps &&
focusZoneProps.onActiveElementChanged
? focusZoneProps.onActiveElementChanged
: onActiveRowChanged, shouldRaiseClicksOnEnter: false, onBlur:
focusZoneProps && focusZoneProps.onBlur ? focusZoneProps.onBlur : onBlur });
var list = groups ? (React.createElement(GroupedList_1.GroupedList,
{ focusZoneProps: focusZoneInnerProps, componentRef: groupedListRef, groups:
groups, groupProps: finalGroupProps, items: items, onRenderCell: onRenderCell,
role: "presentation", selection: selection, selectionMode: checkboxVisibility !==
DetailsList_types_1.CheckboxVisibility.hidden ? selectionMode :
Selection_1.SelectionMode.none, dragDropEvents: dragDropEvents, dragDropHelper:
dragDropHelper, eventsToRegister: rowElementEventMap, listProps:
additionalListProps, onGroupExpandStateChanged: onGroupExpandStateChanged,
usePageCache: usePageCache, onShouldVirtualize: onShouldVirtualize, getGroupHeight:
getGroupHeight, compact: compact })) : (React.createElement(FocusZone_1.FocusZone,
tslib_1.__assign({}, focusZoneInnerProps),
React.createElement(List_1.List, tslib_1.__assign({ ref: listRef, role:
"presentation", items: items, onRenderCell: onRenderListCell(0), usePageCache:
usePageCache, onShouldVirtualize: onShouldVirtualize }, additionalListProps))));
var onHeaderKeyDown = React.useCallback(function (ev) {
if (ev.which === Utilities_1.KeyCodes.down) {
if (focusZoneRef.current && focusZoneRef.current.focus()) {
// select the first item in list after down arrow key event
// only if nothing was selected; otherwise start with the already-
selected item
if (isSelectedOnFocus && selection.getSelectedIndices().length ===
0) {
selection.setIndexSelected(0, true, false);
}
}
}
}, [selection, focusZoneRef, isSelectedOnFocus]);
var onContentKeyDown = React.useCallback(function (ev) {
if (ev.which === Utilities_1.KeyCodes.up && !ev.altKey) {
if (headerRef.current && headerRef.current.focus()) {
}
}
}, [headerRef]);
return (React.createElement("div", tslib_1.__assign({ ref: rootRef, className:
classNames.root, "data-automationid": "DetailsList", "data-is-scrollable":
"false" }, (shouldApplyApplicationRole ? { role: 'application' } : {})),
React.createElement(Utilities_1.FocusRects, null),
React.createElement("div", { role: role, "aria-label": ariaLabelForGrid ||
ariaLabel, "aria-rowcount": isPlaceholderData ? 0 : rowCount, "aria-colcount":
colCount, "aria-readonly": "true", "aria-busy": isPlaceholderData },
React.createElement("div", { onKeyDown: onHeaderKeyDown, role:
"presentation", className: classNames.headerWrapper }, isHeaderVisible &&
onRenderDetailsHeader({
componentRef: headerRef,
layoutMode: layoutMode,
onColumnClick: onColumnHeaderClick,
onColumnContextMenu: onColumnHeaderContextMenu,
onColumnResized: onColumnResized,
onColumnIsSizingChanged: onColumnIsSizingChanged,
onColumnAutoResized: onColumnAutoResized,
groupNestingDepth: groupNestingDepth,
isAllCollapsed: isCollapsed,
onToggleCollapseAll: onToggleCollapse,
ariaLabel: ariaLabelForListHeader,
ariaLabelForSelectAllCheckbox: ariaLabelForSelectAllCheckbox,
ariaLabelForSelectionColumn: ariaLabelForSelectionColumn,
selectAllVisibility: selectAllVisibility,
collapseAllVisibility: groupProps &&
groupProps.collapseAllVisibility,
viewport: viewport,
columnReorderProps: columnReorderProps,
minimumPixelsForDrag: minimumPixelsForDrag,
onRenderDetailsCheckbox: onRenderCheckbox,
rowWidth: sumColumnWidths(adjustedColumns),
}, onRenderDetailsHeader)),
React.createElement("div", { onKeyDown: onContentKeyDown, role:
"presentation", className: classNames.contentWrapper }, !disableSelectionZone ?
(React.createElement(Selection_1.SelectionZone, tslib_1.__assign({ ref:
selectionZoneRef, selection: selection, selectionPreservedOnEmptyClick:
selectionPreservedOnEmptyClick, selectionMode: selectionMode, isSelectedOnFocus:
isSelectedOnFocus, selectionClearedOnEscapePress: isSelectedOnFocus,
toggleWithoutModifierPressed: !isSelectedOnFocus, onItemInvoked: onItemInvoked,
onItemContextMenu: onItemContextMenu, enterModalOnTouch: enterModalSelectionOnTouch
}, (selectionZoneProps || {})), list)) : (list)),
onRenderDetailsFooter(tslib_1.__assign({}, detailsFooterProps)))));
};
var DetailsListBase = /** @class */ (function (_super) {
tslib_1.__extends(DetailsListBase, _super);
function DetailsListBase(props) {
_this._header = React.createRef();
_this._groupedList = React.createRef();
_this._selectionZone = React.createRef();
_this._onRenderRow = function (props, defaultRender) {
return React.createElement(DetailsRow_1.DetailsRow,
};
_this._getDerivedStateFromProps = function (nextProps, previousState) {
var _a = _this.props, checkboxVisibility = _a.checkboxVisibility, items
= _a.items, setKey = _a.setKey, _b = _a.selectionMode, selectionMode = _b === void
0 ? _this._selection.mode : _b, columns = _a.columns, viewport = _a.viewport,
compact = _a.compact, dragDropEvents = _a.dragDropEvents;
var _c = (_this.props.groupProps || {}).isAllGroupsCollapsed,
isAllGroupsCollapsed = _c === void 0 ? undefined : _c;
var newViewportWidth = (nextProps.viewport && nextProps.viewport.width)
|| 0;
var oldViewportWidth = (viewport && viewport.width) || 0;
var shouldResetSelection = nextProps.setKey !== setKey ||
nextProps.setKey === undefined;
var shouldForceUpdates = false;
if (nextProps.layoutMode !== _this.props.layoutMode) {
shouldForceUpdates = true;
}
var nextState = previousState;
if (shouldResetSelection) {
_this._initialFocusedIndex = nextProps.initialFocusedIndex;
// reset focusedItemIndex when setKey changes
nextState = tslib_1.__assign(tslib_1.__assign({}, nextState),
{ focusedItemIndex: _this._initialFocusedIndex !== undefined ?
_this._initialFocusedIndex : -1 });
}
if (!_this.props.disableSelectionZone && nextProps.items !== items) {
_this._selection.setItems(nextProps.items, shouldResetSelection);
}
if (nextProps.checkboxVisibility !== checkboxVisibility ||
nextProps.columns !== columns ||
newViewportWidth !== oldViewportWidth ||
nextProps.compact !== compact) {
}
_this._adjustColumns(nextProps, nextState, true));
if (nextProps.selectionMode !== selectionMode) {
}
if (isAllGroupsCollapsed === undefined &&
nextProps.groupProps &&
nextProps.groupProps.isAllGroupsCollapsed !== undefined) {
{ isCollapsed: nextProps.groupProps.isAllGroupsCollapsed, isSomeGroupExpanded: !
nextProps.groupProps.isAllGroupsCollapsed });
}
if (nextProps.dragDropEvents !== dragDropEvents) {
_this._dragDropHelper && _this._dragDropHelper.dispose();
_this._dragDropHelper = nextProps.dragDropEvents
? new DragDrop_1.DragDropHelper({
selection: _this._selection,
minimumPixelsForDrag: nextProps.minimumPixelsForDrag,
})
: undefined;
}
if (shouldForceUpdates) {
{ version: {} });
}
return nextState;
};
_this._onGroupExpandStateChanged = function (isSomeGroupExpanded) {
_this.setState({ isSomeGroupExpanded: isSomeGroupExpanded });
};
_this._onColumnIsSizingChanged = function (column, isSizing) {
_this.setState({ isSizing: isSizing });
};
_this._onRowDidMount = function (row) {
var _a = row.props, item = _a.item, itemIndex = _a.itemIndex;
var itemKey = _this._getItemKey(item, itemIndex);
_this._activeRows[itemKey] = row; // this is used for column auto
resize
_this._setFocusToRowIfPending(row);
var onRowDidMount = _this.props.onRowDidMount;
if (onRowDidMount) {
onRowDidMount(item, itemIndex);
}
};
_this._onRowWillUnmount = function (row) {
var onRowWillUnmount = _this.props.onRowWillUnmount;
var _a = row.props, item = _a.item, itemIndex = _a.itemIndex;
var itemKey = _this._getItemKey(item, itemIndex);
delete _this._activeRows[itemKey];
if (onRowWillUnmount) {
onRowWillUnmount(item, itemIndex);
}
};
_this._onToggleCollapse = function (collapsed) {
_this.setState({
isCollapsed: collapsed,
});
if (_this._groupedList.current) {
_this._groupedList.current.toggleCollapseAll(collapsed);
}
};
_this._onColumnResized = function (resizingColumn, newWidth,
resizingColumnIndex) {
var newCalculatedWidth = Math.max(resizingColumn.minWidth ||
MIN_COLUMN_WIDTH, newWidth);
if (_this.props.onColumnResize) {
_this.props.onColumnResize(resizingColumn, newCalculatedWidth,
resizingColumnIndex);
}
_this._rememberCalculatedWidth(resizingColumn, newCalculatedWidth);
_this.setState(tslib_1.__assign(tslib_1.__assign({},
_this._adjustColumns(_this.props, _this.state, true, resizingColumnIndex)),
{ version: {} }));
};
/**
* Callback function when double clicked on the details header column
resizer
* which will measure the column cells of all the active rows and resize
the
* column to the max cell width.
*
* @param column - double clicked column definition
* @param columnIndex - double clicked column index
* TODO: min width 100 should be changed to const value and should be
consistent with the
* value used on _onSizerMove method in DetailsHeader
*/
_this._onColumnAutoResized = function (column, columnIndex) {
var max = 0;
var count = 0;
var totalCount = Object.keys(_this._activeRows).length;
for (var key in _this._activeRows) {
if (_this._activeRows.hasOwnProperty(key)) {
var currentRow = _this._activeRows[key];
currentRow.measureCell(columnIndex, function (width) {
max = Math.max(max, width);
count++;
if (count === totalCount) {
_this._onColumnResized(column, max, columnIndex);
}
});
}
}
};
/**
* Call back function when an element in FocusZone becomes active. It will
translate it into item
* and call onActiveItemChanged callback if specified.
*
* @param row - element that became active in Focus Zone
* @param focus - event from Focus Zone
*/
_this._onActiveRowChanged = function (el, ev) {
var _a = _this.props, items = _a.items, onActiveItemChanged =
_a.onActiveItemChanged;
if (!el) {
return;
}
// Check and assign index only if the event was raised from any
DetailsRow element
if (el.getAttribute('data-item-index')) {
var index = Number(el.getAttribute('data-item-index'));
if (index >= 0) {
if (onActiveItemChanged) {
onActiveItemChanged(items[index], index, ev);
}
_this.setState({
focusedItemIndex: index,
});
}
}
};
_this.setState({
focusedItemIndex: -1,
});
};
_this._activeRows = {};
_this._columnOverrides = {};
_this.state = {
focusedItemIndex: -1,
lastWidth: 0,
adjustedColumns: _this._getAdjustedColumns(props, undefined),
isSizing: false,
isCollapsed: props.groupProps && props.groupProps.isAllGroupsCollapsed,
isSomeGroupExpanded: props.groupProps && !
props.groupProps.isAllGroupsCollapsed,
version: {},
getDerivedStateFromProps: _this._getDerivedStateFromProps,
};
_this._selection =
props.selection ||
new Selection_1.Selection({
onSelectionChanged: undefined,
getKey: props.getKey,
selectionMode: props.selectionMode,
});
if (!_this.props.disableSelectionZone) {
_this._selection.setItems(props.items, false);
}
_this._dragDropHelper = props.dragDropEvents
? new DragDrop_1.DragDropHelper({
selection: _this._selection,
minimumPixelsForDrag: props.minimumPixelsForDrag,
})
: undefined;
_this._initialFocusedIndex = props.initialFocusedIndex;
return _this;
}
DetailsListBase.getDerivedStateFromProps = function (nextProps, previousState)
{
return previousState.getDerivedStateFromProps(nextProps, previousState);
};
DetailsListBase.prototype.scrollToIndex = function (index, measureItem,
scrollToMode) {
this._list.current && this._list.current.scrollToIndex(index, measureItem,
scrollToMode);
this._groupedList.current && this._groupedList.current.scrollToIndex(index,
measureItem, scrollToMode);
};
DetailsListBase.prototype.focusIndex = function (index, forceIntoFirstElement,
measureItem, scrollToMode) {
var item = this.props.items[index];
if (item) {
this.scrollToIndex(index, measureItem, scrollToMode);
var itemKey = this._getItemKey(item, index);
var row = this._activeRows[itemKey];
if (row) {
this._setFocusToRow(row, forceIntoFirstElement);
}
}
};
DetailsListBase.prototype.getStartItemIndexInView = function () {
if (this._list && this._list.current) {
return this._list.current.getStartItemIndexInView();
}
else if (this._groupedList && this._groupedList.current) {
return this._groupedList.current.getStartItemIndexInView();
}
return 0;
};
DetailsListBase.prototype.updateColumn = function (column, options) {
var _a, _b;
var _c = this.props, _d = _c.columns, columns = _d === void 0 ?
NO_COLUMNS : _d, selectionMode = _c.selectionMode, checkboxVisibility =
_c.checkboxVisibility, columnReorderOptions = _c.columnReorderOptions;
var width = options.width, newColumnIndex = options.newColumnIndex;
var index = columns.findIndex(function (col) { return col.key ===
column.key; });
if (width) {
this._onColumnResized(column, width, index);
}
if (newColumnIndex !== undefined && columnReorderOptions) {
var isCheckboxColumnHidden = selectionMode ===
Selection_1.SelectionMode.none || checkboxVisibility ===
DetailsList_types_1.CheckboxVisibility.hidden;
var showCheckbox = checkboxVisibility !==
DetailsList_types_1.CheckboxVisibility.hidden;
var columnIndex = (showCheckbox ? 2 : 1) + index;
var draggedIndex = isCheckboxColumnHidden ? columnIndex - 1 :
columnIndex - 2;
var targetIndex = isCheckboxColumnHidden ? newColumnIndex - 1 :
newColumnIndex - 2;
var frozenColumnCountFromStart = (_a =
columnReorderOptions.frozenColumnCountFromStart) !== null && _a !== void 0 ? _a :
0;
var frozenColumnCountFromEnd = (_b =
columnReorderOptions.frozenColumnCountFromEnd) !== null && _b !== void 0 ? _b : 0;
var isValidTargetIndex = targetIndex >= frozenColumnCountFromStart &&
targetIndex < columns.length - frozenColumnCountFromEnd;
if (isValidTargetIndex) {
if (columnReorderOptions.onColumnDrop) {
var dragDropDetails = {
draggedIndex: draggedIndex,
targetIndex: targetIndex,
};
columnReorderOptions.onColumnDrop(dragDropDetails);
}
else if (columnReorderOptions.handleColumnReorder) {
columnReorderOptions.handleColumnReorder(draggedIndex,
targetIndex);
}
}
}
};
DetailsListBase.prototype.componentWillUnmount = function () {
if (this._dragDropHelper) {
// TODO If the DragDropHelper was passed via props, this will dispose
it, which is incorrect behavior.
this._dragDropHelper.dispose();
}
};
DetailsListBase.prototype.componentDidUpdate = function (prevProps, prevState)
{
this._notifyColumnsResized();
if (this._initialFocusedIndex !== undefined) {
var item = this.props.items[this._initialFocusedIndex];
if (item) {
var itemKey = this._getItemKey(item, this._initialFocusedIndex);
if (row) {
this._setFocusToRowIfPending(row);
}
}
}
if (this.props.items !== prevProps.items &&
this.props.items.length > 0 &&
this.state.focusedItemIndex !== -1 &&
!Utilities_1.elementContains(this._root.current,
document.activeElement, false)) {
// Item set has changed and previously-focused item is gone.
// Set focus to item at index of previously-focused item if it is in
range,
// else set focus to the last item.
var index = this.state.focusedItemIndex < this.props.items.length
? this.state.focusedItemIndex
: this.props.items.length - 1;
var item = this.props.items[index];
var itemKey = this._getItemKey(item, this.state.focusedItemIndex);
if (row) {
this._setFocusToRow(row);
}
else {
this._initialFocusedIndex = index;
}
}
if (this.props.onDidUpdate) {
this.props.onDidUpdate(this);
}
};
DetailsListBase.prototype.render = function () {
return (React.createElement(DetailsListInner, tslib_1.__assign({},
this.props, this.state, { selection: this._selection, dragDropHelper:
this._dragDropHelper, rootRef: this._root, listRef: this._list, groupedListRef:
this._groupedList, focusZoneRef: this._focusZone, headerRef: this._header,
selectionZoneRef: this._selectionZone, onGroupExpandStateChanged:
this._onGroupExpandStateChanged, onColumnIsSizingChanged:
this._onColumnIsSizingChanged, onRowDidMount: this._onRowDidMount,
onRowWillUnmount: this._onRowWillUnmount, onColumnResized: this._onColumnResized,
onColumnAutoResized: this._onColumnAutoResized, onToggleCollapse:
this._onToggleCollapse, onActiveRowChanged: this._onActiveRowChanged, onBlur:
this._onBlur, onRenderDefaultRow: this._onRenderRow })));
};
DetailsListBase.prototype.forceUpdate = function () {
_super.prototype.forceUpdate.call(this);
this._forceListUpdates();
};
DetailsListBase.prototype._getGroupNestingDepth = function () {
var groups = this.props.groups;
var level = 0;
var groupsInLevel = groups;
while (groupsInLevel && groupsInLevel.length > 0) {
level++;
groupsInLevel = groupsInLevel[0].children;
}
return level;
};
DetailsListBase.prototype._setFocusToRowIfPending = function (row) {
var itemIndex = row.props.itemIndex;
if (this._initialFocusedIndex !== undefined && itemIndex ===
this._initialFocusedIndex) {
this._setFocusToRow(row);
delete this._initialFocusedIndex;
}
};
DetailsListBase.prototype._setFocusToRow = function (row,
forceIntoFirstElement) {
if (this._selectionZone.current) {
this._selectionZone.current.ignoreNextFocus();
}
row.focus(forceIntoFirstElement);
}, 0);
};
DetailsListBase.prototype._forceListUpdates = function () {
if (this._groupedList.current) {
this._groupedList.current.forceUpdate();
}
if (this._list.current) {
this._list.current.forceUpdate();
}
};
DetailsListBase.prototype._notifyColumnsResized = function () {
this.state.adjustedColumns.forEach(function (column) {
if (column.onColumnResize) {
column.onColumnResize(column.currentWidth);
}
});
};
DetailsListBase.prototype._adjustColumns = function (newProps, previousState,
forceUpdate, resizingColumnIndex) {
var adjustedColumns = this._getAdjustedColumns(newProps, previousState,
forceUpdate, resizingColumnIndex);
var viewport = this.props.viewport;
var viewportWidth = viewport && viewport.width ? viewport.width : 0;
return tslib_1.__assign(tslib_1.__assign({}, previousState),
{ adjustedColumns: adjustedColumns, lastWidth: viewportWidth });
};
/** Returns adjusted columns, given the viewport size and layout mode. */
DetailsListBase.prototype._getAdjustedColumns = function (newProps,
previousState, forceUpdate, resizingColumnIndex) {
var _this = this;
var newItems = newProps.items, layoutMode = newProps.layoutMode,
selectionMode = newProps.selectionMode, viewport = newProps.viewport;
var viewportWidth = viewport && viewport.width ? viewport.width : 0;
var newColumns = newProps.columns;
var columns = this.props ? this.props.columns : [];
var lastWidth = previousState ? previousState.lastWidth : -1;
var lastSelectionMode = previousState ? previousState.lastSelectionMode :
undefined;
if (!forceUpdate &&
lastWidth === viewportWidth &&
lastSelectionMode === selectionMode &&
(!columns || newColumns === columns)) {
return newColumns || [];
}
newColumns = newColumns || buildColumns(newItems, true);
var adjustedColumns;
if (layoutMode === DetailsList_types_1.DetailsListLayoutMode.fixedColumns)
{
adjustedColumns = this._getFixedColumns(newColumns, viewportWidth,
newProps);
// Preserve adjusted column calculated widths.
adjustedColumns.forEach(function (column) {
_this._rememberCalculatedWidth(column, column.calculatedWidth);
});
}
else {
adjustedColumns = this._getJustifiedColumns(newColumns, viewportWidth,
newProps);
adjustedColumns.forEach(function (column) {
_this._getColumnOverride(column.key).currentWidth =
column.calculatedWidth;
});
}
return adjustedColumns;
};
/** Builds a set of columns based on the given columns mixed with the current
overrides. */
DetailsListBase.prototype._getFixedColumns = function (newColumns,
viewportWidth, props) {
var _this = this;
var _a = this.props, _b = _a.selectionMode, selectionMode = _b === void 0 ?
this._selection.mode : _b, checkboxVisibility = _a.checkboxVisibility, flexMargin =
_a.flexMargin, skipViewportMeasures = _a.skipViewportMeasures;
var remainingWidth = viewportWidth - (flexMargin || 0);
var sumProportionalWidth = 0;
newColumns.forEach(function (col) {
if (skipViewportMeasures || !col.flexGrow) {
remainingWidth -= col.maxWidth || col.minWidth || MIN_COLUMN_WIDTH;
}
else {
remainingWidth -= col.minWidth || MIN_COLUMN_WIDTH;
sumProportionalWidth += col.flexGrow;
}
remainingWidth -= getPaddedWidth(col, props, true);
});
var rowCheckWidth = selectionMode !== Selection_1.SelectionMode.none &&
checkboxVisibility !== DetailsList_types_1.CheckboxVisibility.hidden ?
DetailsRowCheck_styles_1.CHECK_CELL_WIDTH : 0;
var groupExpandWidth = this._getGroupNestingDepth() *
GroupSpacer_1.SPACER_WIDTH;
remainingWidth -= rowCheckWidth + groupExpandWidth;
var widthFraction = remainingWidth / sumProportionalWidth;
// Shrinks proportional columns to their max width and adds the remaining
width to distribute to other columns.
if (!skipViewportMeasures) {
newColumns.forEach(function (column) {
var newColumn = tslib_1.__assign(tslib_1.__assign({}, column),
_this._columnOverrides[column.key]);
if (newColumn.flexGrow && newColumn.maxWidth) {
var fullWidth = newColumn.flexGrow * widthFraction +
newColumn.minWidth;
var shrinkWidth = fullWidth - newColumn.maxWidth;
if (shrinkWidth > 0) {
remainingWidth += shrinkWidth;
sumProportionalWidth -= (shrinkWidth / (fullWidth -
newColumn.minWidth)) * newColumn.flexGrow;
}
}
});
}
widthFraction = remainingWidth > 0 ? remainingWidth /
sumProportionalWidth : 0;
return newColumns.map(function (column) {
var newColumn = tslib_1.__assign(tslib_1.__assign({}, column),
// Delay computation until viewport width is available.
if (!skipViewportMeasures && newColumn.flexGrow && remainingWidth <= 0)
{
return newColumn;
}
if (!newColumn.calculatedWidth) {
if (!skipViewportMeasures && newColumn.flexGrow) {
// Assigns the proportion of the remaining extra width after
all columns have met minimum widths.
newColumn.calculatedWidth = newColumn.minWidth +
newColumn.flexGrow * widthFraction;
newColumn.calculatedWidth = Math.min(newColumn.calculatedWidth,
newColumn.maxWidth || Number.MAX_VALUE);
}
else {
newColumn.calculatedWidth = newColumn.maxWidth ||
newColumn.minWidth || MIN_COLUMN_WIDTH;
}
}
return newColumn;
});
};
/** Builds a set of columns to fix within the viewport width. */
DetailsListBase.prototype._getJustifiedColumns = function (newColumns,
viewportWidth, props) {
var _this = this;
var _a = props.selectionMode, selectionMode = _a === void 0 ?
this._selection.mode : _a, checkboxVisibility = props.checkboxVisibility;
var rowCheckWidth = selectionMode !== Selection_1.SelectionMode.none &&
checkboxVisibility !== DetailsList_types_1.CheckboxVisibility.hidden ?
DetailsRowCheck_styles_1.CHECK_CELL_WIDTH : 0;
var groupExpandWidth = this._getGroupNestingDepth() *
GroupSpacer_1.SPACER_WIDTH;
var totalWidth = 0; // offset because we have one less inner padding.
var minimumWidth = 0;
var availableWidth = viewportWidth - (rowCheckWidth + groupExpandWidth);
var adjustedColumns = newColumns.map(function (column, i) {
var baseColumn = tslib_1.__assign(tslib_1.__assign({}, column),
{ calculatedWidth: column.minWidth || MIN_COLUMN_WIDTH });
var newColumn = tslib_1.__assign(tslib_1.__assign({}, baseColumn),
if (!(baseColumn.isCollapsible || baseColumn.isCollapsable)) {
minimumWidth += getPaddedWidth(baseColumn, props);
}
totalWidth += getPaddedWidth(newColumn, props);
return newColumn;
});
if (minimumWidth > availableWidth) {
}
var lastIndex = adjustedColumns.length - 1;
// Shrink or remove collapsable columns.
while (lastIndex >= 0 && totalWidth > availableWidth) {
var column = adjustedColumns[lastIndex];
var minWidth = column.minWidth || MIN_COLUMN_WIDTH;
var overflowWidth = totalWidth - availableWidth;
if (column.calculatedWidth - minWidth >= overflowWidth || !
(column.isCollapsible || column.isCollapsable)) {
var originalWidth = column.calculatedWidth;
column.calculatedWidth = Math.max(column.calculatedWidth -
overflowWidth, minWidth);
totalWidth -= originalWidth - column.calculatedWidth;
}
else {
totalWidth -= getPaddedWidth(column, props);
adjustedColumns.splice(lastIndex, 1);
}
lastIndex--;
}
// Then expand columns starting at the beginning, until we've filled the
width.
for (var i = 0; i < adjustedColumns.length && totalWidth < availableWidth;
i++) {
var column = adjustedColumns[i];
var isLast = i === adjustedColumns.length - 1;
var overrides = this._columnOverrides[column.key];
if (overrides && overrides.calculatedWidth && !isLast) {
continue;
}
var spaceLeft = availableWidth - totalWidth;
var increment = void 0;
if (isLast) {
increment = spaceLeft;
}
else {
var maxWidth = column.maxWidth;
var minWidth = column.minWidth || maxWidth || MIN_COLUMN_WIDTH;
increment = maxWidth ? Math.min(spaceLeft, maxWidth - minWidth) :
spaceLeft;
}
column.calculatedWidth = column.calculatedWidth + increment;
totalWidth += increment;
}
};
DetailsListBase.prototype._rememberCalculatedWidth = function (column,
newCalculatedWidth) {
var overrides = this._getColumnOverride(column.key);
overrides.calculatedWidth = newCalculatedWidth;
overrides.currentWidth = newCalculatedWidth;
};
DetailsListBase.prototype._getColumnOverride = function (key) {
return (this._columnOverrides[key] = this._columnOverrides[key] || {});
};
DetailsListBase.prototype._getItemKey = function (item, itemIndex) {
var getKey = this.props.getKey;
var itemKey = undefined;
if (item) {
itemKey = item.key;
}
if (getKey) {
itemKey = getKey(item, itemIndex);
}
if (!itemKey) {
itemKey = itemIndex;
}
return itemKey;
};
DetailsListBase.defaultProps = {
layoutMode: DetailsList_types_1.DetailsListLayoutMode.justified,
selectionMode: Selection_1.SelectionMode.multiple,
constrainMode: DetailsList_types_1.ConstrainMode.horizontalConstrained,
checkboxVisibility: DetailsList_types_1.CheckboxVisibility.onHover,
isHeaderVisible: true,
compact: false,
useFastIcons: true,
};
DetailsListBase = tslib_1.__decorate([
withViewport_1.withViewport
], DetailsListBase);
return DetailsListBase;
exports.DetailsListBase = DetailsListBase;
function buildColumns(items, canResizeColumns, onColumnClick, sortedColumnKey,
isSortedDescending, groupedColumnKey, isMultiline, columnActionsMode) {
var columns = [];
if (items && items.length) {
var firstItem = items[0];
for (var propName in firstItem) {
if (firstItem.hasOwnProperty(propName)) {
columns.push({
key: propName,
name: propName,
fieldName: propName,
minWidth: MIN_COLUMN_WIDTH,
maxWidth: 300,
isCollapsable: !!columns.length,
isCollapsible: !!columns.length,
isMultiline: isMultiline === undefined ? false : isMultiline,
isSorted: sortedColumnKey === propName,
isSortedDescending: !!isSortedDescending,
isRowHeader: false,
columnActionsMode: columnActionsMode !== null &&
columnActionsMode !== void 0 ? columnActionsMode :
DetailsList_types_1.ColumnActionsMode.clickable,
isResizable: canResizeColumns,
onColumnClick: onColumnClick,
isGrouped: groupedColumnKey === propName,
});
}
}
}
return columns;
}
exports.buildColumns = buildColumns;
function getPaddedWidth(column, props, paddingOnly) {
var _a = props.cellStyleProps, cellStyleProps = _a === void 0 ?
DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _a;
return ((paddingOnly ? 0 : column.calculatedWidth) +
(column.isPadded ? cellStyleProps.cellExtraRightPadding : 0));
}
function getGroupNestingDepth(groups) {
var level = 0;
level++;
}
return level;
}
function useGroupedDetailsListIndexMap(groups) {
return React.useMemo(function () {
var indexMap = {};
if (groups) {
var rowCount = 1;
var numGroupHeaders = 1;
for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
var group = groups_1[_i];
var key = group.key;
indexMap[key] = { numOfGroupHeadersBeforeItem: numGroupHeaders,
totalRowCount: rowCount };
numGroupHeaders++;
rowCount += group.count + 1;
}
}
return indexMap;
}, [groups]);
}
//# sourceMappingURL=DetailsList.base.js.map
/***/ }),
/***/ 23923:
"use strict";

exports.DetailsList = void 0;
var DetailsList_base_1 = __webpack_require__(61925);
var DetailsList_styles_1 = __webpack_require__(56290);
exports.DetailsList = Utilities_1.styled(DetailsList_base_1.DetailsListBase,
DetailsList_styles_1.getDetailsListStyles, undefined, {
scope: 'DetailsList',
});
//# sourceMappingURL=DetailsList.js.map
/***/ }),
/***/ 56290:
"use strict";

exports.getDetailsListStyles = void 0;
root: 'ms-DetailsList',
compact: 'ms-DetailsList--Compact',
contentWrapper: 'ms-DetailsList-contentWrapper',
headerWrapper: 'ms-DetailsList-headerWrapper',
isFixed: 'is-fixed',
isHorizontalConstrained: 'is-horizontalConstrained',
listCell: 'ms-List-cell',
};
var getDetailsListStyles = function (props) {
var _a, _b;
var theme = props.theme, className = props.className, isHorizontalConstrained =
props.isHorizontalConstrained, compact = props.compact, isFixed = props.isFixed;
return {
root: [
classNames.root,
theme.fonts.small,
{
color: semanticColors.listText,
_a["& ." + classNames.listCell] = {
minHeight: 38,
wordBreak: 'break-word',
},
_a),
},
isFixed && classNames.isFixed,
compact && [
classNames.compact,
{
_b["." + classNames.listCell] = {
minHeight: 32,
},
_b),
},
],
isHorizontalConstrained && [
classNames.isHorizontalConstrained,
{
overflowX: 'auto',
overflowY: 'visible',
WebkitOverflowScrolling: 'touch',
},
],
className,
],
focusZone: [
{
minWidth: '100%',
minHeight: 1,
},
],
headerWrapper: classNames.headerWrapper,
contentWrapper: classNames.contentWrapper,
};
};
exports.getDetailsListStyles = getDetailsListStyles;
//# sourceMappingURL=DetailsList.styles.js.map
/***/ }),
/***/ 709:
"use strict";

exports.CheckboxVisibility = exports.DetailsListLayoutMode =
exports.ColumnDragEndLocation = exports.ConstrainMode = exports.ColumnActionsMode =
void 0;
/**
* Enum to describe how a particular column header behaves.
* This is used to to specify the property ÌColumn.columnActionsMode`.
* If ÌColumn.columnActionsMode` is undefined, it's equivalent to
`ColumnActionsMode.clickable`.
*/
var ColumnActionsMode;
(function (ColumnActionsMode) {
/** Renders the column header as disabled. */
ColumnActionsMode[ColumnActionsMode["disabled"] = 0] = "disabled";
/** Renders the column header as clickable. Default value. */
ColumnActionsMode[ColumnActionsMode["clickable"] = 1] = "clickable";
/** Renders the column header as clickable and displays the dropdown chevron.
*/
ColumnActionsMode[ColumnActionsMode["hasDropdown"] = 2] = "hasDropdown";
})(ColumnActionsMode = exports.ColumnActionsMode || (exports.ColumnActionsMode =
{}));
/**
*/
var ConstrainMode;
(function (ConstrainMode) {
/** Lets the content grow which allows the page to manage scrolling. */
ConstrainMode[ConstrainMode["unconstrained"] = 0] = "unconstrained";
/** Constrains the list to the given layout space. */
ConstrainMode[ConstrainMode["horizontalConstrained"] = 1] =
"horizontalConstrained";
})(ConstrainMode = exports.ConstrainMode || (exports.ConstrainMode = {}));
/**
* Enum to describe where the column has been dropped, after starting the drag
*/
var ColumnDragEndLocation;
(function (ColumnDragEndLocation) {
/** Drag ended outside of current list */
ColumnDragEndLocation[ColumnDragEndLocation["outside"] = 0] = "outside";
/** Drag ended within current list */
ColumnDragEndLocation[ColumnDragEndLocation["surface"] = 1] = "surface";
/** Drag ended on header */
ColumnDragEndLocation[ColumnDragEndLocation["header"] = 2] = "header";
})(ColumnDragEndLocation = exports.ColumnDragEndLocation ||
(exports.ColumnDragEndLocation = {}));
/**
*/
var DetailsListLayoutMode;
(function (DetailsListLayoutMode) {
/**
* Lets the user resize columns and makes not attempt to fit them.
*/
DetailsListLayoutMode[DetailsListLayoutMode["fixedColumns"] = 0] =
"fixedColumns";
/**
* Manages which columns are visible, tries to size them according to their
min/max rules and drops
* off columns that can't fit and have isCollapsible set.
*/
DetailsListLayoutMode[DetailsListLayoutMode["justified"] = 1] = "justified";
})(DetailsListLayoutMode = exports.DetailsListLayoutMode ||
(exports.DetailsListLayoutMode = {}));
/**
*/
var CheckboxVisibility;
(function (CheckboxVisibility) {
/** Visible on hover. */
CheckboxVisibility[CheckboxVisibility["onHover"] = 0] = "onHover";
/** Visible always. */
CheckboxVisibility[CheckboxVisibility["always"] = 1] = "always";
/** Hide checkboxes. */
CheckboxVisibility[CheckboxVisibility["hidden"] = 2] = "hidden";
})(CheckboxVisibility = exports.CheckboxVisibility || (exports.CheckboxVisibility =
{}));
//# sourceMappingURL=DetailsList.types.js.map
/***/ }),
/***/ 39245:
"use strict";

exports.DetailsRowBase = void 0;
var DetailsRowCheck_1 = __webpack_require__(62570);
var DetailsRowFields_1 = __webpack_require__(49364);
var DEFAULT_DROPPING_CSS_CLASS = 'is-dropping';
var DetailsRowBase = /** @class */ (function (_super) {
tslib_1.__extends(DetailsRowBase, _super);
function DetailsRowBase(props) {
_this._cellMeasurer = React.createRef();
_this._onSelectionChanged = function () {
var selectionState = getSelectionState(_this.props);
if (!Utilities_1.shallowCompare(selectionState,
_this.state.selectionState)) {
_this.setState({
selectionState: selectionState,
});
}
};
/**
* update isDropping state based on the input value, which is used to
change style during drag and drop
*
* when change to true, that means drag enter. we will add default dropping
class name
* or the custom dropping class name (return result from onDragEnter) to
the root elemet.
*
* when change to false, that means drag leave. we will remove the dropping
class name from root element.
*
* @param newValue - New isDropping state value
* @param event - The event trigger dropping state change which can be
dragenter, dragleave etc
*/
_this._updateDroppingState = function (newValue, event) {
var isDropping = _this.state.isDropping;
var _a = _this.props, dragDropEvents = _a.dragDropEvents, item =
_a.item;
if (!newValue) {
if (dragDropEvents.onDragLeave) {
dragDropEvents.onDragLeave(item, event);
}
}
else if (dragDropEvents.onDragEnter) {
_this._droppingClassNames = dragDropEvents.onDragEnter(item,
event);
}
if (isDropping !== newValue) {
_this.setState({ isDropping: newValue });
}
};
_this.state = {
selectionState: getSelectionState(props),
columnMeasureInfo: undefined,
isDropping: false,
};
_this._droppingClassNames = '';
return _this;
}
DetailsRowBase.getDerivedStateFromProps = function (nextProps, previousState) {
{ selectionState: getSelectionState(nextProps) });
};
DetailsRowBase.prototype.componentDidMount = function () {
var _a = this.props, dragDropHelper = _a.dragDropHelper, selection =
_a.selection, item = _a.item, onDidMount = _a.onDidMount;
if (dragDropHelper && this._root.current) {
dragDropHelper.subscribe(this._root.current, this._events,
this._getRowDragDropOptions());
}
if (selection) {
this._onSelectionChanged);
}
if (onDidMount && item) {
// If the item appears later, we should wait for it before calling this
method.
this._onDidMountCalled = true;
onDidMount(this);
}
};
DetailsRowBase.prototype.componentDidUpdate = function (previousProps) {
var state = this.state;
var _a = this.props, item = _a.item, onDidMount = _a.onDidMount;
var columnMeasureInfo = state.columnMeasureInfo;
if (this.props.itemIndex !== previousProps.itemIndex ||
this.props.item !== previousProps.item ||
this.props.dragDropHelper !== previousProps.dragDropHelper) {
}
if (this.props.dragDropHelper && this._root.current) {
this._getRowDragDropOptions());
}
}
if (columnMeasureInfo && columnMeasureInfo.index >= 0 &&
this._cellMeasurer.current) {
var newWidth =
this._cellMeasurer.current.getBoundingClientRect().width;
columnMeasureInfo.onMeasureDone(newWidth);
this.setState({
columnMeasureInfo: undefined,
});
}
if (item && onDidMount && !this._onDidMountCalled) {
this._onDidMountCalled = true;
onDidMount(this);
}
};
DetailsRowBase.prototype.componentWillUnmount = function () {
var _a = this.props, item = _a.item, onWillUnmount = _a.onWillUnmount;
// Only call the onWillUnmount callback if we have an item.
if (onWillUnmount && item) {
onWillUnmount(this);
}
}
};
DetailsRowBase.prototype.shouldComponentUpdate = function (nextProps,
nextState) {
if (this.props.useReducedRowRenderer) {
var newSelectionState = getSelectionState(nextProps);
if (this.state.selectionState.isSelected !==
newSelectionState.isSelected) {
return true;
}
return !Utilities_1.shallowCompare(this.props, nextProps);
}
else {
return true;
}
};
DetailsRowBase.prototype.render = function () {
var _a = this.props, className = _a.className, _b = _a.columns, columns =
_b === void 0 ? NO_COLUMNS : _b, dragDropEvents = _a.dragDropEvents, item =
_a.item, itemIndex = _a.itemIndex, id = _a.id, _c = _a.flatIndexOffset,
flatIndexOffset = _c === void 0 ? 2 : _c, _d = _a.onRenderCheck, onRenderCheck = _d
=== void 0 ? this._onRenderCheck : _d, onRenderDetailsCheckbox =
_a.onRenderDetailsCheckbox, onRenderItemColumn = _a.onRenderItemColumn,
onRenderField = _a.onRenderField, getCellValueKey = _a.getCellValueKey,
selectionMode = _a.selectionMode, _e = _a.rowWidth, rowWidth = _e === void 0 ? 0 :
_e, checkboxVisibility = _a.checkboxVisibility, getRowAriaLabel =
_a.getRowAriaLabel, getRowAriaDescription = _a.getRowAriaDescription,
getRowAriaDescribedBy = _a.getRowAriaDescribedBy, checkButtonAriaLabel =
_a.checkButtonAriaLabel, checkboxCellClassName = _a.checkboxCellClassName,
/** Alias rowFieldsAs as RowFields and default to DetailsRowFields if
rowFieldsAs does not exist */
rowFieldsAs = _a.rowFieldsAs, selection = _a.selection, indentWidth =
_a.indentWidth, enableUpdateAnimations = _a.enableUpdateAnimations, compact =
_a.compact, theme = _a.theme, styles = _a.styles, cellsByColumn = _a.cellsByColumn,
groupNestingDepth = _a.groupNestingDepth, _f = _a.useFastIcons, useFastIcons = _f
=== void 0 ? true : _f, cellStyleProps = _a.cellStyleProps, group = _a.group,
focusZoneProps = _a.focusZoneProps, _g = _a.disabled, disabled = _g === void 0 ?
false : _g;
var _h = this.state, columnMeasureInfo = _h.columnMeasureInfo, isDropping =
_h.isDropping;
var _j = this.state.selectionState, _k = _j.isSelected, isSelected = _k ===
void 0 ? false : _k, _l = _j.isSelectionModal, isSelectionModal = _l === void 0 ?
false : _l;
var isDraggable = dragDropEvents ? !!(dragDropEvents.canDrag &&
dragDropEvents.canDrag(item)) : undefined;
var droppingClassName = isDropping ? this._droppingClassNames ||
DEFAULT_DROPPING_CSS_CLASS : '';
var ariaLabel = getRowAriaLabel ? getRowAriaLabel(item) : undefined;
var ariaRowDescription = getRowAriaDescription ?
getRowAriaDescription(item) : undefined;
var ariaDescribedBy = getRowAriaDescribedBy ? getRowAriaDescribedBy(item) :
undefined;
var canSelect = !!selection && selection.canSelectItem(item, itemIndex)
&& !disabled;
var isContentUnselectable = selectionMode ===
Selection_1.SelectionMode.multiple;
var showCheckbox = selectionMode !== Selection_1.SelectionMode.none &&
checkboxVisibility !== DetailsList_types_1.CheckboxVisibility.hidden;
var ariaSelected = selectionMode === Selection_1.SelectionMode.none ?
undefined : isSelected;
var ariaPositionInSet = group ? itemIndex - group.startIndex + 1 :
undefined;
var ariaSetSize = group ? group.count : undefined;
var focusZoneDirection = focusZoneProps ? focusZoneProps.direction :
FocusZone_1.FocusZoneDirection.horizontal;
this._classNames = tslib_1.__assign(tslib_1.__assign({}, this._classNames),
getClassNames(styles, {
theme: theme,
isSelected: isSelected,
canSelect: !isContentUnselectable,
anySelected: isSelectionModal,
checkboxCellClassName: checkboxCellClassName,
droppingClassName: droppingClassName,
compact: compact,
enableUpdateAnimations: enableUpdateAnimations,
disabled: disabled,
}));
var rowClassNames = {
isMultiline: this._classNames.isMultiline,
isRowHeader: this._classNames.isRowHeader,
cell: this._classNames.cell,
cellAnimation: this._classNames.cellAnimation,
cellPadded: this._classNames.cellPadded,
cellUnpadded: this._classNames.cellUnpadded,
fields: this._classNames.fields,
};
// Only re-assign rowClassNames when classNames have changed.
// Otherwise, they will cause DetailsRowFields to unnecessarily
// re-render, see https://github.com/microsoft/fluentui/pull/8799.
// Refactor DetailsRowFields to generate own styles to remove need for
this.
if (!Utilities_1.shallowCompare(this._rowClassNames || {}, rowClassNames))
{
this._rowClassNames = rowClassNames;
}
var RowFields = rowFieldsAs ? Utilities_1.composeComponentAs(rowFieldsAs,
DetailsRowFields_1.DetailsRowFields) : DetailsRowFields_1.DetailsRowFields;
var rowFields = (React.createElement(RowFields, { rowClassNames:
this._rowClassNames, rowHeaderId: id + "-header", cellsByColumn: cellsByColumn,
columns: columns, item: item, itemIndex: itemIndex, isSelected: isSelected,
columnStartIndex: (showCheckbox ? 1 : 0) + (groupNestingDepth ? 1 : 0),
onRenderItemColumn: onRenderItemColumn, onRenderField: onRenderField,
getCellValueKey: getCellValueKey, enableUpdateAnimations: enableUpdateAnimations,
cellStyleProps: cellStyleProps }));
var defaultRole = 'row';
var role = this.props.role ? this.props.role : defaultRole;
this._ariaRowDescriptionId = Utilities_3.getId('DetailsRow-description');
// When the user does not specify any column is a row-header in the columns
props,
// The aria-labelledby of the checkbox does not specify {id}-header.
var hasRowHeader = columns.some(function (column) {
return !!column.isRowHeader;
});
var ariaLabelledby = id + "-checkbox" + (hasRowHeader ? " " + id + "-
header" : '');
return (React.createElement(FocusZone_1.FocusZone,
tslib_1.__assign({ "data-is-focusable": true },
Utilities_1.getNativeProps(this.props, Utilities_1.divProperties), (typeof
isDraggable === 'boolean'
? {
'data-is-draggable': isDraggable,
draggable: isDraggable,
}
: {}), focusZoneProps, { direction: focusZoneDirection, elementRef:
this._root, componentRef: this._focusZone, role: role, "aria-label": ariaLabel,
"aria-disabled": disabled || undefined, "aria-describedby": ariaRowDescription ?
this._ariaRowDescriptionId : ariaDescribedBy, className: this._classNames.root,
"data-selection-index": itemIndex, "data-selection-touch-invoke": true, "data-
selection-disabled": disabled || undefined, "data-item-index": itemIndex, "aria-
rowindex": ariaPositionInSet === undefined ? itemIndex + flatIndexOffset :
undefined, "aria-level": (groupNestingDepth && groupNestingDepth + 1) || undefined,
"aria-posinset": ariaPositionInSet, "aria-setsize": ariaSetSize, "data-
automationid": "DetailsRow", style: { minWidth: rowWidth }, "aria-selected":
ariaSelected, allowFocusRoot: true }),
ariaRowDescription ? (React.createElement("span", { key: "description",
role: "presentation", hidden: true, id: this._ariaRowDescriptionId },
ariaRowDescription)) : null,
showCheckbox && (React.createElement("div", { role: "gridcell", "data-
selection-toggle": true, className: this._classNames.checkCell }, onRenderCheck({
id: id ? id + "-checkbox" : undefined,
selected: isSelected,
anySelected: isSelectionModal,
'aria-label': checkButtonAriaLabel,
'aria-labelledby': id ? ariaLabelledby : undefined,
canSelect: canSelect,
compact: compact,
className: this._classNames.check,
theme: theme,
isVisible: checkboxVisibility ===
DetailsList_types_1.CheckboxVisibility.always,
onRenderDetailsCheckbox: onRenderDetailsCheckbox,
}))),
indentWidth, role: "gridcell", count: groupNestingDepth -
(this.props.collapseAllVisibility === GroupedList_1.CollapseAllVisibility.hidden ?
1 : 0) }),
item && rowFields,
columnMeasureInfo && (React.createElement("span", { role:
"presentation", className: Utilities_1.css(this._classNames.cellMeasurer,
this._classNames.cell), ref: this._cellMeasurer },
React.createElement(RowFields, { rowClassNames:
this._rowClassNames, rowHeaderId: id + "-header", columns:
[columnMeasureInfo.column], item: item, itemIndex: itemIndex, columnStartIndex:
(showCheckbox ? 1 : 0) + (groupNestingDepth ? 1 : 0) + columns.length,
onRenderItemColumn: onRenderItemColumn, getCellValueKey: getCellValueKey }))),
React.createElement("span", { role: "checkbox", className:
this._classNames.checkCover, "aria-checked": isSelected, "data-selection-toggle":
true })));
};
/**
* measure cell at index. and call the call back with the measured cell width
when finish measure
*
* @param index - The cell index
* @param onMeasureDone - The call back function when finish measure
*/
DetailsRowBase.prototype.measureCell = function (index, onMeasureDone) {
var _a = this.props.columns, columns = _a === void 0 ? NO_COLUMNS : _a;
var column = tslib_1.__assign({}, columns[index]);
column.minWidth = 0;
column.maxWidth = 999999;
delete column.calculatedWidth;
this.setState({
columnMeasureInfo: {
index: index,
column: column,
onMeasureDone: onMeasureDone,
},
});
};
DetailsRowBase.prototype.focus = function (forceIntoFirstElement) {
var _a;
return !!((_a = this._focusZone.current) === null || _a === void 0 ? void 0
: _a.focus(forceIntoFirstElement));
};
DetailsRowBase.prototype._onRenderCheck = function (props) {
return React.createElement(DetailsRowCheck_1.DetailsRowCheck,
};
DetailsRowBase.prototype._getRowDragDropOptions = function () {
var _a = this.props, item = _a.item, itemIndex = _a.itemIndex,
dragDropEvents = _a.dragDropEvents, eventsToRegister = _a.eventsToRegister;
var options = {
eventMap: eventsToRegister,
selectionIndex: itemIndex,
context: { data: item, index: itemIndex },
canDrag: dragDropEvents.canDrag,
canDrop: dragDropEvents.canDrop,
onDragStart: dragDropEvents.onDragStart,
updateDropState: this._updateDroppingState,
onDrop: dragDropEvents.onDrop,
onDragEnd: dragDropEvents.onDragEnd,
onDragOver: dragDropEvents.onDragOver,
};
return options;
};
return DetailsRowBase;
exports.DetailsRowBase = DetailsRowBase;
function getSelectionState(props) {
var _a;
var itemIndex = props.itemIndex, selection = props.selection;
return {
isSelected: !!(selection === null || selection === void 0 ? void 0 :
selection.isIndexSelected(itemIndex)),
isSelectionModal: !!((_a = selection === null || selection === void 0 ?
void 0 : selection.isModal) === null || _a === void 0 ? void 0 :
_a.call(selection)),
};
}
//# sourceMappingURL=DetailsRow.base.js.map
/***/ }),
/***/ 14696:
"use strict";

exports.DetailsRow = void 0;
var DetailsRow_base_1 = __webpack_require__(39245);
exports.DetailsRow = Utilities_1.styled(DetailsRow_base_1.DetailsRowBase,
DetailsRow_styles_1.getDetailsRowStyles, undefined, {
scope: 'DetailsRow',
});
//# sourceMappingURL=DetailsRow.js.map
/***/ }),
/***/ 57495:
"use strict";

exports.getDetailsRowStyles = exports.DEFAULT_ROW_HEIGHTS =
exports.DEFAULT_CELL_STYLE_PROPS = exports.DetailsRowGlobalClassNames = void 0;
var Link_styles_1 = __webpack_require__(5378);
exports.DetailsRowGlobalClassNames = {
root: 'ms-DetailsRow',
// TODO: in Fabric 7.0 lowercase the 'Compact' for consistency across other
components.
compact: 'ms-DetailsList--Compact',
cell: 'ms-DetailsRow-cell',
cellAnimation: 'ms-DetailsRow-cellAnimation',
cellCheck: 'ms-DetailsRow-cellCheck',
check: 'ms-DetailsRow-check',
cellMeasurer: 'ms-DetailsRow-cellMeasurer',
listCellFirstChild: 'ms-List-cell:first-child',
isContentUnselectable: 'is-contentUnselectable',
isSelected: 'is-selected',
isCheckVisible: 'is-check-visible',
isRowHeader: 'is-row-header',
fields: 'ms-DetailsRow-fields',
};
var IsFocusableSelector = "[data-is-focusable='true']";
exports.DEFAULT_CELL_STYLE_PROPS = {
cellLeftPadding: 12,
cellRightPadding: 8,
cellExtraRightPadding: 24,
};
// Source of default row heights to share.
exports.DEFAULT_ROW_HEIGHTS = {
rowHeight: 42,
compactRowHeight: 32,
};
// Constant values
var values = tslib_1.__assign(tslib_1.__assign({}, exports.DEFAULT_ROW_HEIGHTS),
{ rowVerticalPadding: 11, compactRowVerticalPadding: 6 });
var getDetailsRowStyles = function (props) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
var theme = props.theme, isSelected = props.isSelected, canSelect =
props.canSelect, droppingClassName = props.droppingClassName, anySelected =
props.anySelected, isCheckVisible = props.isCheckVisible, checkboxCellClassName =
props.checkboxCellClassName, compact = props.compact, className = props.className,
_q = props.cellStyleProps, cellStyleProps = _q === void 0 ?
exports.DEFAULT_CELL_STYLE_PROPS : _q, enableUpdateAnimations =
props.enableUpdateAnimations, disabled = props.disabled;
var palette = theme.palette, fonts = theme.fonts;
var neutralPrimary = palette.neutralPrimary, white = palette.white,
neutralSecondary = palette.neutralSecondary, neutralLighter =
palette.neutralLighter, neutralLight = palette.neutralLight, neutralDark =
palette.neutralDark, neutralQuaternaryAlt = palette.neutralQuaternaryAlt;
var _r = theme.semanticColors, focusBorder = _r.focusBorder, focusedLinkColor =
_r.linkHovered;
var classNames =
Styling_1.getGlobalClassNames(exports.DetailsRowGlobalClassNames, theme);
var colors = {
// Default
defaultHeaderText: neutralPrimary,
defaultMetaText: neutralSecondary,
defaultBackground: white,
// Default Hover
defaultHoverHeaderText: neutralDark,
defaultHoverMetaText: neutralPrimary,
defaultHoverBackground: neutralLighter,
// Selected
selectedHeaderText: neutralDark,
selectedMetaText: neutralPrimary,
selectedBackground: neutralLight,
// Selected Hover
selectedHoverHeaderText: neutralDark,
selectedHoverMetaText: neutralPrimary,
selectedHoverBackground: neutralQuaternaryAlt,
// Focus
focusHeaderText: neutralDark,
focusMetaText: neutralPrimary,
focusBackground: neutralLight,
focusHoverBackground: neutralQuaternaryAlt,
};
var rowHighContrastFocus = {
top: 2,
right: 2,
bottom: 2,
left: 2,
};
// Selected row styles
var selectedStyles = [
inset: -1,
borderColor: focusBorder,
outlineColor: white,
highContrastStyle: rowHighContrastFocus,
}),
classNames.isSelected,
{
color: colors.selectedMetaText,
background: colors.selectedBackground,
borderBottom: "1px solid " + white,
selectors: (_a = {
'&:before': {
display: 'block',
top: -1,
height: 1,
bottom: 0,
left: 0,
right: 0,
content: '',
borderTop: "1px solid " + white,
}
},
_a["." + classNames.cell + " > ." +
Link_styles_1.GlobalClassNames.root] = {
color: focusedLinkColor,
color: 'HighlightText',
},
_b),
},
// Selected State hover
_a['&:hover'] = {
background: colors.selectedHoverBackground,
color: colors.selectedHoverMetaText,
// Selected State hover meta cell
_d["." + classNames.cell] = {
},
_d["." + classNames.cell + " > ." +
},
_d),
},
// Selected State hover Header cell
_c["." + classNames.isRowHeader] = {
color: colors.selectedHoverHeaderText,
},
_e),
},
_c),
},
// Focus state
_a['&:focus'] = {
background: colors.focusBackground,
// Selected State hover meta cell
_f["." + classNames.cell] = {
color: colors.focusMetaText,
selectors: {
'> a': {
},
},
},
_g),
},
// Row header cell
_f["." + classNames.isRowHeader] = {
color: colors.focusHeaderText,
},
_h),
},
// Ensure high-contrast mode overrides default focus
background
},
_f),
},
tslib_1.__assign(tslib_1.__assign({ background: 'Highlight', color: 'HighlightText'
}, Styling_1.getHighContrastNoAdjustStyle()), { selectors: {
a: {
},
} }),
// Focus and hover state
_a['&:focus:hover'] = {
background: colors.focusHoverBackground,
},
_a),
},
];
var cannotSelectStyles = [
classNames.isContentUnselectable,
{
userSelect: 'none',
cursor: 'default',
},
];
var rootCompactStyles = {
minHeight: values.compactRowHeight,
border: 0,
};
var cellCompactStyles = {
minHeight: values.compactRowHeight,
paddingTop: values.compactRowVerticalPadding,
paddingBottom: values.compactRowVerticalPadding,
paddingLeft: cellStyleProps.cellLeftPadding + "px",
};
var defaultCellStyles = [
Styling_1.getFocusStyle(theme, { inset: -1 }),
classNames.cell,
{
minHeight: values.rowHeight,
overflow: 'hidden',
paddingTop: values.rowVerticalPadding,
paddingBottom: values.rowVerticalPadding,
paddingLeft: cellStyleProps.cellLeftPadding + "px",
selectors: (_j = {
'& > button': {
maxWidth: '100%',
}
},
_j[IsFocusableSelector] = Styling_1.getFocusStyle(theme, { inset: -
1, borderColor: neutralSecondary, outlineColor: white }),
_j),
},
isSelected && {
_k[Styling_1.HighContrastSelector] = tslib_1.__assign({ background:
'Highlight', color: 'HighlightText' }, Styling_1.getHighContrastNoAdjustStyle()),
_k),
},
compact && cellCompactStyles,
disabled && { opacity: 0.5 },
];
return {
root: [
classNames.root,
Styling_1.AnimationClassNames.fadeIn400,
droppingClassName,
theme.fonts.small,
isCheckVisible && classNames.isCheckVisible,
Styling_1.getFocusStyle(theme, { borderColor: focusBorder,
outlineColor: white }),
{
borderBottom: "1px solid " + neutralLighter,
background: colors.defaultBackground,
color: colors.defaultMetaText,
// This ensures that the row always tries to consume is minimum
width and does not compress.
minWidth: '100%',
minHeight: values.rowHeight,
padding: 0,
textAlign: 'left',
_l["." + classNames.listCellFirstChild + " &:before"] = {
display: 'none',
},
_l['&:hover'] = {
background: colors.defaultHoverBackground,
color: colors.defaultHoverMetaText,
_m["." + classNames.isRowHeader] = {
color: colors.defaultHoverHeaderText,
},
_m["." + classNames.cell + " > ." +
color: focusedLinkColor,
},
_m),
},
_l["&:hover ." + classNames.check] = {
opacity: 1,
},
_l["." + Utilities_1.IsFocusVisibleClassName + " &:focus ." +
classNames.check] = {
opacity: 1,
},
_l['.ms-GroupSpacer'] = {
flexShrink: 0,
flexGrow: 0,
},
_l),
},
isSelected && selectedStyles,
!canSelect && cannotSelectStyles,
compact && rootCompactStyles,
className,
],
cellUnpadded: {
paddingRight: cellStyleProps.cellRightPadding + "px",
},
cellPadded: {
cellStyleProps.cellRightPadding + "px",
_o["&." + classNames.cellCheck] = {
paddingRight: 0,
},
_o),
},
cell: defaultCellStyles,
cellAnimation: enableUpdateAnimations &&
Styling_1.AnimationStyles.slideLeftIn40,
cellMeasurer: [
classNames.cellMeasurer,
{
},
],
checkCell: [
defaultCellStyles,
classNames.cellCheck,
checkboxCellClassName,
{
padding: 0,
// Ensure that the check cell covers the top border of the cell.
// This ensures the click target does not leave a spot which would
// cause other items to be deselected.
paddingTop: 1,
marginTop: -1,
flexShrink: 0,
},
],
checkCover: {
top: -1,
left: 0,
bottom: 0,
right: 0,
display: anySelected ? 'block' : 'none',
},
fields: [
classNames.fields,
{
display: 'flex',
},
],
isRowHeader: [
classNames.isRowHeader,
{
color: colors.defaultHeaderText,
},
isSelected && {
color: colors.selectedHeaderText,
selectors: (_p = {},
_p[Styling_1.HighContrastSelector] = {
},
_p),
},
],
isMultiline: [
defaultCellStyles,
{
whiteSpace: 'normal',
},
],
check: [classNames.check],
};
};
exports.getDetailsRowStyles = getDetailsRowStyles;
//# sourceMappingURL=DetailsRow.styles.js.map
/***/ }),
/***/ 87438:
"use strict";

//# sourceMappingURL=DetailsRow.types.js.map
/***/ }),
/***/ 62570:
"use strict";

exports.DetailsRowCheck = void 0;
var Check_1 = __webpack_require__(19774);
var DetailsRowCheckBase = function (props) {
var _a = props.isVisible, isVisible = _a === void 0 ? false : _a, _b =
props.canSelect, canSelect = _b === void 0 ? false : _b, _c = props.anySelected,
anySelected = _c === void 0 ? false : _c, _d = props.selected, selected = _d ===
void 0 ? false : _d, selectionMode = props.selectionMode, _e = props.isHeader,
isHeader = _e === void 0 ? false : _e, className = props.className, checkClassName
= props.checkClassName, styles = props.styles, theme = props.theme, compact =
props.compact, onRenderDetailsCheckbox = props.onRenderDetailsCheckbox, _f =
props.useFastIcons, useFastIcons = _f === void 0 ? true : _f, // must be removed
from buttonProps
buttonProps = tslib_1.__rest(props, ["isVisible", "canSelect", "anySelected",
"selected", "selectionMode", "isHeader", "className", "checkClassName", "styles",
"theme", "compact", "onRenderDetailsCheckbox", "useFastIcons"]);
var defaultCheckboxRender = useFastIcons ? _fastDefaultCheckboxRender :
_defaultCheckboxRender;
var onRenderCheckbox = onRenderDetailsCheckbox
? Utilities_1.composeRenderFunction(onRenderDetailsCheckbox,
defaultCheckboxRender)
: defaultCheckboxRender;
theme: theme,
canSelect: canSelect,
selected: selected,
anySelected: anySelected,
isHeader: isHeader,
isVisible: isVisible,
compact: compact,
});
var detailsCheckboxProps = {
checked: selected,
theme: theme,
};
var divProps = Utilities_1.getNativeElementProps('div', buttonProps, ['aria-
label', 'aria-labelledby', 'aria-describedby']);
var checkRole = selectionMode === Selection_1.SelectionMode.single ? 'radio' :
'checkbox';
return canSelect ? (React.createElement("div", tslib_1.__assign({},
buttonProps, { role: checkRole,
className: Utilities_1.css(classNames.root, classNames.check), "aria-
checked": selected, "data-selection-toggle": true, "data-automationid":
"DetailsRowCheck", tabIndex: -1 }), onRenderCheckbox(detailsCheckboxProps))) : (
React.createElement("div", tslib_1.__assign({}, divProps, { className:
Utilities_1.css(classNames.root, classNames.check) })));
};
var FastCheck = React.memo(function (props) {
return React.createElement(Check_1.Check, { theme: props.theme, checked:
props.checked, className: props.className, useFastIcons: true });
});
function _defaultCheckboxRender(checkboxProps) {
return React.createElement(Check_1.Check, { checked: checkboxProps.checked });
}
function _fastDefaultCheckboxRender(checkboxProps) {
return React.createElement(FastCheck, { theme: checkboxProps.theme, checked:
checkboxProps.checked });
}
exports.DetailsRowCheck = Utilities_1.styled(DetailsRowCheckBase,
DetailsRowCheck_styles_1.getDetailsRowCheckStyles, undefined, { scope:
'DetailsRowCheck' }, true);
//# sourceMappingURL=DetailsRowCheck.js.map
/***/ }),
/***/ 32979:
"use strict";

exports.getDetailsRowCheckStyles = exports.CHECK_CELL_WIDTH = void 0;
var Check_styles_1 = __webpack_require__(98874);
root: 'ms-DetailsRow-check',
isDisabled: 'ms-DetailsRow-check--isDisabled',
isHeader: 'ms-DetailsRow-check--isHeader',
};
exports.CHECK_CELL_WIDTH = 48;
var getDetailsRowCheckStyles = function (props) {
var theme = props.theme, className = props.className, isHeader =
props.isHeader, selected = props.selected, anySelected = props.anySelected,
canSelect = props.canSelect, compact = props.compact, isVisible = props.isVisible;
var rowHeight = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.rowHeight,
compactRowHeight = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.compactRowHeight;
var height = isHeader ? DetailsHeader_styles_1.HEADER_HEIGHT : compact ?
compactRowHeight : rowHeight;
var isCheckVisible = isVisible || selected || anySelected;
return {
root: [classNames.root, className],
check: [
!canSelect && classNames.isDisabled,
isHeader && classNames.isHeader,
theme.fonts.small,
Check_styles_1.CheckGlobalClassNames.checkHost,
{
display: 'flex',
cursor: 'default',
background: 'none',
border: 'none',
opacity: isCheckVisible ? 1 : 0,
height: height,
width: exports.CHECK_CELL_WIDTH,
padding: 0,
margin: 0,
},
],
isDisabled: [],
};
};
exports.getDetailsRowCheckStyles = getDetailsRowCheckStyles;
//# sourceMappingURL=DetailsRowCheck.styles.js.map
/***/ }),
/***/ 11310:
"use strict";

//# sourceMappingURL=DetailsRowCheck.types.js.map
/***/ }),
/***/ 49364:
"use strict";

exports.DetailsRowFields = void 0;
var getCellText = function (item, column) {
var value = item && column && column.fieldName ? item[column.fieldName] : '';
if (value === null || value === undefined) {
value = '';
}
if (typeof value === 'boolean') {
return value.toString();
}
return value;
};
/**
* Component for rendering a row's cells in a `DetailsList`.
*
*/
var DetailsRowFields = function (props) {
var columns = props.columns, rowClassNames = props.rowClassNames, _a =
props.cellStyleProps, cellStyleProps = _a === void 0 ?
DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _a, item = props.item, itemIndex =
props.itemIndex, isSelected = props.isSelected, onRenderItemColumn =
props.onRenderItemColumn, getCellValueKey = props.getCellValueKey,
propsOnRenderField = props.onRenderField, cellsByColumn = props.cellsByColumn,
enableUpdateAnimations = props.enableUpdateAnimations, rowHeaderId =
props.rowHeaderId;
var cellValueKeysRef = React.useRef();
var cellValueKeys = cellValueKeysRef.current || (cellValueKeysRef.current =
{});
var defaultOnRenderField = React.useCallback(function (fieldProps) {
var column = fieldProps.column, cellValueKey = fieldProps.cellValueKey,
className = fieldProps.className, onRender = fieldProps.onRender, fieldItem =
fieldProps.item, fieldItemIndex = fieldProps.itemIndex;
var width = typeof column.calculatedWidth === 'undefined'
? 'auto'
: column.calculatedWidth +
(column.isPadded ? cellStyleProps.cellExtraRightPadding : 0);
var key = "" + column.key + (cellValueKey !== undefined ? "-" +
cellValueKey : '');
return (React.createElement("div", { key: key, id: column.isRowHeader ?
rowHeaderId : undefined, role: column.isRowHeader ? 'rowheader' : 'gridcell',
"aria-readonly": true, className: Utilities_1.css(column.className,
column.isMultiline && rowClassNames.isMultiline, column.isRowHeader &&
rowClassNames.isRowHeader, rowClassNames.cell, column.isPadded ?
rowClassNames.cellPadded : rowClassNames.cellUnpadded, className), style: { width:
width }, "data-automationid": "DetailsRowCell", "data-automation-key":
column.key }, onRender(fieldItem, fieldItemIndex, column)));
}, [rowClassNames, cellStyleProps, rowHeaderId]);
return (React.createElement("div", { className: rowClassNames.fields, "data-
automationid": "DetailsRowFields", role: "presentation" }, columns.map(function
(column) {
var _a = column.getValueKey, getValueKey = _a === void 0 ?
getCellValueKey : _a;
var onRender = (cellsByColumn && column.key in cellsByColumn && (function
() { return cellsByColumn[column.key]; })) ||
column.onRender ||
onRenderItemColumn ||
defaultOnRender;
var onRenderField = defaultOnRenderField;
if (column.onRenderField) {
onRenderField = Utilities_1.composeRenderFunction(column.onRenderField,
onRenderField);
}
if (propsOnRenderField) {
onRenderField = Utilities_1.composeRenderFunction(propsOnRenderField,
onRenderField);
}
var previousValueKey = cellValueKeys[column.key];
var cellValueKey = enableUpdateAnimations && getValueKey ?
getValueKey(item, itemIndex, column) : undefined;
var showAnimation = false;
if (cellValueKey !== undefined && previousValueKey !== undefined &&
cellValueKey !== previousValueKey) {
showAnimation = true;
}
cellValueKeys[column.key] = cellValueKey;
return onRenderField({
item: item,
itemIndex: itemIndex,
column: column,
cellValueKey: cellValueKey,
className: showAnimation ? rowClassNames.cellAnimation : undefined,
onRender: onRender,
});
})));
};
exports.DetailsRowFields = DetailsRowFields;
function defaultOnRender(item, index, column) {
if (!item || !column) {
return null;
}
return getCellText(item, column);
}
//# sourceMappingURL=DetailsRowFields.js.map
/***/ }),
/***/ 65090:
"use strict";

//# sourceMappingURL=DetailsRowFields.types.js.map
/***/ }),
/***/ 36390:
"use strict";

exports.ShimmeredDetailsListBase = void 0;
var DetailsList_1 = __webpack_require__(23923);
var Shimmer_1 = __webpack_require__(50759);
var SHIMMER_INITIAL_ITEMS = 10;
var DEFAULT_SHIMMER_HEIGHT = 7;
var SHIMMER_LINE_VS_CELL_WIDTH_RATIO = 0.95;
var ShimmeredDetailsListBase = /** @class */ (function (_super) {
tslib_1.__extends(ShimmeredDetailsListBase, _super);
function ShimmeredDetailsListBase(props) {
_this._onRenderShimmerPlaceholder = function (index, rowProps) {
var onRenderCustomPlaceholder = _this.props.onRenderCustomPlaceholder;
var placeholderElements = onRenderCustomPlaceholder
? onRenderCustomPlaceholder(rowProps, index,
_this._renderDefaultShimmerPlaceholder)
: _this._renderDefaultShimmerPlaceholder(rowProps);
return React.createElement(Shimmer_1.Shimmer, { customElementsGroup:
placeholderElements });
};
_this._renderDefaultShimmerPlaceholder = function (rowProps) {
var columns = rowProps.columns, compact = rowProps.compact,
selectionMode = rowProps.selectionMode, checkboxVisibility =
rowProps.checkboxVisibility, _a = rowProps.cellStyleProps, cellStyleProps = _a ===
void 0 ? DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS : _a;
var rowHeight = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.rowHeight,
compactRowHeight = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.compactRowHeight;
// 1px to take into account the border-bottom of DetailsRow.
var gapHeight = compact ? compactRowHeight : rowHeight + 1;
var shimmerElementsRow = [];
var showCheckbox = selectionMode !== Selection_1.SelectionMode.none &&
checkboxVisibility !== DetailsList_types_1.CheckboxVisibility.hidden;
if (showCheckbox) {
shimmerElementsRow.push(React.createElement(Shimmer_1.ShimmerElementsGroup, { key:
'checkboxGap', shimmerElements: [{ type: Shimmer_1.ShimmerElementType.gap, width:
'40px', height: gapHeight }] }));
}
columns.forEach(function (column, columnIdx) {
var shimmerElements = [];
var groupWidth = cellStyleProps.cellLeftPadding +
column.calculatedWidth +
(column.isPadded ? cellStyleProps.cellExtraRightPadding : 0);
shimmerElements.push({
type: Shimmer_1.ShimmerElementType.gap,
width: cellStyleProps.cellLeftPadding,
height: gapHeight,
});
if (column.isIconOnly) {
type: Shimmer_1.ShimmerElementType.line,
width: column.calculatedWidth,
height: column.calculatedWidth,
});
width: cellStyleProps.cellRightPadding,
height: gapHeight,
});
}
else {
type: Shimmer_1.ShimmerElementType.line,
width: column.calculatedWidth *
SHIMMER_LINE_VS_CELL_WIDTH_RATIO,
height: DEFAULT_SHIMMER_HEIGHT,
});
width: cellStyleProps.cellRightPadding +
(column.calculatedWidth - column.calculatedWidth *
SHIMMER_LINE_VS_CELL_WIDTH_RATIO) +
(column.isPadded ? cellStyleProps.cellExtraRightPadding
: 0),
height: gapHeight,
});
}
columnIdx, width: groupWidth + "px", shimmerElements: shimmerElements }));
});
// When resizing the window from narrow to wider, we need to cover the
exposed Shimmer wave
// until the column resizing logic is done.
'endGap', width: '100%', shimmerElements: [{ type:
Shimmer_1.ShimmerElementType.gap, width: '100%', height: gapHeight }] }));
return React.createElement("div", { style: { display: 'flex' } },
shimmerElementsRow);
};
_this._shimmerItems = props.shimmerLines ? new Array(props.shimmerLines) :
new Array(SHIMMER_INITIAL_ITEMS);
return _this;
}
ShimmeredDetailsListBase.prototype.render = function () {
var _a = this.props, detailsListStyles = _a.detailsListStyles,
enableShimmer = _a.enableShimmer, items = _a.items, listProps = _a.listProps,
onRenderCustomPlaceholder = _a.onRenderCustomPlaceholder, removeFadingOverlay =
_a.removeFadingOverlay, shimmerLines = _a.shimmerLines, styles = _a.styles, theme =
_a.theme, ariaLabelForGrid = _a.ariaLabelForGrid, ariaLabelForShimmer =
_a.ariaLabelForShimmer, restProps = tslib_1.__rest(_a, ["detailsListStyles",
"enableShimmer", "items", "listProps", "onRenderCustomPlaceholder",
"removeFadingOverlay", "shimmerLines", "styles", "theme", "ariaLabelForGrid",
"ariaLabelForShimmer"]);
var listClassName = listProps && listProps.className;
theme: theme,
});
var newListProps = tslib_1.__assign(tslib_1.__assign({}, listProps), {
// Adds to the optional listProp className a fading out overlay
className only when ènableShimmer` toggled on
// and the overlay is not disabled by `removeFadingOverlay` prop.
className: enableShimmer && !removeFadingOverlay ?
Utilities_1.css(this._classNames.root, listClassName) : listClassName });
return (React.createElement(DetailsList_1.DetailsList, tslib_1.__assign({},
restProps, { styles: detailsListStyles, items: enableShimmer ? this._shimmerItems :
items, isPlaceholderData: enableShimmer, ariaLabelForGrid: (enableShimmer &&
ariaLabelForShimmer) || ariaLabelForGrid, onRenderMissingItem:
this._onRenderShimmerPlaceholder, listProps: newListProps })));
};
return ShimmeredDetailsListBase;
exports.ShimmeredDetailsListBase = ShimmeredDetailsListBase;
//# sourceMappingURL=ShimmeredDetailsList.base.js.map
/***/ }),
/***/ 75561:
"use strict";

exports.ShimmeredDetailsList = void 0;
var ShimmeredDetailsList_base_1 = __webpack_require__(36390);
var ShimmeredDetailsList_styles_1 = __webpack_require__(63677);
exports.ShimmeredDetailsList =
Utilities_1.styled(ShimmeredDetailsList_base_1.ShimmeredDetailsListBase,
ShimmeredDetailsList_styles_1.getShimmeredDetailsListStyles, undefined, { scope:
'ShimmeredDetailsList' });
//# sourceMappingURL=ShimmeredDetailsList.js.map
/***/ }),
/***/ 63677:
"use strict";

exports.getShimmeredDetailsListStyles = void 0;
var getShimmeredDetailsListStyles = function (props) {
return {
root: {
selectors: {
':after': {
content: '""',
top: 0,
right: 0,
bottom: 0,
left: 0,
// eslint-disable-next-line @fluentui/max-len
backgroundImage: "linear-gradient(to bottom, transparent 30%, "
+ palette.whiteTranslucent40 + " 65%," + palette.white + " 100%)",
},
},
},
};
};
exports.getShimmeredDetailsListStyles = getShimmeredDetailsListStyles;
//# sourceMappingURL=ShimmeredDetailsList.styles.js.map
/***/ }),
/***/ 37687:
"use strict";

//# sourceMappingURL=ShimmeredDetailsList.types.js.map
/***/ }),
/***/ 44625:
"use strict";

// ShimmeredDetailsList is not exported here as it is exported from
../ShimmeredDetailsList.ts
/***/ }),
/***/ 22395:
"use strict";

exports.DialogBase = void 0;
var DialogContent_types_1 = __webpack_require__(5837);
var Modal_1 = __webpack_require__(14086);
var DialogContent_1 = __webpack_require__(34581);
var DefaultModalProps = {
isDarkOverlay: false,
isBlocking: false,
className: '',
containerClassName: '',
topOffsetFixed: false,
enableAriaHiddenSiblings: true,
};
var DefaultDialogContentProps = {
type: DialogContent_types_1.DialogType.normal,
className: '',
topButtonsProps: [],
};
var DialogBase = /** @class */ (function (_super) {
tslib_1.__extends(DialogBase, _super);
function DialogBase(props) {
_this._getSubTextId = function () {
var _a = _this.props, ariaDescribedById = _a.ariaDescribedById,
modalProps = _a.modalProps, dialogContentProps = _a.dialogContentProps, subText =
_a.subText;
var id = (modalProps && modalProps.subtitleAriaId) ||
ariaDescribedById;
if (!id) {
id = ((dialogContentProps && dialogContentProps.subText) ||
subText) && _this._defaultSubTextId;
}
return id;
};
_this._getTitleTextId = function () {
var _a = _this.props, ariaLabelledById = _a.ariaLabelledById,
modalProps = _a.modalProps, dialogContentProps = _a.dialogContentProps, title =
_a.title;
var id = (modalProps && modalProps.titleAriaId) || ariaLabelledById;
if (!id) {
id = ((dialogContentProps && dialogContentProps.title) || title) &&
_this._defaultTitleTextId;
}
return id;
};
_this._id = Utilities_1.getId('Dialog');
_this._defaultTitleTextId = _this._id + '-title';
_this._defaultSubTextId = _this._id + '-subText';
if (false) {}
return _this;
}
DialogBase.prototype.render = function () {
var _a, _b, _c;
var
className = props.className, containerClassName = props.containerClassName,
contentClassName = props.contentClassName, elementToFocusOnDismiss =
props.elementToFocusOnDismiss, firstFocusableSelector =
props.firstFocusableSelector, forceFocusInsideTrap = props.forceFocusInsideTrap,
styles = props.styles, hidden = props.hidden, _d = props.disableRestoreFocus,
disableRestoreFocus = _d === void 0 ? props.ignoreExternalFocusing : _d, isBlocking
= props.isBlocking, isClickableOutsideFocusTrap =
props.isClickableOutsideFocusTrap, isDarkOverlay = props.isDarkOverlay, _e =
props.isOpen, isOpen = _e === void 0 ? !hidden : _e, onDismiss = props.onDismiss,
onDismissed = props.onDismissed, onLayerDidMount = props.onLayerDidMount,
responsiveMode = props.responsiveMode, subText = props.subText, theme =
props.theme, title = props.title, topButtonsProps = props.topButtonsProps, type =
props.type,
minWidth = props.minWidth, maxWidth = props.maxWidth, modalProps =
props.modalProps;
var mergedLayerProps = tslib_1.__assign({ onLayerDidMount:
onLayerDidMount }, modalProps === null || modalProps === void 0 ? void 0 :
modalProps.layerProps);
var dialogDraggableClassName;
var dragOptions;
// If dragOptions are provided, but no drag handle is specified, we supply
a drag handle,
// and inform dialog contents to add class to draggable class to the header
if ((modalProps === null || modalProps === void 0 ? void 0 :
modalProps.dragOptions) && !((_a = modalProps.dragOptions) === null || _a === void
0 ? void 0 : _a.dragHandleSelector)) {
// spread options to avoid mutating props
dragOptions = tslib_1.__assign({}, modalProps.dragOptions);
dialogDraggableClassName = 'ms-Dialog-draggable-header';
dragOptions.dragHandleSelector = "." + dialogDraggableClassName;
}
var mergedModalProps =
tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({},
DefaultModalProps), { elementToFocusOnDismiss: elementToFocusOnDismiss,
firstFocusableSelector: firstFocusableSelector, forceFocusInsideTrap:
forceFocusInsideTrap, disableRestoreFocus: disableRestoreFocus,
isClickableOutsideFocusTrap: isClickableOutsideFocusTrap, responsiveMode:
responsiveMode, className: className, containerClassName: containerClassName,
isBlocking: isBlocking, isDarkOverlay: isDarkOverlay, onDismissed: onDismissed }),
modalProps), { dragOptions: dragOptions, layerProps: mergedLayerProps, isOpen:
isOpen });
var dialogContentProps =
tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ className: contentClassName,
subText: subText, title: title, topButtonsProps: topButtonsProps, type: type },
DefaultDialogContentProps), props.dialogContentProps), { draggableHeaderClassName:
dialogDraggableClassName, titleProps: tslib_1.__assign({
id: ((_b = props.dialogContentProps) === null || _b === void 0 ?
void 0 : _b.titleId) || this._defaultTitleTextId }, (_c = props.dialogContentProps)
=== null || _c === void 0 ? void 0 : _c.titleProps) });
theme: theme,
className: mergedModalProps.className,
containerClassName: mergedModalProps.containerClassName,
hidden: hidden,
dialogDefaultMinWidth: minWidth,
dialogDefaultMaxWidth: maxWidth,
});
return (React.createElement(Modal_1.Modal, tslib_1.__assign({},
mergedModalProps, { className: classNames.root, containerClassName:
classNames.main, onDismiss: onDismiss || mergedModalProps.onDismiss,
subtitleAriaId: this._getSubTextId(), titleAriaId: this._getTitleTextId() }),
React.createElement(DialogContent_1.DialogContent,
tslib_1.__assign({ subTextId: this._defaultSubTextId, showCloseButton:
mergedModalProps.isBlocking, onDismiss: onDismiss }, dialogContentProps),
props.children)));
};
DialogBase.defaultProps = {
hidden: true,
};
DialogBase = tslib_1.__decorate([
ResponsiveMode_1.withResponsiveMode
], DialogBase);
return DialogBase;
exports.DialogBase = DialogBase;
//# sourceMappingURL=Dialog.base.js.map
/***/ }),
/***/ 51354:
"use strict";
exports.Dialog = void 0;
var Dialog_base_1 = __webpack_require__(22395);
var Dialog_styles_1 = __webpack_require__(40113);
exports.Dialog = Utilities_1.styled(Dialog_base_1.DialogBase,
Dialog_styles_1.getStyles, undefined, { scope: 'Dialog' });
exports.Dialog.displayName = 'Dialog';
//# sourceMappingURL=Dialog.js.map
/***/ }),
/***/ 40113:
"use strict";

root: 'ms-Dialog',
};
var _a;
var className = props.className, containerClassName = props.containerClassName,
// eslint-disable-line deprecation/deprecation
_b = props.dialogDefaultMinWidth, // eslint-disable-line
dialogDefaultMinWidth = _b === void 0 ? '288px' : _b, _c =
props.dialogDefaultMaxWidth, dialogDefaultMaxWidth = _c === void 0 ? '340px' : _c,
hidden = props.hidden, theme = props.theme;
return {
root: [classNames.root, theme.fonts.medium, className],
main: [
{
width: dialogDefaultMinWidth,
_a["@media (min-width: " + Styling_1.ScreenWidthMinMedium +
"px)"] = {
width: 'auto',
maxWidth: dialogDefaultMaxWidth,
minWidth: dialogDefaultMinWidth,
},
_a),
},
!hidden && { display: 'flex' },
containerClassName,
],
};
};
//# sourceMappingURL=Dialog.styles.js.map
/***/ }),
/***/ 66184:
"use strict";

//# sourceMappingURL=Dialog.types.js.map
/***/ }),
/***/ 91802:
"use strict";

exports.DialogContentBase = void 0;
var DialogContent_types_1 = __webpack_require__(5837);
var DialogFooter_1 = __webpack_require__(58208);
var DialogFooterType = (React.createElement(DialogFooter_1.DialogFooter,
null)).type;
var COMPONENT_NAME = 'DialogContent';
var DialogContentBase = /** @class */ (function (_super) {
tslib_1.__extends(DialogContentBase, _super);
function DialogContentBase(props) {
titleId: 'titleProps.id',
});
return _this;
}
DialogContentBase.prototype.render = function () {
var _a = this.props, showCloseButton = _a.showCloseButton, className =
_a.className, closeButtonAriaLabel = _a.closeButtonAriaLabel, onDismiss =
_a.onDismiss, subTextId = _a.subTextId, subText = _a.subText, _b = _a.titleProps,
titleProps = _b === void 0 ? {} : _b,
titleId = _a.titleId, title = _a.title, type = _a.type, styles = _a.styles,
theme = _a.theme, draggableHeaderClassName = _a.draggableHeaderClassName;
theme: theme,
isLargeHeader: type === DialogContent_types_1.DialogType.largeHeader,
isClose: type === DialogContent_types_1.DialogType.close,
draggableHeaderClassName: draggableHeaderClassName,
});
var groupings = this._groupChildren();
var subTextContent;
if (subText) {
subTextContent = (React.createElement("p", { className:
classNames.subText, id: subTextId }, subText));
}
return (React.createElement("div", { className: classNames.content },
React.createElement("div", { className: classNames.header },
React.createElement("div", tslib_1.__assign({ id: titleId, role:
"heading", "aria-level": 1 }, titleProps, { className:
Utilities_1.css(classNames.title, titleProps.className) }), title),
React.createElement("div", { className: classNames.topButton },
this.props.topButtonsProps.map(function (props, index) { return
(React.createElement(Button_1.IconButton, tslib_1.__assign({ key: props.uniqueId ||
index }, props))); }),
(type === DialogContent_types_1.DialogType.close ||
(showCloseButton && type !== DialogContent_types_1.DialogType.largeHeader)) &&
(React.createElement(Button_1.IconButton, { className: classNames.button,
iconProps: { iconName: 'Cancel' }, ariaLabel: closeButtonAriaLabel, onClick:
onDismiss })))),
React.createElement("div", { className: classNames.inner },
React.createElement("div", { className: classNames.innerContent },
subTextContent,
groupings.contents),
groupings.footers)));
};
// @TODO - typing the footers as an array of DialogFooter is difficult because
// casing "child as DialogFooter" causes a problem because
// "Neither type 'ReactElement<any>' nor type 'DialogFooter' is assignable to
the other."
DialogContentBase.prototype._groupChildren = function () {
var groupings = {
footers: [],
contents: [],
};
React.Children.map(this.props.children, function (child) {
if (typeof child === 'object' && child !== null && child.type ===
DialogFooterType) {
groupings.footers.push(child);
}
else {
groupings.contents.push(child);
}
});
return groupings;
};
DialogContentBase.defaultProps = {
className: '',
topButtonsProps: [],
closeButtonAriaLabel: 'Close',
};
DialogContentBase = tslib_1.__decorate([
ResponsiveMode_1.withResponsiveMode
], DialogContentBase);
return DialogContentBase;
exports.DialogContentBase = DialogContentBase;
//# sourceMappingURL=DialogContent.base.js.map
/***/ }),
/***/ 34581:
"use strict";

exports.DialogContent = void 0;
var DialogContent_base_1 = __webpack_require__(91802);
var DialogContent_styles_1 = __webpack_require__(37378);
exports.DialogContent = Utilities_1.styled(DialogContent_base_1.DialogContentBase,
DialogContent_styles_1.getStyles, undefined, { scope: 'DialogContent' });
//# sourceMappingURL=DialogContent.js.map
/***/ }),
/***/ 37378:
"use strict";

contentLgHeader: 'ms-Dialog-lgHeader',
close: 'ms-Dialog--close',
subText: 'ms-Dialog-subText',
header: 'ms-Dialog-header',
headerLg: 'ms-Dialog--lgHeader',
button: 'ms-Dialog-button ms-Dialog-button--close',
inner: 'ms-Dialog-inner',
content: 'ms-Dialog-content',
title: 'ms-Dialog-title',
};
var _a, _b, _c;
var className = props.className, theme = props.theme, isLargeHeader =
props.isLargeHeader, isClose = props.isClose, hidden = props.hidden, isMultiline =
props.isMultiline, draggableHeaderClassName = props.draggableHeaderClassName;
var palette = theme.palette, fonts = theme.fonts, effects = theme.effects,
semanticColors = theme.semanticColors;
return {
content: [
isLargeHeader && [
classNames.contentLgHeader,
{
borderTop: "4px solid " + palette.themePrimary,
},
],
isClose && classNames.close,
{
flexGrow: 1,
overflowY: 'hidden', // required for allowScrollOnElement
},
className,
],
subText: [
classNames.subText,
fonts.medium,
{
margin: '0 0 24px 0',
lineHeight: '1.5',
fontWeight: Styling_1.FontWeights.regular,
},
],
header: [
classNames.header,
{
width: '100%',
},
isClose && classNames.close,
draggableHeaderClassName && [
draggableHeaderClassName,
{
cursor: 'move',
},
],
],
button: [
classNames.button,
hidden && {
selectors: {
'.ms-Icon.ms-Icon--Cancel': {
color: semanticColors.buttonText,
},
},
},
],
inner: [
classNames.inner,
{
padding: '0 24px 24px',
_a["@media (min-width: " + Styling_1.ScreenWidthMinSmall + "px)
and (max-width: " + Styling_1.ScreenWidthMaxSmall + "px)"] = {
padding: '0 16px 16px',
},
_a),
},
],
innerContent: [
classNames.content,
{
width: '100%',
},
],
title: [
classNames.title,
fonts.xLarge,
{
margin: '0',
minHeight: fonts.xLarge.fontSize,
padding: '16px 46px 20px 24px',
lineHeight: 'normal',
_b["@media (min-width: " + Styling_1.ScreenWidthMinSmall + "px)
},
_b),
},
isLargeHeader && {
color: semanticColors.menuHeader,
},
isMultiline && { fontSize: fonts.xxLarge.fontSize },
],
topButton: [
{
display: 'flex',
flexWrap: 'nowrap',
top: '0',
right: '0',
padding: '15px 15px 0 0',
selectors: (_c = {
'> *': {
flex: '0 0 auto',
},
'.ms-Dialog-button': {
},
'.ms-Dialog-button:hover': {
color: semanticColors.buttonTextHovered,
}
},
_c["@media (min-width: " + Styling_1.ScreenWidthMinSmall + "px)
padding: '15px 8px 0 0',
},
_c),
},
],
};
};
//# sourceMappingURL=DialogContent.styles.js.map
/***/ }),
/***/ 5837:
"use strict";

exports.DialogType = void 0;
/**
* {@docCategory Dialog}
*/
var DialogType;
(function (DialogType) {
/** Standard dialog */
DialogType[DialogType["normal"] = 0] = "normal";
/** Dialog with large header banner */
DialogType[DialogType["largeHeader"] = 1] = "largeHeader";
/** Dialog with an 'x' close button in the upper-right corner */
DialogType[DialogType["close"] = 2] = "close";
})(DialogType = exports.DialogType || (exports.DialogType = {}));
//# sourceMappingURL=DialogContent.types.js.map
/***/ }),
/***/ 18859:
"use strict";

exports.DialogFooterBase = void 0;
var DialogFooterBase = /** @class */ (function (_super) {
tslib_1.__extends(DialogFooterBase, _super);
function DialogFooterBase(props) {
return _this;
}
DialogFooterBase.prototype.render = function () {
var _a = this.props, className = _a.className, styles = _a.styles, theme =
_a.theme;
theme: theme,
});
return (React.createElement("div", { className: this._classNames.actions },
this._classNames.actionsRight }, this._renderChildrenAsActions())));
};
DialogFooterBase.prototype._renderChildrenAsActions = function () {
var _this = this;
return React.Children.map(this.props.children, function (child) {
return child ? React.createElement("span", { className:
_this._classNames.action }, child) : null;
});
};
return DialogFooterBase;
exports.DialogFooterBase = DialogFooterBase;
//# sourceMappingURL=DialogFooter.base.js.map
/***/ }),
/***/ 58208:
"use strict";

exports.DialogFooter = void 0;
var DialogFooter_base_1 = __webpack_require__(18859);
var DialogFooter_styles_1 = __webpack_require__(1018);
exports.DialogFooter = Utilities_1.styled(DialogFooter_base_1.DialogFooterBase,
DialogFooter_styles_1.getStyles, undefined, { scope: 'DialogFooter' });
//# sourceMappingURL=DialogFooter.js.map
/***/ }),
/***/ 1018:
"use strict";

actions: 'ms-Dialog-actions',
action: 'ms-Dialog-action',
actionsRight: 'ms-Dialog-actionsRight',
};
return {
actions: [
classNames.actions,
{
width: '100%',
minHeight: '24px',
lineHeight: '24px',
margin: '16px 0 0',
fontSize: '0',
selectors: {
'.ms-Button': {
},
},
},
className,
],
action: [
classNames.action,
{
margin: '0 4px',
},
],
actionsRight: [
classNames.actionsRight,
{
textAlign: 'right',
marginRight: '-4px',
fontSize: '0',
},
],
};
};
//# sourceMappingURL=DialogFooter.styles.js.map
/***/ }),
/***/ 30559:
"use strict";

//# sourceMappingURL=DialogFooter.types.js.map
/***/ }),
/***/ 93315:
"use strict";

/***/ }),
/***/ 19619:
"use strict";

exports.VerticalDividerBase = void 0;
exports.VerticalDividerBase = React.forwardRef(function (props, ref) {
var styles = props.styles, theme = props.theme, deprecatedGetClassNames =
props.getClassNames, className = props.className;
var classNames = getClassNames(styles, { theme: theme, getClassNames:
deprecatedGetClassNames, className: className });
return (React.createElement("span", { className: classNames.wrapper, ref:
ref },
React.createElement("span", { className: classNames.divider })));
});
exports.VerticalDividerBase.displayName = 'VerticalDividerBase';
//# sourceMappingURL=VerticalDivider.base.js.map
/***/ }),
/***/ 1342:
"use strict";

exports.getDividerClassNames = void 0;
/**
* @deprecated use getStyles exported from VerticalDivider.styles.ts
*/
exports.getDividerClassNames = Utilities_1.memoizeFunction(
function (theme) {
wrapper: {
height: '100%',
},
divider: {
width: 1,
height: '100%',
},
});
});
//# sourceMappingURL=VerticalDivider.classNames.js.map
/***/ }),
/***/ 61826:
"use strict";

exports.VerticalDivider = void 0;
var VerticalDivider_styles_1 = __webpack_require__(2961);
var VerticalDivider_base_1 = __webpack_require__(19619);
exports.VerticalDivider =
Utilities_1.styled(VerticalDivider_base_1.VerticalDividerBase,
VerticalDivider_styles_1.getStyles, undefined, {
scope: 'VerticalDivider',
});
//# sourceMappingURL=VerticalDivider.js.map
/***/ }),
/***/ 2961:
"use strict";

var theme = props.theme, getClassNames = props.getClassNames, className =
props.className;
if (!theme) {
throw new Error('Theme is undefined or null.');
}
if (getClassNames) {
var names = getClassNames(theme);
return {
wrapper: [names.wrapper],
divider: [names.divider],
};
}
return {
wrapper: [
{
height: '100%',
},
className,
],
divider: [
{
width: 1,
height: '100%',
},
],
};
};
//# sourceMappingURL=VerticalDivider.styles.js.map
/***/ }),
/***/ 10702:
"use strict";

//# sourceMappingURL=VerticalDivider.types.js.map
/***/ }),
/***/ 56273:
"use strict";

/***/ }),
/***/ 50613:
"use strict";

exports.DocumentCardBase = exports.DocumentCardContext = void 0;
var DocumentCard_types_1 = __webpack_require__(50856);
var COMPONENT_NAME = 'DocumentCard';
exports.DocumentCardContext = React.createContext({});
/**
* {@docCategory DocumentCard}
*/
var DocumentCardBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardBase, _super);
function DocumentCardBase(props) {
_this._rootElement = React.createRef();
_this._onAction(ev);
};
_this._onAction(ev);
}
};
_this._onAction = function (ev) {
var _a = _this.props, onClick = _a.onClick, onClickHref =
_a.onClickHref, onClickTarget = _a.onClickTarget;
if (onClick) {
onClick(ev);
}
else if (!onClick && onClickHref) {
// If no onClick Function was provided and we do have an
onClickHref, redirect to the onClickHref
if (onClickTarget) {
window.open(onClickHref, onClickTarget, 'noreferrer noopener
nofollow');
}
else {
window.location.href = onClickHref;
}
}
};
accentColor: undefined,
});
return _this;
}
DocumentCardBase.prototype.render = function () {
var _a = this.props, onClick = _a.onClick, onClickHref = _a.onClickHref,
children = _a.children, type = _a.type, accentColor = _a.accentColor, styles =
_a.styles, theme = _a.theme, className = _a.className;
Utilities_1.divProperties, [
'className',
'onClick',
'type',
'role',
]);
var actionable = onClick || onClickHref ? true : false;
theme: theme,
actionable: actionable,
compact: type === DocumentCard_types_1.DocumentCardType.compact ?
true : false,
});
// Override the border color if an accent color was provided (compact card
only)
var style;
if (type === DocumentCard_types_1.DocumentCardType.compact && accentColor)
{
style = {
borderBottomColor: accentColor,
};
}
// if this element is actionable it should have an aria role
var role = this.props.role || (actionable ? (onClick ? 'button' : 'link') :
undefined);
var tabIndex = actionable ? 0 : undefined;
var documentCardContextValue = { role: role, tabIndex: tabIndex };
return (React.createElement("div", tslib_1.__assign({ ref:
this._rootElement, role: 'group', className: this._classNames.root, onKeyDown:
actionable ? this._onKeyDown : undefined, onClick: actionable ? this._onClick :
undefined, style: style }, nativeProps),
React.createElement(exports.DocumentCardContext.Provider, { value:
documentCardContextValue }, children)));
};
DocumentCardBase.prototype.focus = function () {
this._rootElement.current.focus();
}
};
DocumentCardBase.defaultProps = {
type: DocumentCard_types_1.DocumentCardType.normal,
};
return DocumentCardBase;
exports.DocumentCardBase = DocumentCardBase;
//# sourceMappingURL=DocumentCard.base.js.map
/***/ }),
/***/ 13387:
"use strict";

exports.DocumentCard = void 0;
var DocumentCard_base_1 = __webpack_require__(50613);
var DocumentCard_styles_1 = __webpack_require__(50181);
exports.DocumentCard = Utilities_1.styled(DocumentCard_base_1.DocumentCardBase,
DocumentCard_styles_1.getStyles, undefined, { scope: 'DocumentCard' });
//# sourceMappingURL=DocumentCard.js.map
/***/ }),
/***/ 50181:
"use strict";

var DocumentCardPreview_styles_1 = __webpack_require__(85074);
var DocumentCardActivity_styles_1 = __webpack_require__(63353);
var DocumentCardTitle_styles_1 = __webpack_require__(56392);
var DocumentCardLocation_styles_1 = __webpack_require__(2950);
root: 'ms-DocumentCard',
rootActionable: 'ms-DocumentCard--actionable',
rootCompact: 'ms-DocumentCard--compact',
};
var _a, _b;
var className = props.className, theme = props.theme, actionable =
props.actionable, compact = props.compact;
var palette = theme.palette, fonts = theme.fonts, effects = theme.effects;
return {
root: [
classNames.root,
{
border: "1px solid " + palette.neutralLight,
maxWidth: '320px',
minWidth: '206px',
userSelect: 'none',
selectors: (_a = {
':focus': {
outline: '0px solid',
}
},
Styling_1.getInputFocusStyle(palette.neutralSecondary, effects.roundedCorner2),
_a["." +
DocumentCardLocation_styles_1.DocumentCardLocationGlobalClassNames.root + " + ." +
DocumentCardTitle_styles_1.DocumentCardTitleGlobalClassNames.root] = {
paddingTop: '4px',
},
_a),
},
actionable && [
classNames.rootActionable,
{
selectors: {
':hover': {
cursor: 'pointer',
borderColor: palette.neutralTertiaryAlt,
},
':hover:after': {
content: '" "',
top: 0,
right: 0,
bottom: 0,
left: 0,
border: "1px solid " + palette.neutralTertiaryAlt,
},
},
},
],
compact && [
classNames.rootCompact,
{
display: 'flex',
maxWidth: '480px',
height: '108px',
_b["." +
DocumentCardPreview_styles_1.DocumentCardPreviewGlobalClassNames.root] = {
borderRight: "1px solid " + palette.neutralLight,
borderBottom: 0,
maxHeight: '106px',
maxWidth: '144px',
},
_b["." +
DocumentCardPreview_styles_1.DocumentCardPreviewGlobalClassNames.icon] = {
maxHeight: '32px',
maxWidth: '32px',
},
_b["." +
DocumentCardActivity_styles_1.DocumentCardActivityGlobalClassNames.root] = {
},
_b["." +
DocumentCardTitle_styles_1.DocumentCardTitleGlobalClassNames.root] = {
paddingBottom: '12px 16px 8px 16px',
lineHeight: '16px',
},
_b),
},
],
className,
],
};
};
//# sourceMappingURL=DocumentCard.styles.js.map
/***/ }),
/***/ 50856:
"use strict";

exports.DocumentCardType = void 0;
/**
*/
var DocumentCardType;
(function (DocumentCardType) {
/**
* Standard DocumentCard.
*/
DocumentCardType[DocumentCardType["normal"] = 0] = "normal";
/**
* Compact layout. Displays the preview beside the details, rather than above.
*/
DocumentCardType[DocumentCardType["compact"] = 1] = "compact";
})(DocumentCardType = exports.DocumentCardType || (exports.DocumentCardType = {}));
//# sourceMappingURL=DocumentCard.types.js.map
/***/ }),
/***/ 48850:
"use strict";

exports.DocumentCardActionsBase = void 0;
/**
*/
var DocumentCardActionsBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardActionsBase, _super);
function DocumentCardActionsBase(props) {
return _this;
}
DocumentCardActionsBase.prototype.render = function () {
var _this = this;
var _a = this.props, actions = _a.actions, views = _a.views, styles =
theme: theme,
});
return (React.createElement("div", { className: this._classNames.root },
actions &&
actions.map(function (action, index) {
_this._classNames.action, key: index },
tslib_1.__assign({}, action))));
}),
views > 0 && (React.createElement("div", { className:
this._classNames.views },
React.createElement(Icon_1.Icon, { iconName: "View", className:
this._classNames.viewsIcon }),
views))));
};
return DocumentCardActionsBase;
exports.DocumentCardActionsBase = DocumentCardActionsBase;
//# sourceMappingURL=DocumentCardActions.base.js.map
/***/ }),
/***/ 5612:
"use strict";

exports.DocumentCardActions = void 0;
var DocumentCardActions_base_1 = __webpack_require__(48850);
var DocumentCardActions_styles_1 = __webpack_require__(96253);
exports.DocumentCardActions =
Utilities_1.styled(DocumentCardActions_base_1.DocumentCardActionsBase,
DocumentCardActions_styles_1.getStyles, undefined, { scope:
'DocumentCardActions' });
//# sourceMappingURL=DocumentCardActions.js.map
/***/ }),
/***/ 96253:
"use strict";

var ACTION_SIZE = 34;
var HORIZONTAL_PADDING = 12;
var VERTICAL_PADDING = 4;
root: 'ms-DocumentCardActions',
action: 'ms-DocumentCardActions-action',
views: 'ms-DocumentCardActions-views',
};
return {
root: [
classNames.root,
{
height: ACTION_SIZE + "px",
padding: VERTICAL_PADDING + "px " + HORIZONTAL_PADDING + "px",
},
className,
],
action: [
classNames.action,
{
float: 'left',
marginRight: '4px',
cursor: 'pointer',
selectors: {
'.ms-Button': {
height: ACTION_SIZE,
width: ACTION_SIZE,
},
'.ms-Button:hover .ms-Button-icon': {
color: theme.semanticColors.buttonText,
cursor: 'pointer',
},
},
},
],
views: [
classNames.views,
{
textAlign: 'right',
lineHeight: ACTION_SIZE,
},
],
viewsIcon: {
marginRight: '8px',
},
};
};
//# sourceMappingURL=DocumentCardActions.styles.js.map
/***/ }),
/***/ 26909:
"use strict";

//# sourceMappingURL=DocumentCardActions.types.js.map
/***/ }),
/***/ 45668:
"use strict";

exports.DocumentCardActivityBase = void 0;
var PersonaCoin_1 = __webpack_require__(9609);
/**
*/
var DocumentCardActivityBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardActivityBase, _super);
function DocumentCardActivityBase(props) {
return _this;
}
DocumentCardActivityBase.prototype.render = function () {
var _a = this.props, activity = _a.activity, people = _a.people, styles =
theme: theme,
multiplePeople: people.length > 1,
});
if (!people || people.length === 0) {
return null;
}
this._renderAvatars(people),
React.createElement("div", { className: this._classNames.details },
React.createElement("span", { className: this._classNames.name },
this._getNameString(people)),
this._classNames.activity }, activity))));
};
DocumentCardActivityBase.prototype._renderAvatars = function (people) {
return (React.createElement("div", { className: this._classNames.avatars },
people.length > 1 ? this._renderAvatar(people[1]) : null,
this._renderAvatar(people[0])));
};
DocumentCardActivityBase.prototype._renderAvatar = function (person) {
return (React.createElement("div", { className: this._classNames.avatar },
React.createElement(PersonaCoin_1.PersonaCoin, { imageInitials:
person.initials, text: person.name, imageUrl: person.profileImageSrc,
initialsColor: person.initialsColor, allowPhoneInitials: person.allowPhoneInitials,
role: "presentation", size: Persona_1.PersonaSize.size32 })));
};
DocumentCardActivityBase.prototype._getNameString = function (people) {
var nameString = people[0].name;
if (people.length >= 2) {
nameString += ' +' + (people.length - 1);
}
return nameString;
};
return DocumentCardActivityBase;
exports.DocumentCardActivityBase = DocumentCardActivityBase;
//# sourceMappingURL=DocumentCardActivity.base.js.map
/***/ }),
/***/ 89726:
"use strict";

exports.DocumentCardActivity = void 0;
var DocumentCardActivity_base_1 = __webpack_require__(45668);
var DocumentCardActivity_styles_1 = __webpack_require__(63353);
exports.DocumentCardActivity =
Utilities_1.styled(DocumentCardActivity_base_1.DocumentCardActivityBase,
DocumentCardActivity_styles_1.getStyles, undefined, { scope: 'DocumentCardActivity'
});
//# sourceMappingURL=DocumentCardActivity.js.map
/***/ }),
/***/ 63353:
"use strict";

exports.getStyles = exports.DocumentCardActivityGlobalClassNames = void 0;
var VERTICAL_PADDING = 8;
var HORIZONTAL_PADDING = 16;
var IMAGE_SIZE = 32;
var PERSONA_TEXT_GUTTER = 8;
exports.DocumentCardActivityGlobalClassNames = {
root: 'ms-DocumentCardActivity',
multiplePeople: 'ms-DocumentCardActivity--multiplePeople',
details: 'ms-DocumentCardActivity-details',
name: 'ms-DocumentCardActivity-name',
activity: 'ms-DocumentCardActivity-activity',
avatars: 'ms-DocumentCardActivity-avatars',
avatar: 'ms-DocumentCardActivity-avatar',
};
var theme = props.theme, className = props.className, multiplePeople =
props.multiplePeople;
var classNames =
Styling_1.getGlobalClassNames(exports.DocumentCardActivityGlobalClassNames, theme);
return {
root: [
classNames.root,
multiplePeople && classNames.multiplePeople,
{
padding: VERTICAL_PADDING + "px " + HORIZONTAL_PADDING + "px",
},
className,
],
avatars: [
classNames.avatars,
{
marginLeft: '-2px',
height: '32px',
},
],
avatar: [
classNames.avatar,
{
width: IMAGE_SIZE,
height: IMAGE_SIZE,
selectors: {
'&:after': {
content: '" "',
left: '-1px',
top: '-1px',
right: '-1px',
bottom: '-1px',
border: "2px solid " + palette.white,
},
':nth-of-type(2)': multiplePeople && {
marginLeft: '-16px',
},
},
},
],
details: [
classNames.details,
{
left: multiplePeople
? HORIZONTAL_PADDING + IMAGE_SIZE * 1.5 + PERSONA_TEXT_GUTTER +
"px"
: HORIZONTAL_PADDING + IMAGE_SIZE + PERSONA_TEXT_GUTTER + "px",
height: IMAGE_SIZE,
top: VERTICAL_PADDING,
width: "calc(100% - " + (HORIZONTAL_PADDING + IMAGE_SIZE +
PERSONA_TEXT_GUTTER + HORIZONTAL_PADDING) + "px)",
},
],
name: [
classNames.name,
{
display: 'block',
lineHeight: '15px',
height: '15px',
overflow: 'hidden',
},
],
activity: [
classNames.activity,
{
display: 'block',
lineHeight: '15px',
height: '15px',
overflow: 'hidden',
},
],
};
};
//# sourceMappingURL=DocumentCardActivity.styles.js.map
/***/ }),
/***/ 97539:
"use strict";

//# sourceMappingURL=DocumentCardActivity.types.js.map
/***/ }),
/***/ 99938:
"use strict";

exports.DocumentCardDetailsBase = void 0;
/**
*/
var DocumentCardDetailsBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardDetailsBase, _super);
function DocumentCardDetailsBase(props) {
return _this;
}
DocumentCardDetailsBase.prototype.render = function () {
var _a = this.props, children = _a.children, styles = _a.styles, theme =
_a.theme, className = _a.className;
theme: theme,
});
return React.createElement("div", { className: this._classNames.root },
children);
};
return DocumentCardDetailsBase;
exports.DocumentCardDetailsBase = DocumentCardDetailsBase;
//# sourceMappingURL=DocumentCardDetails.base.js.map
/***/ }),
/***/ 22974:
"use strict";

exports.DocumentCardDetails = void 0;
var DocumentCardDetails_base_1 = __webpack_require__(99938);
var DocumentCardDetails_styles_1 = __webpack_require__(8769);
exports.DocumentCardDetails =
Utilities_1.styled(DocumentCardDetails_base_1.DocumentCardDetailsBase,
DocumentCardDetails_styles_1.getStyles, undefined, { scope:
'DocumentCardDetails' });
//# sourceMappingURL=DocumentCardDetails.js.map
/***/ }),
/***/ 8769:
"use strict";

root: 'ms-DocumentCardDetails',
};
return {
root: [
classNames.root,
{
display: 'flex',
flex: 1,
justifyContent: 'space-between',
overflow: 'hidden',
},
className,
],
};
};
//# sourceMappingURL=DocumentCardDetails.styles.js.map
/***/ }),
/***/ 4571:
"use strict";

//# sourceMappingURL=DocumentCardDetails.types.js.map
/***/ }),
/***/ 53769:
"use strict";

exports.DocumentCardImageBase = void 0;
/**
*/
var DocumentCardImageBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardImageBase, _super);
function DocumentCardImageBase(props) {
_this._onImageLoad = function () {
_this.setState({ imageHasLoaded: true });
};
_this.state = { imageHasLoaded: false };
return _this;
}
DocumentCardImageBase.prototype.render = function () {
var _a = this.props, styles = _a.styles, width = _a.width, height =
_a.height, imageFit = _a.imageFit, imageSrc = _a.imageSrc;
this._classNames = getClassNames(styles, this.props);
imageSrc && (React.createElement(Image_1.Image, { width: width, height:
height, imageFit: imageFit, src: imageSrc, role: "presentation", alt: "", onLoad:
this._onImageLoad })),
this.state.imageHasLoaded ? this._renderCornerIcon() :
this._renderCenterIcon()));
};
DocumentCardImageBase.prototype._renderCenterIcon = function () {
var iconProps = this.props.iconProps;
this._classNames.centeredIconWrapper },
React.createElement(Icon_1.Icon, tslib_1.__assign({ className:
this._classNames.centeredIcon }, iconProps))));
};
DocumentCardImageBase.prototype._renderCornerIcon = function () {
var iconProps = this.props.iconProps;
return React.createElement(Icon_1.Icon, tslib_1.__assign({ className:
this._classNames.cornerIcon }, iconProps));
};
return DocumentCardImageBase;
exports.DocumentCardImageBase = DocumentCardImageBase;
//# sourceMappingURL=DocumentCardImage.base.js.map
/***/ }),
/***/ 26425:
"use strict";

exports.DocumentCardImage = void 0;
var DocumentCardImage_base_1 = __webpack_require__(53769);
var DocumentCardImage_styles_1 = __webpack_require__(37267);
exports.DocumentCardImage =
Utilities_1.styled(DocumentCardImage_base_1.DocumentCardImageBase,
DocumentCardImage_styles_1.getStyles, undefined, { scope: 'DocumentCardImage' });
//# sourceMappingURL=DocumentCardImage.js.map
/***/ }),
/***/ 37267:
"use strict";

var centeredIconSize = '42px';
var cornerIconSize = '32px';
var theme = props.theme, className = props.className, height = props.height,
width = props.width;
return {
root: [
{
borderBottom: "1px solid " + palette.neutralLight,
backgroundColor: palette.neutralLighterAlt,
overflow: "hidden",
height: height && height + "px",
width: width && width + "px",
},
className,
],
centeredIcon: [
{
height: centeredIconSize,
width: centeredIconSize,
fontSize: centeredIconSize,
},
],
centeredIconWrapper: [
{
display: 'flex',
height: '100%',
width: '100%',
top: 0,
left: 0,
},
],
cornerIcon: [
{
left: '10px',
bottom: '10px',
height: cornerIconSize,
width: cornerIconSize,
fontSize: cornerIconSize,
},
],
};
};
//# sourceMappingURL=DocumentCardImage.styles.js.map
/***/ }),
/***/ 72612:
"use strict";

//# sourceMappingURL=DocumentCardImage.types.js.map
/***/ }),
/***/ 16215:
"use strict";
exports.DocumentCardLocationBase = void 0;
/**
*/
var DocumentCardLocationBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardLocationBase, _super);
function DocumentCardLocationBase(props) {
return _this;
}
DocumentCardLocationBase.prototype.render = function () {
var _a = this.props, location = _a.location, locationHref =
_a.locationHref, ariaLabel = _a.ariaLabel, onClick = _a.onClick, styles =
theme: theme,
});
return (React.createElement("a", { className: this._classNames.root, href:
locationHref, onClick: onClick, "aria-label": ariaLabel }, location));
};
return DocumentCardLocationBase;
exports.DocumentCardLocationBase = DocumentCardLocationBase;
//# sourceMappingURL=DocumentCardLocation.base.js.map
/***/ }),
/***/ 33360:
"use strict";

exports.DocumentCardLocation = void 0;
var DocumentCardLocation_base_1 = __webpack_require__(16215);
var DocumentCardLocation_styles_1 = __webpack_require__(2950);
exports.DocumentCardLocation =
Utilities_1.styled(DocumentCardLocation_base_1.DocumentCardLocationBase,
DocumentCardLocation_styles_1.getStyles, undefined, { scope: 'DocumentCardLocation'
});
//# sourceMappingURL=DocumentCardLocation.js.map
/***/ }),
/***/ 2950:
"use strict";

exports.getStyles = exports.DocumentCardLocationGlobalClassNames = void 0;
exports.DocumentCardLocationGlobalClassNames = {
root: 'ms-DocumentCardLocation',
};
var theme = props.theme, className = props.className;
var classNames =
Styling_1.getGlobalClassNames(exports.DocumentCardLocationGlobalClassNames, theme);
return {
root: [
classNames.root,
fonts.small,
{
display: 'block',
overflow: 'hidden',
selectors: {
':hover': {
cursor: 'pointer',
},
},
},
className,
],
};
};
//# sourceMappingURL=DocumentCardLocation.styles.js.map
/***/ }),
/***/ 6588:
"use strict";

//# sourceMappingURL=DocumentCardLocation.types.js.map
/***/ }),
/***/ 38969:
"use strict";

exports.DocumentCardLogoBase = void 0;
/**
*/
var DocumentCardLogoBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardLogoBase, _super);
function DocumentCardLogoBase(props) {
return _this;
}
DocumentCardLogoBase.prototype.render = function () {
var _a = this.props, logoIcon = _a.logoIcon, styles = _a.styles, theme =
theme: theme,
});
React.createElement(Icon_1.Icon, { iconName: logoIcon })));
};
return DocumentCardLogoBase;
exports.DocumentCardLogoBase = DocumentCardLogoBase;
//# sourceMappingURL=DocumentCardLogo.base.js.map
/***/ }),
/***/ 40101:
"use strict";

exports.DocumentCardLogo = void 0;
var DocumentCardLogo_base_1 = __webpack_require__(38969);
var DocumentCardLogo_styles_1 = __webpack_require__(64481);
exports.DocumentCardLogo =
Utilities_1.styled(DocumentCardLogo_base_1.DocumentCardLogoBase,
DocumentCardLogo_styles_1.getStyles, undefined, { scope: 'DocumentCardLogo' });
//# sourceMappingURL=DocumentCardLogo.js.map
/***/ }),
/***/ 64481:
"use strict";

root: 'ms-DocumentCardLogo',
};
return {
root: [
classNames.root,
{
fontSize: fonts.xxLargePlus.fontSize,
display: 'block',
},
className,
],
};
};
//# sourceMappingURL=DocumentCardLogo.styles.js.map
/***/ }),
/***/ 86400:
"use strict";

//# sourceMappingURL=DocumentCardLogo.types.js.map
/***/ }),
/***/ 55209:
"use strict";

exports.DocumentCardPreviewBase = void 0;
var DEFAULT_DISPLAY_COUNT = 3;
/**
*/
var DocumentCardPreviewBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardPreviewBase, _super);
function DocumentCardPreviewBase(props) {
_this._renderPreviewList = function (previewImages) {
var _a = _this.props, getOverflowDocumentCountText =
_a.getOverflowDocumentCountText, _b = _a.maxDisplayCount, maxDisplayCount = _b ===
void 0 ? DEFAULT_DISPLAY_COUNT : _b;
// Determine how many documents we won't be showing
var overflowDocumentCount = previewImages.length - maxDisplayCount;
// Determine the overflow text that will be rendered after the preview
list.
var overflowText = overflowDocumentCount
? getOverflowDocumentCountText
? getOverflowDocumentCountText(overflowDocumentCount)
: '+' + overflowDocumentCount
: null;
// Create list items for the documents to be shown
var fileListItems = previewImages.slice(0,
maxDisplayCount).map(function (file, fileIndex) { return (React.createElement("li",
{ key: fileIndex },
React.createElement(Image_1.Image, { className:
_this._classNames.fileListIcon, src: file.iconSrc, role: "presentation", alt: "",
width: "16px", height: "16px" }),
React.createElement(Link_1.Link, tslib_1.__assign({ className:
_this._classNames.fileListLink,
href: file.url }, file.linkProps), file.name))); });
React.createElement("ul", { className:
_this._classNames.fileList }, fileListItems),
overflowText && React.createElement("span", { className:
_this._classNames.fileListOverflowText }, overflowText)));
};
return _this;
}
DocumentCardPreviewBase.prototype.render = function () {
var _a = this.props, previewImages = _a.previewImages, styles = _a.styles,
theme = _a.theme, className = _a.className;
var style;
var preview;
var isFileList = previewImages.length > 1;
theme: theme,
isFileList: isFileList,
});
if (previewImages.length > 1) {
// Render a list of files
preview = this._renderPreviewList(previewImages);
}
else if (previewImages.length === 1) {
// Render a single preview
preview = this._renderPreviewImage(previewImages[0]);
// Override the border color if an accent color was provided
if (previewImages[0].accentColor) {
style = {
borderBottomColor: previewImages[0].accentColor,
};
}
}
return (React.createElement("div", { className: this._classNames.root,
style: style }, preview));
};
DocumentCardPreviewBase.prototype._renderPreviewImage = function (previewImage)
{
var width = previewImage.width, height = previewImage.height, imageFit =
previewImage.imageFit, previewIconProps = previewImage.previewIconProps,
previewIconContainerClass = previewImage.previewIconContainerClass;
if (previewIconProps) {
Utilities_1.css(this._classNames.previewIcon, previewIconContainerClass), style:
{ width: width, height: height } },
React.createElement(Icon_1.Icon, tslib_1.__assign({},
previewIconProps))));
}
var image = (React.createElement(Image_1.Image, { width: width, height:
height, imageFit: imageFit, src: previewImage.previewImageSrc, role:
"presentation", alt: "" }));
var icon;
if (previewImage.iconSrc) {
icon = React.createElement(Image_1.Image, { className:
this._classNames.icon, src: previewImage.iconSrc, role: "presentation", alt: "" });
}
image,
icon));
};
return DocumentCardPreviewBase;
exports.DocumentCardPreviewBase = DocumentCardPreviewBase;
//# sourceMappingURL=DocumentCardPreview.base.js.map
/***/ }),
/***/ 40726:
"use strict";

exports.DocumentCardPreview = void 0;
var DocumentCardPreview_base_1 = __webpack_require__(55209);
var DocumentCardPreview_styles_1 = __webpack_require__(85074);
exports.DocumentCardPreview =
Utilities_1.styled(DocumentCardPreview_base_1.DocumentCardPreviewBase,
DocumentCardPreview_styles_1.getStyles, undefined, { scope:
'DocumentCardPreview' });
//# sourceMappingURL=DocumentCardPreview.js.map
/***/ }),
/***/ 85074:
"use strict";

exports.getStyles = exports.DocumentCardPreviewGlobalClassNames = void 0;
exports.DocumentCardPreviewGlobalClassNames = {
root: 'ms-DocumentCardPreview',
icon: 'ms-DocumentCardPreview-icon',
iconContainer: 'ms-DocumentCardPreview-iconContainer',
};
var _a, _b;
var theme = props.theme, className = props.className, isFileList =
props.isFileList;
var classNames =
Styling_1.getGlobalClassNames(exports.DocumentCardPreviewGlobalClassNames, theme);
return {
root: [
classNames.root,
fonts.small,
{
backgroundColor: isFileList ? palette.white :
palette.neutralLighterAlt,
borderBottom: "1px solid " + palette.neutralLight,
overflow: "hidden",
},
className,
],
previewIcon: [
classNames.iconContainer,
{
display: 'flex',
height: '100%',
},
],
icon: [
classNames.icon,
{
left: '10px',
bottom: '10px',
},
],
fileList: {
margin: 0,
selectors: {
li: {
height: '16px',
lineHeight: '16px',
display: 'flex',
flexWrap: 'nowrap',
overflow: 'hidden',
},
},
},
fileListIcon: {
flexShrink: 0,
marginRight: '8px',
},
fileListLink: [
outline: 'none',
},
}),
{
flexGrow: 1,
overflow: 'hidden',
selectors: (_a = {
':hover': {
}
},
outline: 'none',
},
_b),
},
_a),
},
],
fileListOverflowText: {
display: 'block',
},
};
};
//# sourceMappingURL=DocumentCardPreview.styles.js.map
/***/ }),
/***/ 27034:
"use strict";

//# sourceMappingURL=DocumentCardPreview.types.js.map
/***/ }),
/***/ 10100:
"use strict";

exports.DocumentCardStatusBase = void 0;
/**
*/
var DocumentCardStatusBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardStatusBase, _super);
function DocumentCardStatusBase(props) {
return _this;
}
DocumentCardStatusBase.prototype.render = function () {
var _a = this.props, statusIcon = _a.statusIcon, status = _a.status, styles
= _a.styles, theme = _a.theme, className = _a.className;
var iconProps = {
iconName: statusIcon,
styles: {
root: { padding: '8px' },
},
};
theme: theme,
});
statusIcon && React.createElement(Icon_1.Icon, tslib_1.__assign({},
iconProps)),
status));
};
return DocumentCardStatusBase;
exports.DocumentCardStatusBase = DocumentCardStatusBase;
//# sourceMappingURL=DocumentCardStatus.base.js.map
/***/ }),
/***/ 23343:
"use strict";

exports.DocumentCardStatus = void 0;
var DocumentCardStatus_base_1 = __webpack_require__(10100);
var DocumentCardStatus_styles_1 = __webpack_require__(76660);
exports.DocumentCardStatus =
Utilities_1.styled(DocumentCardStatus_base_1.DocumentCardStatusBase,
DocumentCardStatus_styles_1.getStyles, undefined, { scope: 'DocumentCardStatus' });
//# sourceMappingURL=DocumentCardStatus.js.map
/***/ }),
/***/ 76660:
"use strict";

root: 'ms-DocumentCardStatus',
};
return {
root: [
classNames.root,
fonts.medium,
{
margin: '8px 16px',
height: '32px',
},
className,
],
};
};
//# sourceMappingURL=DocumentCardStatus.styles.js.map
/***/ }),
/***/ 56171:
"use strict";

//# sourceMappingURL=DocumentCardStatus.types.js.map
/***/ }),
/***/ 84499:
"use strict";

exports.DocumentCardTitleBase = void 0;
var DocumentCard_base_1 = __webpack_require__(50613);
var TRUNCATION_VERTICAL_OVERFLOW_THRESHOLD = 5;
/**
*/
var DocumentCardTitleBase = /** @class */ (function (_super) {
tslib_1.__extends(DocumentCardTitleBase, _super);
function DocumentCardTitleBase(props) {
_this._titleElement = React.createRef();
// Truncate logic here way can't handle the case that chars with different
widths are mixed very well.
// Let _shrinkTitle take care of that.
_this._truncateTitle = function () {
if (!_this._needMeasurement) {
return;
}
_this._async.requestAnimationFrame(_this._truncateWhenInAnimation);
};
_this._truncateWhenInAnimation = function () {
var originalTitle = _this.props.title;
var element = _this._titleElement.current;
if (element) {
var style = getComputedStyle(element);
if (style.width && style.lineHeight && style.height) {
var clientWidth = element.clientWidth, scrollWidth =
element.scrollWidth;
_this._clientWidth = clientWidth;
var lines = Math.floor((parseInt(style.height, 10) +
TRUNCATION_VERTICAL_OVERFLOW_THRESHOLD) / parseInt(style.lineHeight, 10));
element.style.whiteSpace = '';
// Use overflow to predict truncated length.
// Take an example.The text is: A text with A very long text
that need to be truncated.ppt
// if container is like
// |A text with A very| long text that need to be truncated.ppt
// The scroll width is 58, (take two | out of length)
// The client width is 18
// the overflow rate is scrollWidth/clientWidth which should be
close to length(overflowText)/length(visualText)
// And the length of remaining text should be truncated is
(original Length)/(58/18) -3 = 15.
// So that the logic can predict truncated text well.
// first piece will be À text `, * second piece will be
àted.ppt`
// |A text ...ated.ppt|
var overFlowRate = scrollWidth / (parseInt(style.width, 10) *
lines);
if (overFlowRate > 1) {
var truncatedLength = originalTitle.length / overFlowRate -
3; /** Saved for separator */
return _this.setState({
truncatedTitleFirstPiece: originalTitle.slice(0,
truncatedLength / 2),
truncatedTitleSecondPiece:
originalTitle.slice(originalTitle.length - truncatedLength / 2),
});
}
}
}
};
_this._shrinkTitle = function () {
var _a = _this.state, truncatedTitleFirstPiece =
_a.truncatedTitleFirstPiece, truncatedTitleSecondPiece =
_a.truncatedTitleSecondPiece;
if (truncatedTitleFirstPiece && truncatedTitleSecondPiece) {
var titleElement = _this._titleElement.current;
if (!titleElement) {
return;
}
if (titleElement.scrollHeight > titleElement.clientHeight +
TRUNCATION_VERTICAL_OVERFLOW_THRESHOLD ||
titleElement.scrollWidth > titleElement.clientWidth) {
_this.setState({
truncatedTitleFirstPiece: truncatedTitleFirstPiece.slice(0,
truncatedTitleFirstPiece.length - 1),
truncatedTitleSecondPiece:
truncatedTitleSecondPiece.slice(1),
});
}
}
};
_this._clientWidth = undefined;
_this.state = {
truncatedTitleFirstPiece: undefined,
truncatedTitleSecondPiece: undefined,
};
return _this;
}
DocumentCardTitleBase.prototype.componentDidUpdate = function (prevProps) {
var _this = this;
if (this.props.title !== prevProps.title) {
this.setState({
});
}
if (prevProps.shouldTruncate !== this.props.shouldTruncate) {
if (this.props.shouldTruncate) {
this._truncateTitle();
this._async.requestAnimationFrame(this._shrinkTitle);
this._events.on(window, 'resize', this._updateTruncation);
}
else {
this._events.off(window, 'resize', this._updateTruncation);
}
}
else if (this._needMeasurement) {
this._async.requestAnimationFrame(function () {
_this._truncateWhenInAnimation();
_this._shrinkTitle();
});
}
};
DocumentCardTitleBase.prototype.componentDidMount = function () {
if (this.props.shouldTruncate) {
this._truncateTitle();
this._events.on(window, 'resize', this._updateTruncation);
}
};
DocumentCardTitleBase.prototype.componentWillUnmount = function () {
};
DocumentCardTitleBase.prototype.render = function () {
var _this = this;
var _a = this.props, title = _a.title, shouldTruncate = _a.shouldTruncate,
showAsSecondaryTitle = _a.showAsSecondaryTitle, styles = _a.styles, theme =
var _b = this.state, truncatedTitleFirstPiece =
_b.truncatedTitleFirstPiece, truncatedTitleSecondPiece =
_b.truncatedTitleSecondPiece;
theme: theme,
showAsSecondaryTitle: showAsSecondaryTitle,
});
if (shouldTruncate && truncatedTitleFirstPiece &&
truncatedTitleSecondPiece) {
return
(React.createElement(DocumentCard_base_1.DocumentCardContext.Consumer, null,
function (_a) {
var role = _a.role, tabIndex = _a.tabIndex;
_this._classNames.root, ref: _this._titleElement, title: title, tabIndex: tabIndex,
role: role },
truncatedTitleFirstPiece,
"\u2026",
truncatedTitleSecondPiece));
}));
}
else {
return
(React.createElement(DocumentCard_base_1.DocumentCardContext.Consumer, null,
function (_a) {
var role = _a.role, tabIndex = _a.tabIndex;
_this._classNames.root, ref: _this._titleElement, title: title, tabIndex: tabIndex,
role: role, style: _this._needMeasurement ? { whiteSpace: 'nowrap' } : undefined },
title));
}));
}
};
Object.defineProperty(DocumentCardTitleBase.prototype, "_needMeasurement", {
/**
* In measuring, it will render a same style text with whiteSpace:
'nowrap', to get overflow rate.
* So that the logic can predict truncated text well.
*/
get: function () {
return !!this.props.shouldTruncate && this._clientWidth === undefined;
},
enumerable: false,
configurable: true
});
DocumentCardTitleBase.prototype._updateTruncation = function () {
var _this = this;
if (this._timerId) {
return;
}
this._timerId = this._async.setTimeout(function () {
delete _this._timerId;
_this._clientWidth = undefined;
_this.setState({
});
}, 250);
};
return DocumentCardTitleBase;
exports.DocumentCardTitleBase = DocumentCardTitleBase;
//# sourceMappingURL=DocumentCardTitle.base.js.map
/***/ }),
/***/ 56164:
"use strict";

exports.DocumentCardTitle = void 0;
var DocumentCardTitle_base_1 = __webpack_require__(84499);
var DocumentCardTitle_styles_1 = __webpack_require__(56392);
exports.DocumentCardTitle =
Utilities_1.styled(DocumentCardTitle_base_1.DocumentCardTitleBase,
DocumentCardTitle_styles_1.getStyles, undefined, { scope: 'DocumentCardTitle' });
//# sourceMappingURL=DocumentCardTitle.js.map
/***/ }),
/***/ 56392:
"use strict";

exports.getStyles = exports.DocumentCardTitleGlobalClassNames = void 0;
exports.DocumentCardTitleGlobalClassNames = {
root: 'ms-DocumentCardTitle',
};
var _a;
var theme = props.theme, className = props.className, showAsSecondaryTitle =
props.showAsSecondaryTitle;
var palette = theme.palette, fonts = theme.fonts, effects = theme.effects;
var classNames =
Styling_1.getGlobalClassNames(exports.DocumentCardTitleGlobalClassNames, theme);
return {
root: [
classNames.root,
showAsSecondaryTitle ? fonts.medium : fonts.large,
{
display: 'block',
overflow: 'hidden',
height: showAsSecondaryTitle ? '45px' : '38px',
lineHeight: showAsSecondaryTitle ? '18px' : '21px',
color: showAsSecondaryTitle ? palette.neutralSecondary :
palette.neutralPrimary,
selectors: (_a = {
':focus': {
outline: '0px solid',
}
},
Styling_1.getInputFocusStyle(palette.neutralSecondary, effects.roundedCorner2),
_a),
},
className,
],
};
};
//# sourceMappingURL=DocumentCardTitle.styles.js.map
/***/ }),
/***/ 87466:
"use strict";

//# sourceMappingURL=DocumentCardTitle.types.js.map
/***/ }),
/***/ 18576:
"use strict";

/***/ }),
/***/ 70635:
"use strict";

exports.DropdownBase = void 0;
var Dropdown_types_1 = __webpack_require__(82425);
var DropdownSizePosCache_1 = __webpack_require__(94390);
var Panel_1 = __webpack_require__(71927);
// import and use V7 Checkbox to ensure no breaking changes.
var Checkbox_1 = __webpack_require__(78754);
var COMPONENT_NAME = 'Dropdown';
options: [],
};
function useSelectedItemsState(_a) {
var defaultSelectedKeys = _a.defaultSelectedKeys, selectedKeys =
_a.selectedKeys, defaultSelectedKey = _a.defaultSelectedKey, selectedKey =
_a.selectedKey, options = _a.options, multiSelect = _a.multiSelect;
var oldOptions = react_hooks_1.usePrevious(options);
var _b = React.useState([]), selectedIndices = _b[0], setSelectedIndices =
_b[1];
// In controlled component usage where selectedKey is provided, update the
selectedIndex
// state if the key or options change.
var selectedKeyPropToUse;
// this does a shallow compare (assumes options are pure), for the purposes of
determining whether
// defaultSelectedKey/defaultSelectedKeys are respected.
var didOptionsChange = options !== oldOptions;
if (multiSelect) {
if (didOptionsChange && defaultSelectedKeys !== undefined) {
selectedKeyPropToUse = defaultSelectedKeys;
}
else {
selectedKeyPropToUse = selectedKeys;
}
}
else {
if (didOptionsChange && defaultSelectedKey !== undefined) {
selectedKeyPropToUse = defaultSelectedKey;
}
else {
selectedKeyPropToUse = selectedKey;
}
}
var oldSelectedKeyProp = react_hooks_1.usePrevious(selectedKeyPropToUse);
/** Get all selected indexes for multi-select mode */
var getSelectedIndexes = function () {
if (selectedKeyPropToUse === undefined) {
if (multiSelect) {
return getAllSelectedIndices();
}
var selectedIndex = getSelectedIndex(null);
return selectedIndex !== -1 ? [selectedIndex] : [];
}
else if (!Array.isArray(selectedKeyPropToUse)) {
var selectedIndex = getSelectedIndex(selectedKeyPropToUse);
return selectedIndex !== -1 ? [selectedIndex] : [];
}
var returnValue = [];
for (var _i = 0, selectedKeyPropToUse_1 = selectedKeyPropToUse; _i <
selectedKeyPropToUse_1.length; _i++) {
var key = selectedKeyPropToUse_1[_i];
var selectedIndex = getSelectedIndex(key);
selectedIndex !== -1 && returnValue.push(selectedIndex);
}
return returnValue;
};
var getAllSelectedIndices = function () {
return options
.map(function (option, index) { return (option.selected ? index : -
1); })
.filter(function (index) { return index !== -1; });
};
var getSelectedIndex = function (searchKey) {
return Utilities_1.findIndex(options, function (option) {
// eslint-disable-next-line eqeqeq
if (searchKey != null) {
return option.key === searchKey;
}
else {
return !!option.selected || !!option.isSelected;
}
});
};
if ((selectedKeyPropToUse !== undefined || !oldOptions) &&
(selectedKeyPropToUse !== oldSelectedKeyProp || didOptionsChange)) {
setSelectedIndices(getSelectedIndexes());
}
}, [didOptionsChange, multiSelect, oldOptions, oldSelectedKeyProp, options,
selectedKeyPropToUse]);
return [selectedIndices, setSelectedIndices];
}
exports.DropdownBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
var mergedRootRef = react_hooks_1.useMergedRefs(forwardedRef, rootRef);
var responsiveMode = ResponsiveMode_1.useResponsiveMode(rootRef,
props.responsiveMode);
var _a = useSelectedItemsState(props), selectedIndices = _a[0],
setSelectedIndices = _a[1];
return (React.createElement(DropdownInternal, tslib_1.__assign({}, props,
{ responsiveMode: responsiveMode, hoisted: { rootRef: mergedRootRef,
selectedIndices: selectedIndices, setSelectedIndices: setSelectedIndices } })));
});
exports.DropdownBase.displayName = 'DropdownBase';
var DropdownInternal = /** @class */ (function (_super) {
tslib_1.__extends(DropdownInternal, _super);
function DropdownInternal(props) {
_this._host = React.createRef();
_this._dropDown = React.createRef();
_this._scrollIdleDelay = 250 /* ms */;
_this._sizePosCache = new DropdownSizePosCache_1.DropdownSizePosCache();
_this._requestAnimationFrame =
Utilities_1.safeRequestAnimationFrame(_this);
/**
* Close menu callout if it is open
*/
_this.dismissMenu = function () {
isOpen && _this.setState({ isOpen: false });
};
_this._onChange = function (event, options, index, checked, multiSelect) {
var _a = _this.props, onChange = _a.onChange, onChanged = _a.onChanged;
if (onChange || onChanged) {
// for single-select, option passed in will always be selected.
// for multi-select, flip the checked value
var changedOpt = multiSelect ?
tslib_1.__assign(tslib_1.__assign({}, options[index]), { selected: !checked }) :
options[index];
onChange && onChange(tslib_1.__assign(tslib_1.__assign({}, event),
{ target: _this._dropDown.current }), changedOpt, index);
onChanged && onChanged(changedOpt, index);
}
};
/** Get either props.placeholder (new name) or props.placeHolder (old name)
*/
_this._getPlaceholder = function () {
return _this.props.placeholder || _this.props.placeHolder;
};
/** Get text in dropdown input as a string */
_this._getTitle = function (items, _unused) {
var _a = _this.props.multiSelectDelimiter, multiSelectDelimiter = _a
=== void 0 ? ', ' : _a;
return items.map(function (i) { return
i.text; }).join(multiSelectDelimiter);
};
/** Render text in dropdown input */
_this._onRenderTitle = function (items) {
return React.createElement(React.Fragment, null,
_this._getTitle(items));
};
/** Render placeholder text in dropdown input */
_this._onRenderPlaceholder = function (props) {
if (!_this._getPlaceholder()) {
return null;
}
return React.createElement(React.Fragment, null,
_this._getPlaceholder());
};
/** Render Callout or Panel container and pass in list */
_this._onRenderContainer = function (props) {
var calloutProps = props.calloutProps, panelProps = props.panelProps;
var _a = _this.props, responsiveMode = _a.responsiveMode, dropdownWidth
= _a.dropdownWidth;
var isSmall = responsiveMode <= ResponsiveMode_1.ResponsiveMode.medium;
var focusTrapZoneProps = { firstFocusableTarget: "#" + _this._listId +
"1" };
var panelStyles = _this._classNames.subComponentStyles
? _this._classNames.subComponentStyles.panel
: undefined;
var calloutWidth = undefined;
var calloutMinWidth = undefined;
if (dropdownWidth === 'auto') {
calloutMinWidth = _this._dropDown.current ?
_this._dropDown.current.clientWidth : 0;
}
else {
calloutWidth = dropdownWidth || (_this._dropDown.current ?
_this._dropDown.current.clientWidth : 0);
}
return isSmall ? (React.createElement(Panel_1.Panel, tslib_1.__assign({
closeButtonAriaLabel: "Close", focusTrapZoneProps: focusTrapZoneProps,
hasCloseButton: true, isOpen: true, isLightDismiss: true, onDismiss:
_this._onDismiss, styles: panelStyles }, panelProps),
_this._renderFocusableList(props))) : (React.createElement(Callout_1.Callout,
tslib_1.__assign({ isBeakVisible: false, gapSpace: 0, doNotLayer: false,
directionalHintFixed: false, directionalHint:
Callout_1.DirectionalHint.bottomLeftEdge, calloutWidth: calloutWidth,
calloutMinWidth: calloutMinWidth }, calloutProps, { className:
_this._classNames.callout, target: _this._dropDown.current, onDismiss:
_this._onDismiss, onScroll: _this._onScroll, onPositioned: _this._onPositioned }),
_this._renderFocusableList(props)));
};
/** Render Caret Down Icon */
_this._onRenderCaretDown = function (props) {
return React.createElement(Icon_1.Icon, { className:
_this._classNames.caretDown, iconName: "ChevronDown", "aria-hidden": true });
};
/** Render List of items */
var _a = props.onRenderItem, onRenderItem = _a === void 0 ?
_this._onRenderItem : _a;
var queue = { items: [] };
var renderedList = [];
var emptyQueue = function () {
var newGroup = queue.id
? [
React.createElement("div", { role: "group", key: queue.id,
"aria-labelledby": queue.id }, queue.items),
]
: queue.items;
renderedList = tslib_1.__spreadArray(tslib_1.__spreadArray([],
renderedList), newGroup);
// Flush items and id
queue = { items: [] };
};
var placeRenderedOptionIntoQueue = function (item, index) {
/*
Case Header
empty queue if it's not already empty
ensure unique ID for header and set queue ID
push header into queue
Case Divider
push divider into queue if not first item
empty queue if not already empty
Default
push item into queue
*/
var id = _this._id + item.key;
queue.items.push(onRenderItem(tslib_1.__assign(tslib_1.__assign({ id: id }, item),

{ index: index }), _this._onRenderItem));
queue.id = id;
break;
index > 0 &&
break;
default:

}
};
// Place options into the queue. Queue will be emptied anytime a Header
or Divider is encountered
props.options.forEach(function (item, index) {
placeRenderedOptionIntoQueue(item, index);
});
// Push remaining items into all renderedList
return React.createElement(React.Fragment, null, renderedList);
};
return _this._renderSeparator(item);
return _this._renderHeader(item);
default:
return _this._renderOption(item);
}
};
_this._renderOption = function (item) {
var _a = _this.props, _b = _a.onRenderOption, onRenderOption = _b ===
void 0 ? _this._onRenderOption : _b, _c = _a.hoisted.selectedIndices,
selectedIndices = _c === void 0 ? [] : _c;
var isItemSelected = item.index !== undefined && selectedIndices ?
selectedIndices.indexOf(item.index) > -1 : false;
// select the right className based on the combination of
selected/disabled
var itemClassName = item.hidden // predicate: item hidden
? _this._classNames.dropdownItemHidden
: isItemSelected && item.disabled === true // predicate: both
selected and disabled
? _this._classNames.dropdownItemSelectedAndDisabled
: isItemSelected // predicate: selected only
? _this._classNames.dropdownItemSelected
: item.disabled === true // predicate: disabled only
? _this._classNames.dropdownItemDisabled
: _this._classNames.dropdownItem;
var title = item.title;
var multiSelectItemStyles = _this._classNames.subComponentStyles
? _this._classNames.subComponentStyles.multiSelectItem
: undefined;
return !_this.props.multiSelect ?
(React.createElement(Button_1.CommandButton, { id: _this._listId + item.index, key:
item.key, "data-index": item.index, "data-is-focusable": !item.disabled, disabled:
item.disabled, className: itemClassName, onClick: _this._onItemClick(item),
onMouseEnter: _this._onItemMouseEnter.bind(_this, item),
onMouseLeave: _this._onMouseItemLeave.bind(_this, item),
onMouseMove: _this._onItemMouseMove.bind(_this, item), role:
"option", "aria-selected": isItemSelected ? 'true' : 'false', ariaLabel:
item.ariaLabel, title: title, "aria-posinset":
_this._sizePosCache.positionInSet(item.index), "aria-setsize":
_this._sizePosCache.optionSetSize }, onRenderOption(item,
_this._onRenderOption))) : (React.createElement(Checkbox_1.Checkbox, { id:
_this._listId + item.index, key: item.key, disabled: item.disabled, onChange:
_this._onItemClick(item), inputProps: tslib_1.__assign({ 'aria-selected':
isItemSelected, onMouseEnter: _this._onItemMouseEnter.bind(_this, item),
onMouseLeave: _this._onMouseItemLeave.bind(_this, item), onMouseMove:
_this._onItemMouseMove.bind(_this, item), role: 'option' }, {
'data-index': item.index,
'data-is-focusable': !item.disabled,
}), label: item.text, title: title,
onRenderLabel: _this._onRenderItemLabel.bind(_this, item),
className: itemClassName, checked: isItemSelected, styles: multiSelectItemStyles,
ariaPositionInSet: _this._sizePosCache.positionInSet(item.index), ariaSetSize:
_this._sizePosCache.optionSetSize, ariaLabel: item.ariaLabel }));
};
/** Render content of item (i.e. text/icon inside of button) */
_this._onRenderOption = function (item) {
_this._classNames.dropdownOptionText }, item.text);
};
/** Render custom label for drop down item */
_this._onRenderItemLabel = function (item) {
var _a = _this.props.onRenderOption, onRenderOption = _a === void 0 ?
_this._onRenderOption : _a;
return onRenderOption(item, _this._onRenderOption);
};
_this._onPositioned = function (positions) {
if (_this._focusZone.current) {
// Focusing an element can trigger a reflow. Making this wait until
there is an animation
// frame can improve perf significantly.
_this._requestAnimationFrame(function () {
var selectedIndices = _this.props.hoisted.selectedIndices;
if (_this._focusZone.current) {
if (!_this._hasBeenPositioned &&
selectedIndices &&
selectedIndices[0] &&
!_this.props.options[selectedIndices[0]].disabled) {
var element =
Utilities_1.getDocument().getElementById(_this._id + "-list" + selectedIndices[0]);
if (element) {
_this._focusZone.current.focusElement(element);
}
_this._hasBeenPositioned = true;
}
else {
_this._focusZone.current.focus();
}
}
});
}
if (!_this.state.calloutRenderEdge || _this.state.calloutRenderEdge !==
positions.targetEdge) {
_this.setState({
calloutRenderEdge: positions.targetEdge,
});
}
};
_this._onItemClick = function (item) {
return function (event) {
if (!item.disabled) {
_this.setSelectedIndex(event, item.index);
// only close the callout when it's in single-select mode
_this.setState({
isOpen: false,
});
}
}
};
};
/**
*/
if (!_this._isScrollIdle && _this._scrollIdleTimeoutId !== undefined) {
clearTimeout(_this._scrollIdleTimeoutId);
_this._scrollIdleTimeoutId = undefined;
}
else {
_this._isScrollIdle = false;
}
_this._scrollIdleTimeoutId = window.setTimeout(function () {
}, _this._scrollIdleDelay);
};
_this._onMouseItemLeave = function (item, ev) {
if (_this._shouldIgnoreMouseEvent()) {
return;
}
/**
* Edge and IE expose a setActive() function for focusable divs that
*/
if (_this._host.current) {
if (_this._host.current.setActive) {
try {
_this._host.current.setActive();
}
catch (e) {
/* no-op */
}
}
else {
_this._host.current.focus();
}
}
};
_this._onDismiss = function () {
_this.setState({ isOpen: false });
};
_this._onDropdownBlur = function (ev) {
// If Dropdown disabled do not proceed with this logic.
var disabled = _this._isDisabled();
if (disabled) {
return;
}
if (_this.state.isOpen) {
// Do not call onBlur or update focus state when the callout is
opened
return;
}
_this.setState({ hasFocus: false });
if (_this.props.onBlur) {
_this.props.onBlur(ev);
}
};
_this._onDropdownKeyDown = function (ev) {
// If Dropdown disabled do not process any keyboard events.
if (disabled) {
return;
}
keydown.
// See comment in _shouldHandleKeyUp for reasoning.
_this._lastKeyDownWasAltOrMeta = _this._isAltOrMeta(ev);
return;
}
}
var newIndex;
var selectedIndex = _this.props.hoisted.selectedIndices.length ?
_this.props.hoisted.selectedIndices[0] : -1;
var containsExpandCollapseModifier = ev.altKey || ev.metaKey;
switch (ev.which) {
_this.setState({
isOpen: !isOpen,
});
break;
if (!isOpen) {
return;
}
_this.setState({
isOpen: false,
});
break;
if (containsExpandCollapseModifier) {
if (isOpen) {
break;
}
return;
}
if (_this.props.multiSelect) {
}
else if (!_this._isDisabled()) {
newIndex = _this._moveIndex(ev, -1, selectedIndex - 1,
selectedIndex);
}
break;
}
if ((containsExpandCollapseModifier && !isOpen) ||
_this.props.multiSelect) {
}
else if (!_this._isDisabled()) {
newIndex = _this._moveIndex(ev, 1, selectedIndex + 1,
selectedIndex);
}
break;
newIndex = _this._moveIndex(ev, 1, 0, selectedIndex);
}
break;
newIndex = _this._moveIndex(ev, -1,
_this.props.options.length - 1, selectedIndex);
}
break;
// event handled in _onDropdownKeyUp
break;
default:
return;
}
if (newIndex !== selectedIndex) {
}
};
_this._onDropdownKeyUp = function (ev) {
// If Dropdown disabled do not process any keyboard events.
if (disabled) {
return;
}
var shouldHandleKey = _this._shouldHandleKeyUp(ev);
if (_this.props.onKeyUp) {
_this.props.onKeyUp(ev);
return;
}
}
switch (ev.which) {
_this.setState({
isOpen: !isOpen,
});
break;
default:
if (shouldHandleKey && isOpen) {
}
return;
}
};
_this._onZoneKeyDown = function (ev) {
var _a, _b;
var elementToFocus;
keydown.
// See comment in _shouldHandleKeyUp for reasoning.
_this._lastKeyDownWasAltOrMeta = _this._isAltOrMeta(ev);
var containsExpandCollapseModifier = ev.altKey || ev.metaKey;
switch (ev.which) {
}
else {
if (_this._host.current) {
elementToFocus =
Utilities_1.getLastFocusable(_this._host.current, _this._host.current.lastChild,
true);
}
}
break;
// All directional keystrokes should be canceled when the zone is
rendered.
// This avoids the body scroll from reacting and thus dismissing
the dropdown.
case Utilities_1.KeyCodes.pageUp:
case Utilities_1.KeyCodes.pageDown:
break;
if (!containsExpandCollapseModifier && _this._host.current) {
elementToFocus =
Utilities_1.getFirstFocusable(_this._host.current, _this._host.current.firstChild,
true);
}
break;
break;
var document_1 = Utilities_1.getDocument();
if (document_1) {
if (ev.shiftKey) {
(_a = utilities_1.getPreviousElement(document_1.body,
_this._dropDown.current, false, false, true, true)) === null || _a === void 0 ?
void 0 : _a.focus();
}
else {
(_b = utilities_1.getNextElement(document_1.body,
_this._dropDown.current, false, false, true, true)) === null || _b === void 0 ?
void 0 : _b.focus();
}
}
break;
default:
return;
}
}
};
_this._onZoneKeyUp = function (ev) {
var shouldHandleKey = _this._shouldHandleKeyUp(ev);
if (shouldHandleKey && _this.state.isOpen) {
}
};
_this._onDropdownClick = function (ev) {
if (_this.props.onClick) {
_this.props.onClick(ev);
return;
}
}
if (!disabled && !_this._shouldOpenOnFocus()) {
_this.setState({
isOpen: !isOpen,
});
}
_this._isFocusedByClick = false; // reset
};
_this._onDropdownMouseDown = function () {
_this._isFocusedByClick = true;
};
if (!disabled) {
if (_this.props.onFocus) {
_this.props.onFocus(ev);
}
var state = { hasFocus: true };
if (_this._shouldOpenOnFocus()) {
state.isOpen = true;
}
_this.setState(state);
}
};
/**
* Because the isDisabled prop is deprecated, we have had to repeat this
logic all over the place.
* This helper method avoids all the repetition.
*/
_this._isDisabled = function () {
var isDisabled = _this.props.isDisabled;
// Remove this deprecation workaround at 1.0.0
if (disabled === undefined) {
disabled = isDisabled;
}
return disabled;
};
_this._onRenderLabel = function (props) {
var label = props.label, required = props.required, disabled =
props.disabled;
var labelStyles = _this._classNames.subComponentStyles
? _this._classNames.subComponentStyles.label
: undefined;
return label ? (React.createElement(Label_1.Label, { className:
_this._classNames.label, id: _this._labelId, required: required, styles:
labelStyles, disabled: disabled }, label)) : null;
};
var multiSelect = props.multiSelect, selectedKey = props.selectedKey,
selectedKeys = props.selectedKeys, defaultSelectedKey = props.defaultSelectedKey,
defaultSelectedKeys = props.defaultSelectedKeys, options = props.options;
if (false) { var warnNotMultiSelect, warnMultiSelect; }
_this._id = props.id || Utilities_1.getId('Dropdown');
_this._labelId = _this._id + '-label';
_this._listId = _this._id + '-list';
_this._optionId = _this._id + '-option';
_this._hasBeenPositioned = false;
_this._sizePosCache.updateOptions(options);
_this.state = {
isOpen: false,
hasFocus: false,
calloutRenderEdge: undefined,
};
return _this;
}
Object.defineProperty(DropdownInternal.prototype, "selectedOptions", {
/**
*/
get: function () {
var _a = this.props, options = _a.options, selectedIndices =
_a.hoisted.selectedIndices;
return SelectableOption_1.getAllSelectedOptions(options,
selectedIndices);
},
enumerable: false,
configurable: true
});
DropdownInternal.prototype.componentWillUnmount = function () {
clearTimeout(this._scrollIdleTimeoutId);
};
DropdownInternal.prototype.componentDidUpdate = function (prevProps, prevState)
{
if (prevState.isOpen === true && this.state.isOpen === false) {
this._gotMouseMove = false;
this._hasBeenPositioned = false;
if (this.props.onDismiss) {
this.props.onDismiss();
}
}
};
DropdownInternal.prototype.render = function () {
var id = this._id;
var className = props.className, label = props.label, options =
props.options, ariaLabel = props.ariaLabel, required = props.required, errorMessage
= props.errorMessage, propStyles = props.styles, theme = props.theme, panelProps =
props.panelProps, calloutProps = props.calloutProps, _a = props.onRenderTitle,
onRenderTitle = _a === void 0 ? this._getTitle : _a, _b = props.onRenderContainer,
onRenderContainer = _b === void 0 ? this._onRenderContainer : _b, _c =
props.onRenderCaretDown, onRenderCaretDown = _c === void 0 ?
this._onRenderCaretDown : _c, _d = props.onRenderLabel, onRenderLabel = _d === void
0 ? this._onRenderLabel : _d, selectedIndices = props.hoisted.selectedIndices;
var _e = this.state, isOpen = _e.isOpen, calloutRenderEdge =
_e.calloutRenderEdge, hasFocus = _e.hasFocus;
var onRenderPlaceholder = props.onRenderPlaceholder ||
props.onRenderPlaceHolder || this._getPlaceholder;
// If our cached options are out of date update our cache
if (options !== this._sizePosCache.cachedOptions) {
this._sizePosCache.updateOptions(options);
}
var selectedOptions = SelectableOption_1.getAllSelectedOptions(options,
selectedIndices);
var divProps = Utilities_1.getNativeProps(props,
var disabled = this._isDisabled();
var errorMessageId = id + '-errorMessage';
var ariaActiveDescendant = disabled
? undefined
: isOpen && selectedIndices.length === 1 && selectedIndices[0] >= 0
? this._listId + selectedIndices[0]
: undefined;
this._classNames = getClassNames(propStyles, {
theme: theme,
hasError: !!(errorMessage && errorMessage.length > 0),
hasLabel: !!label,
isOpen: isOpen,
required: required,
disabled: disabled,
isRenderingPlaceholder: !selectedOptions.length,
panelClassName: panelProps ? panelProps.className : undefined,
calloutClassName: calloutProps ? calloutProps.className : undefined,
calloutRenderEdge: calloutRenderEdge,
});
var hasErrorMessage = !!errorMessage && errorMessage.length > 0;
return (React.createElement("div", { className: this._classNames.root, ref:
this.props.hoisted.rootRef, "aria-owns": isOpen ? this._listId : undefined },
onRenderLabel(this.props, this._onRenderLabel),
React.createElement("div", tslib_1.__assign({ "data-is-focusable": !
disabled, "data-ktp-target": true, ref: this._dropDown, id: id, tabIndex:
disabled ? -1 : 0, role: "combobox", "aria-haspopup": "listbox", "aria-expanded":
isOpen ? 'true' : 'false', "aria-label": ariaLabel, "aria-labelledby": label && !
ariaLabel ? Utilities_1.mergeAriaAttributeValues(this._labelId, this._optionId) :
undefined, "aria-describedby": hasErrorMessage ? this._id + '-errorMessage' :
undefined, "aria-activedescendant": ariaActiveDescendant, "aria-required":
required, "aria-disabled": disabled, "aria-controls": isOpen ? this._listId :
undefined }, divProps, { className: this._classNames.dropdown, onBlur:
this._onDropdownBlur, onKeyDown: this._onDropdownKeyDown, onKeyUp:
this._onDropdownKeyUp, onClick: this._onDropdownClick, onMouseDown:
this._onDropdownMouseDown, onFocus: this._onFocus }),
React.createElement("span", { id: this._optionId, className:
this._classNames.title, "aria-live": hasFocus ? 'polite' : undefined, "aria-
atomic": hasFocus ? true : undefined, "aria-invalid": hasErrorMessage },
// If option is selected render title, otherwise render the
placeholder text
selectedOptions.length
? onRenderTitle(selectedOptions, this._onRenderTitle)
: onRenderPlaceholder(props, this._onRenderPlaceholder)),
this._classNames.caretDownWrapper }, onRenderCaretDown(props,
this._onRenderCaretDown))),
isOpen && onRenderContainer(tslib_1.__assign(tslib_1.__assign({},
props), { onDismiss: this._onDismiss }), this._onRenderContainer),
hasErrorMessage && (React.createElement("div", { role: "alert", id:
errorMessageId, className: this._classNames.errorMessage }, errorMessage))));
};
DropdownInternal.prototype.focus = function (shouldOpenOnFocus) {
if (this._dropDown.current) {
this._dropDown.current.focus();
if (shouldOpenOnFocus) {
this.setState({
isOpen: true,
});
}
}
};
DropdownInternal.prototype.setSelectedIndex = function (event, index) {
var _a = this.props, options = _a.options, selectedKey = _a.selectedKey,
selectedKeys = _a.selectedKeys, multiSelect = _a.multiSelect, notifyOnReselect =
_a.notifyOnReselect, _b = _a.hoisted.selectedIndices, selectedIndices = _b === void
0 ? [] : _b;
var checked = selectedIndices ? selectedIndices.indexOf(index) > -1 :
false;
var newIndexes = [];
index = Math.max(0, Math.min(options.length - 1, index));
// If this is a controlled component then no state change should take
place.
if (selectedKey !== undefined || selectedKeys !== undefined) {
this._onChange(event, options, index, checked, multiSelect);
return;
}
if (!multiSelect && !notifyOnReselect && index === selectedIndices[0]) {
return;
}
else if (multiSelect) {
newIndexes = selectedIndices ? this._copyArray(selectedIndices) : [];
if (checked) {
var position = newIndexes.indexOf(index);
if (position > -1) {
// unchecked the current one
newIndexes.splice(position, 1);
}
}
else {
// add the new selected index into the existing one
newIndexes.push(index);
}
}
else {
// Set the selected option if this is an uncontrolled component
newIndexes = [index];
}
event.persist();
// Call onChange after state is updated
this.props.hoisted.setSelectedIndices(newIndexes);
this._onChange(event, options, index, checked, multiSelect);
};
DropdownInternal.prototype._copyArray = function (array) {
var newArray = [];
for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
var element = array_1[_i];
newArray.push(element);
}
return newArray;
};
/**
* Finds the next valid Dropdown option and sets the selected index to it.
* @param stepValue - Value of how many items the function should traverse.
Should be -1 or 1.
* @param index - Index of where the search should start
* @param selectedIndex - The selectedIndex Dropdown's state
* @returns The next valid dropdown option's index
*/
DropdownInternal.prototype._moveIndex = function (event, stepValue, index,
selectedIndex) {
var options = this.props.options;
// Return selectedIndex if nothing has changed or options is empty
if (selectedIndex === index || options.length === 0) {
return selectedIndex;
}
// If the user is pressing the up or down key we want to make
// sure that the dropdown cycles through the options without
// causing the screen to scroll. In _onDropdownKeyDown
// at the very end is a check to see if newIndex !== selectedIndex.
// If the index is less than 0 and we set it back to 0, then
// newIndex will equal selectedIndex and not stop the action
// of the key press happening and vice versa for indexes greater
// than or equal to the options length.
if (index >= options.length) {
index = 0;
}
else if (index < 0) {
index = options.length - 1;
}
var stepCounter = 0;
// If current index is a header or divider, or disabled, increment by step
while (options[index].itemType ===
Dropdown_types_1.DropdownMenuItemType.Header ||
options[index].itemType ===
Dropdown_types_1.DropdownMenuItemType.Divider ||
options[index].disabled) {
// If stepCounter exceeds length of options, then return selectedIndex
(-1)
if (stepCounter >= options.length) {
return selectedIndex;
}
// If index + stepValue is out of bounds, wrap around
if (index + stepValue < 0) {
index = options.length;
}
else if (index + stepValue >= options.length) {
index = -1;
}
index = index + stepValue;
stepCounter++;
}
this.setSelectedIndex(event, index);
return index;
};
/** Wrap item list in a FocusZone */
DropdownInternal.prototype._renderFocusableList = function (props) {
var _a = props.onRenderList, onRenderList = _a === void 0 ?
this._onRenderList : _a, label = props.label, ariaLabel = props.ariaLabel,
multiSelect = props.multiSelect;
this._classNames.dropdownItemsWrapper, onKeyDown: this._onZoneKeyDown, onKeyUp:
this._onZoneKeyUp, ref: this._host, tabIndex: 0 },
React.createElement(FocusZone_1.FocusZone, { ref: this._focusZone,
direction: FocusZone_1.FocusZoneDirection.vertical, id: this._listId, className:
this._classNames.dropdownItems, role: "listbox", "aria-label": ariaLabel, "aria-
labelledby": label && !ariaLabel ? this._labelId : undefined, "aria-
multiselectable": multiSelect }, onRenderList(props, this._onRenderList))));
};
DropdownInternal.prototype._renderSeparator = function (item) {
var index = item.index, key = item.key;
var separatorClassName = item.hidden ?
this._classNames.dropdownDividerHidden : this._classNames.dropdownDivider;
if (index > 0) {
return React.createElement("div", { role: "separator", key: key,
className: separatorClassName });
}
return null;
};
DropdownInternal.prototype._renderHeader = function (item) {
var _a = this.props.onRenderOption, onRenderOption = _a === void 0 ?
this._onRenderOption : _a;
var key = item.key, id = item.id;
var headerClassName = item.hidden
? this._classNames.dropdownItemHeaderHidden
: this._classNames.dropdownItemHeader;
return (React.createElement("div", { id: id, key: key, className:
headerClassName }, onRenderOption(item, this._onRenderOption)));
};
DropdownInternal.prototype._onItemMouseEnter = function (item, ev) {
if (this._shouldIgnoreMouseEvent()) {
return;
}
};
DropdownInternal.prototype._onItemMouseMove = function (item, ev) {
this._gotMouseMove = true;
if (!this._isScrollIdle || document.activeElement === targetElement) {
return;
}
};
DropdownInternal.prototype._shouldIgnoreMouseEvent = function () {
return !this._isScrollIdle || !this._gotMouseMove;
};
/**
* Returns true if the key for the event is alt (Mac option) or meta (Mac
command).
*/
DropdownInternal.prototype._isAltOrMeta = function (ev) {
};
/**
* We close the menu on key up only if ALL of the following are true:
* - Most recent key down was alt or meta (command)
* - The alt/meta key down was NOT followed by some other key (such as down/up
arrow to
* expand/collapse the menu)
* - We're not on a Mac (or iOS)
*
* This is because on Windows, pressing alt moves focus to the application menu
bar or similar,
* closing any open context menus. There is not a similar behavior on Macs.
*/
DropdownInternal.prototype._shouldHandleKeyUp = function (ev) {
var keyPressIsAltOrMetaAlone = this._lastKeyDownWasAltOrMeta &&
this._isAltOrMeta(ev);
this._lastKeyDownWasAltOrMeta = false;
return !!keyPressIsAltOrMetaAlone && !(Utilities_1.isMac() ||
Utilities_1.isIOS());
};
/**
* Returns true if dropdown should set to open on focus.
* Otherwise, isOpen state should be toggled on click
*/
DropdownInternal.prototype._shouldOpenOnFocus = function () {
var hasFocus = this.state.hasFocus;
var openOnKeyboardFocus = this.props.openOnKeyboardFocus;
return !this._isFocusedByClick && openOnKeyboardFocus === true && !
hasFocus;
};
DropdownInternal.defaultProps = {
options: [],
};
return DropdownInternal;
//# sourceMappingURL=Dropdown.base.js.map
/***/ }),
/***/ 55259:
"use strict";

exports.Dropdown = void 0;
var Dropdown_base_1 = __webpack_require__(70635);
var Dropdown_styles_1 = __webpack_require__(16596);
exports.Dropdown = Utilities_1.styled(Dropdown_base_1.DropdownBase,
Dropdown_styles_1.getStyles, undefined, {
scope: 'Dropdown',
});
exports.Dropdown.displayName = 'Dropdown';
//# sourceMappingURL=Dropdown.js.map
/***/ }),
/***/ 16596:
"use strict";
var _a, _b, _c;

root: 'ms-Dropdown-container',
label: 'ms-Dropdown-label',
dropdown: 'ms-Dropdown',
title: 'ms-Dropdown-title',
caretDownWrapper: 'ms-Dropdown-caretDownWrapper',
caretDown: 'ms-Dropdown-caretDown',
callout: 'ms-Dropdown-callout',
panel: 'ms-Dropdown-panel',
dropdownItems: 'ms-Dropdown-items',
dropdownItem: 'ms-Dropdown-item',
dropdownDivider: 'ms-Dropdown-divider',
dropdownOptionText: 'ms-Dropdown-optionText',
dropdownItemHeader: 'ms-Dropdown-header',
titleIsPlaceHolder: 'ms-Dropdown-titleIsPlaceHolder',
titleHasError: 'ms-Dropdown-title--hasError',
};
var DROPDOWN_HEIGHT = 32;
var DROPDOWN_ITEM_HEIGHT = 36;
var highContrastAdjustMixin = (_a = {},
_a[Styling_1.HighContrastSelector + ", " +
Styling_1.HighContrastSelectorWhite.replace('@media ', '')] = tslib_1.__assign({},
_a);
var highContrastItemAndTitleStateMixin = {
selectors: tslib_1.__assign((_b = {}, _b[Styling_1.HighContrastSelector] = {
}, _b), highContrastAdjustMixin),
};
var highContrastBorderState = {
},
_c),
};
var MinimumScreenSelector = Styling_1.getScreenSelector(0,
Styling_1.ScreenWidthMinMedium);
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
var theme = props.theme, hasError = props.hasError, hasLabel = props.hasLabel,
className = props.className, isOpen = props.isOpen, disabled = props.disabled,
required = props.required, isRenderingPlaceholder = props.isRenderingPlaceholder,
panelClassName = props.panelClassName, calloutClassName = props.calloutClassName,
calloutRenderEdge = props.calloutRenderEdge;
if (!theme) {
throw new Error('theme is undefined or null in base Dropdown getStyles
function.');
}
var globalClassnames = Styling_1.getGlobalClassNames(GlobalClassNames, theme);
var palette = theme.palette, semanticColors = theme.semanticColors, effects =
theme.effects, fonts = theme.fonts;
var rootHoverFocusActiveSelectorNeutralDarkMixin = {
color: semanticColors.menuItemTextHovered,
};
var rootHoverFocusActiveSelectorNeutralPrimaryMixin = {
color: semanticColors.menuItemText,
};
var borderColorError = {
borderColor: semanticColors.errorText,
};
var dropdownItemStyle = [
globalClassnames.dropdownItem,
{
cursor: 'pointer',
display: 'flex',
padding: '0 8px',
width: '100%',
minHeight: DROPDOWN_ITEM_HEIGHT,
lineHeight: 20,
height: 0,
borderRadius: 0,
textAlign: 'left',
'.ms-Button-flexContainer': {
width: '100%',
},
},
];
var dropdownHeaderStyle = [
globalClassnames.dropdownItemHeader,
tslib_1.__assign(tslib_1.__assign({}, fonts.medium), { fontWeight:
Styling_1.FontWeights.semibold, color: semanticColors.menuHeader, background:
'none', backgroundColor: 'transparent', border: 'none', height:
DROPDOWN_ITEM_HEIGHT, lineHeight: DROPDOWN_ITEM_HEIGHT, cursor: 'default', padding:
'0 8px', userSelect: 'none', textAlign: 'left', selectors: (_a = {},
_a) }),
];
var selectedItemBackgroundColor = semanticColors.menuItemBackgroundPressed;
var itemSelectors = function (isSelected) {
var _a;
if (isSelected === void 0) { isSelected = false; }
return {
selectors: (_a = {
'&:hover:focus': [
{
backgroundColor: !isSelected ?
semanticColors.menuItemBackgroundHovered : selectedItemBackgroundColor,
},
highContrastItemAndTitleStateMixin,
],
'&:focus': [
{
backgroundColor: !isSelected ? 'transparent' :
selectedItemBackgroundColor,
},
],
'&:active': [
{
backgroundColor: !isSelected ?
semanticColors.menuBackground : semanticColors.menuItemBackgroundHovered,
},
]
},
_a["." + Utilities_1.IsFocusVisibleClassName + " &:focus:after"] =
{
left: 0,
top: 0,
bottom: 0,
right: 0,
},
border: 'none',
},
_a),
};
};
var dropdownItemSelected = tslib_1.__spreadArray(tslib_1.__spreadArray([],
dropdownItemStyle), [
{
backgroundColor: selectedItemBackgroundColor,
},
itemSelectors(true),
]);
var dropdownItemDisabled = tslib_1.__spreadArray(tslib_1.__spreadArray([],
dropdownItemStyle), [
{
cursor: 'default',
color: 'GrayText',
border: 'none',
},
_b),
},
]);
var titleOpenBorderRadius = calloutRenderEdge ===
Positioning_1.RectangleEdge.bottom
? effects.roundedCorner2 + " " + effects.roundedCorner2 + " 0 0"
: "0 0 " + effects.roundedCorner2 + " " + effects.roundedCorner2;
var calloutOpenBorderRadius = calloutRenderEdge ===
Positioning_1.RectangleEdge.bottom
? "0 0 " + effects.roundedCorner2 + " " + effects.roundedCorner2
: effects.roundedCorner2 + " " + effects.roundedCorner2 + " 0 0";
return {
root: [globalClassnames.root, className],
label: globalClassnames.label,
dropdown: [
globalClassnames.dropdown,
Styling_1.normalize,
fonts.medium,
{
borderColor: semanticColors.focusBorder,
outline: 0,
userSelect: 'none',
_c['&:hover .' + globalClassnames.title] = [
!disabled && rootHoverFocusActiveSelectorNeutralDarkMixin,
{ borderColor: isOpen ? palette.neutralSecondary :
palette.neutralPrimary },
highContrastBorderState,
],
_c['&:focus .' + globalClassnames.title] = [
{ selectors: (_d = {}, _d[Styling_1.HighContrastSelector] =
{ color: 'Highlight' }, _d) },
],
_c['&:focus:after'] = [
{
content: "''",
top: '0px',
left: '0px',
width: '100%',
height: '100%',
// see https://github.com/microsoft/fluentui/pull/9182
for semantic color disc
border: !disabled ? "2px solid " + palette.themePrimary
: 'none',
color: 'Highlight',
},
_e),
},
],
_c['&:active .' + globalClassnames.title] = [
{ borderColor: palette.themePrimary },
highContrastBorderState,
],
_c['&:hover .' + globalClassnames.caretDown] = !disabled &&
rootHoverFocusActiveSelectorNeutralPrimaryMixin,
_c['&:focus .' + globalClassnames.caretDown] = [
!disabled &&
{ selectors: (_f = {}, _f[Styling_1.HighContrastSelector] =
{ color: 'Highlight' }, _f) },
],
_c['&:active .' + globalClassnames.caretDown] = !disabled &&
_c['&:hover .' + globalClassnames.titleIsPlaceHolder] = !
disabled && rootHoverFocusActiveSelectorNeutralPrimaryMixin,
_c['&:focus .' + globalClassnames.titleIsPlaceHolder] = !
_c['&:active .' + globalClassnames.titleIsPlaceHolder] = !
_c['&:hover .' + globalClassnames.titleHasError] =
borderColorError,
_c['&:active .' + globalClassnames.titleHasError] =
borderColorError,
_c),
},
isOpen && 'is-open',
required && 'is-required',
required &&
!hasLabel && {
selectors: (_g = {
':before': {
content: "'*'",
top: -5,
right: -10,
}
},
selectors: {
':after': {
right: -14, // moving the * 4 pixel to right to
alleviate border clipping in HC mode.
},
},
},
_g),
},
],
title: [
globalClassnames.title,
{
borderWidth: 1,
borderColor: semanticColors.inputBorder,
borderRadius: isOpen ? titleOpenBorderRadius :
effects.roundedCorner2,
cursor: 'pointer',
display: 'block',
height: DROPDOWN_HEIGHT,
lineHeight: DROPDOWN_HEIGHT - 2,
padding: "0 28px 0 8px",
overflow: 'hidden',
},
isRenderingPlaceholder && [globalClassnames.titleIsPlaceHolder,
{ color: semanticColors.inputPlaceholderText }],
hasError && [globalClassnames.titleHasError, borderColorError],
disabled && {
border: 'none',
cursor: 'default',
_h[Styling_1.HighContrastSelector] = tslib_1.__assign({ border:
'1px solid GrayText', color: 'GrayText', backgroundColor: 'Window' },
_h),
},
],
caretDownWrapper: [
globalClassnames.caretDownWrapper,
{
height: DROPDOWN_HEIGHT,
lineHeight: DROPDOWN_HEIGHT - 2,
paddingTop: 1,
right: 8,
top: 0,
},
!disabled && {
cursor: 'pointer',
},
],
caretDown: [
globalClassnames.caretDown,
{ color: palette.neutralSecondary, fontSize: fonts.small.fontSize,
pointerEvents: 'none' },
disabled && {
_j[Styling_1.HighContrastSelector] = tslib_1.__assign({ color:
_j),
},
],
errorMessage: tslib_1.__assign(tslib_1.__assign({ color:
semanticColors.errorText }, theme.fonts.small), { paddingTop: 5 }),
callout: [
globalClassnames.callout,
{
borderRadius: calloutOpenBorderRadius,
_k['.ms-Callout-main'] = { borderRadius:
calloutOpenBorderRadius },
_k),
},
calloutClassName,
],
dropdownItemsWrapper: { selectors: { '&:focus': { outline: 0 } } },
dropdownItems: [globalClassnames.dropdownItems, { display: 'block' }],
dropdownItem: tslib_1.__spreadArray(tslib_1.__spreadArray([],
dropdownItemStyle), [itemSelectors()]),
dropdownItemSelected: dropdownItemSelected,
dropdownItemDisabled: dropdownItemDisabled,
dropdownItemSelectedAndDisabled: [dropdownItemSelected,
dropdownItemDisabled, { backgroundColor: 'transparent' }],
dropdownItemHidden: tslib_1.__spreadArray(tslib_1.__spreadArray([],
dropdownItemStyle), [{ display: 'none' }]),
dropdownDivider: [globalClassnames.dropdownDivider, { height: 1,
backgroundColor: semanticColors.bodyDivider }],
dropdownDividerHidden: [globalClassnames.dropdownDivider, { display: 'none'
}],
dropdownOptionText: [
globalClassnames.dropdownOptionText,
{
overflow: 'hidden',
minWidth: 0,
maxWidth: '100%',
margin: '1px',
},
],
dropdownItemHeader: dropdownHeaderStyle,
dropdownItemHeaderHidden: tslib_1.__spreadArray(tslib_1.__spreadArray([],
dropdownHeaderStyle), [{ display: 'none' }]),
label: { root: { display: 'inline-block' } },
multiSelectItem: {
root: {
padding: 0,
},
label: {
alignSelf: 'stretch',
padding: '0 8px',
width: '100%',
},
input: {
_l["." + Utilities_1.IsFocusVisibleClassName + " &:focus +
label::before"] = {
outlineOffset: '0px',
},
_l),
},
},
panel: {
root: [panelClassName],
main: {
// In case of extra small screen sizes
_m[MinimumScreenSelector] = {
// panelWidth xs
width: 272,
},
_m),
},
contentInner: { padding: '0 0 20px' },
},
},
};
};
//# sourceMappingURL=Dropdown.styles.js.map
/***/ }),
/***/ 82425:
"use strict";

exports.DropdownMenuItemType = void 0;
Object.defineProperty(exports, "DropdownMenuItemType", ({ enumerable: true, get:
function () { return SelectableOption_1.SelectableOptionMenuItemType; } }));
//# sourceMappingURL=Dropdown.types.js.map
/***/ }),
/***/ 59998:
"use strict";

/***/ }),
/***/ 94390:
"use strict";

exports.DropdownSizePosCache = void 0;
var Dropdown_types_1 = __webpack_require__(82425);
/**
* A utility class to cache size and position in cache.
*
* Dropdown options has non-selectable display types. It is therefore not cheap to
determine
* the total number of actual selectable options as well as the position an option
is in the
* list of options - O(n) cost for each lookup.
*
* Given that we potentially have to make this determination on every single render
pass, this
* cache should provide a little bit of relief.
*/
var DropdownSizePosCache = /** @class */ (function () {
function DropdownSizePosCache() {
this._size = 0;
}
/**
* Invalidates the cache and recalculate the size of selectable options.
*/
DropdownSizePosCache.prototype.updateOptions = function (options) {
var displayOnlyOptionsCache = [];
var size = 0;
for (var i = 0; i < options.length; i++) {
if (options[i].itemType ===
Dropdown_types_1.DropdownMenuItemType.Divider || options[i].itemType ===
Dropdown_types_1.DropdownMenuItemType.Header) {
displayOnlyOptionsCache.push(i);
}
else if (!options[i].hidden) {
size++;
}
}
this._size = size;
this._displayOnlyOptionsCache = displayOnlyOptionsCache;
this._cachedOptions = tslib_1.__spreadArray([], options);
};
Object.defineProperty(DropdownSizePosCache.prototype, "optionSetSize", {
/**
* The size of all the selectable options.
*/
get: function () {
return this._size;
},
enumerable: false,
configurable: true
});
Object.defineProperty(DropdownSizePosCache.prototype, "cachedOptions", {
/**
* The chached options array.
*/
get: function () {
return this._cachedOptions;
},
enumerable: false,
configurable: true
});
/**
* Returns the position of this option element relative to the full set of
selectable option elements.
* Note: the first selectable element is position 1 in the set.
* @param index The raw index of the option element.
*/
DropdownSizePosCache.prototype.positionInSet = function (index) {
if (index === undefined) {
return undefined;
}
// we could possibly memoize this too but this should be good enough, most
of the time (the expectation is that
// when you have a lot of options, the selectable options will heavily
dominate over the non-selectable options.
var offset = 0;
while (index > this._displayOnlyOptionsCache[offset]) {
offset++;
}
if (this._displayOnlyOptionsCache[offset] === index) {
throw new Error("Unexpected: Option at index " + index + " is not a
selectable element.");
}
return index - offset + 1;
};
return DropdownSizePosCache;
}());
exports.DropdownSizePosCache = DropdownSizePosCache;
//# sourceMappingURL=DropdownSizePosCache.js.map
/***/ }),
/***/ 28029:
"use strict";

exports.BaseExtendedPicker = void 0;
var Autofill_1 = __webpack_require__(98515);
var stylesImport = __webpack_require__(98490);
var styles = stylesImport;
var BaseExtendedPicker = /** @class */ (function (_super) {
tslib_1.__extends(BaseExtendedPicker, _super);
function BaseExtendedPicker(basePickerProps) {
var _this = _super.call(this, basePickerProps) || this;
_this.floatingPicker = React.createRef();
_this.selectedItemsList = React.createRef();
_this.root = React.createRef();
_this.input = React.createRef();
_this.onSelectionChange = function () {
};
_this.onInputChange = function (value, composing) {
// We don't want to update the picker's suggestions when the input is
still being composed
if (!composing) {
_this.setState({ queryString: value });
if (_this.floatingPicker.current) {
_this.floatingPicker.current.onQueryStringChanged(value);
}
}
};
_this.onInputFocus = function (ev) {
if (_this.selectedItemsList.current) {
_this.selectedItemsList.current.unselectAll();
}
if (_this.props.inputProps && _this.props.inputProps.onFocus) {
_this.props.inputProps.onFocus(ev);
}
};
_this.onInputClick = function (ev) {
_this.selectedItemsList.current.unselectAll();
}
if (_this.floatingPicker.current && _this.inputElement) {
// Update the value if the input value is empty or is different
than the current inputText from the floatingPicker
var shoudUpdateValue = _this.inputElement.value === '' ||
_this.inputElement.value !== _this.floatingPicker.current.inputText;
_this.floatingPicker.current.showPicker(shoudUpdateValue);
}
};
// This is protected because we may expect the backspace key to work
differently in a different kind of picker.
// This lets the subclass override it and provide it's own onBackspace. For
an example see the BasePickerListBelow
_this.onBackspace = function (ev) {
if (ev.which !== Utilities_1.KeyCodes.backspace) {
return;
}
if (_this.selectedItemsList.current && _this.items.length) {
if (_this.input.current &&
!_this.input.current.isValueSelected &&
_this.input.current.inputElement ===
ev.currentTarget.ownerDocument.activeElement &&
_this.input.current.cursorLocation === 0) {
_this.floatingPicker.current.hidePicker();
}
_this.selectedItemsList.current.removeItemAt(_this.items.length
- 1);
_this._onSelectedItemsChanged();
}
else if (_this.selectedItemsList.current.hasSelectedItems()) {
_this.floatingPicker.current.hidePicker();
}
_this.selectedItemsList.current.removeSelectedItems();
_this._onSelectedItemsChanged();
}
}
};
_this.onCopy = function (ev) {
// Pass it down into the selected items list
_this.selectedItemsList.current.onCopy(ev);
}
};
_this.onPaste = function (ev) {
if (_this.props.onPaste) {
var inputText = ev.clipboardData.getData('Text');
_this.props.onPaste(inputText);
}
};
_this._onSuggestionSelected = function (item) {
var currentRenderedQueryString =
_this.props.currentRenderedQueryString;
var queryString = _this.state.queryString;
if (currentRenderedQueryString === undefined ||
currentRenderedQueryString === queryString) {
var processedItem = _this.props.onItemSelected
? _this.props.onItemSelected(item)
: item;
if (processedItem === null) {
return;
}
var processedItemObject = processedItem;
var processedItemPromiseLike = processedItem;
var newItem_1;
if (processedItemPromiseLike && processedItemPromiseLike.then) {
processedItemPromiseLike.then(function (resolvedProcessedItem)
{
newItem_1 = resolvedProcessedItem;
_this._addProcessedItem(newItem_1);
});
}
else {
newItem_1 = processedItemObject;
_this._addProcessedItem(newItem_1);
}
}
};
_this._onSelectedItemsChanged = function () {
_this.focus();
};
/**
* The floating picker is the source of truth for if the menu has been
opened or not.
*
* Because this isn't tracked inside the state of this component, we need
to
* force an update here to keep the rendered output that depends on the
picker being open
* in sync with the state
*
* Called when the suggestions is shown or closed
*/
_this._onSuggestionsShownOrHidden = function () {
};
_this.selection = new Selection_1.Selection({ onSelectionChanged: function
() { return _this.onSelectionChange(); } });
_this.state = {
queryString: '',
};
return _this;
}
Object.defineProperty(BaseExtendedPicker.prototype, "items", {
get: function () {
var _a, _b, _c, _d;
return (_d = (_c = (_a = this.props.selectedItems) !== null && _a !==
void 0 ? _a : (_b = this.selectedItemsList.current) === null || _b === void 0 ?
void 0 : _b.items) !== null && _c !== void 0 ? _c :
this.props.defaultSelectedItems) !== null && _d !== void 0 ? _d : null;
},
enumerable: false,
configurable: true
});
BaseExtendedPicker.prototype.componentDidMount = function () {
this.forceUpdate();
};
BaseExtendedPicker.prototype.focus = function () {
if (this.input.current) {
this.input.current.focus();
}
};
BaseExtendedPicker.prototype.clearInput = function () {
this.input.current.clear();
}
};
Object.defineProperty(BaseExtendedPicker.prototype, "inputElement", {
get: function () {
return this.input.current && this.input.current.inputElement;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseExtendedPicker.prototype, "highlightedItems", {
get: function () {
return this.selectedItemsList.current ?
this.selectedItemsList.current.highlightedItems() : [];
},
enumerable: false,
configurable: true
});
BaseExtendedPicker.prototype.render = function () {
var _a = this.props, className = _a.className, inputProps = _a.inputProps,
disabled = _a.disabled, focusZoneProps = _a.focusZoneProps;
var activeDescendant = this.floatingPicker.current &&
this.floatingPicker.current.currentSelectedSuggestionIndex !== -1
? 'sug-' + this.floatingPicker.current.currentSelectedSuggestionIndex
: undefined;
var isExpanded = this.floatingPicker.current ?
this.floatingPicker.current.isSuggestionsShown : false;
return (React.createElement("div", { ref: this.root, className:
Utilities_1.css('ms-BasePicker ms-BaseExtendedPicker', className ? className : ''),
onKeyDown: this.onBackspace, onCopy: this.onCopy },
React.createElement(FocusZone_1.FocusZone,
tslib_1.__assign({ direction: FocusZone_1.FocusZoneDirection.bidirectional },
focusZoneProps),
React.createElement(Selection_1.SelectionZone, { selection:
this.selection, selectionMode: Selection_1.SelectionMode.multiple },
React.createElement("div", { className: Utilities_1.css('ms-
BasePicker-text', styles.pickerText), role: 'list' },
this.props.headerComponent,
this.renderSelectedItemsList(),
this.canAddItems() &&
(React.createElement(Autofill_1.Autofill, tslib_1.__assign({}, inputProps,
{ className: Utilities_1.css('ms-BasePicker-input', styles.pickerInput), ref:
this.input, onFocus: this.onInputFocus, onClick: this.onInputClick,
onInputValueChange: this.onInputChange, "aria-activedescendant": activeDescendant,
"aria-owns": isExpanded ? 'suggestion-list' : undefined, "aria-expanded":
isExpanded, "aria-haspopup": "true", role: "combobox", disabled: disabled, onPaste:
this.onPaste })))))),
this.renderFloatingPicker()));
};
Object.defineProperty(BaseExtendedPicker.prototype, "floatingPickerProps", {
get: function () {
return this.props.floatingPickerProps;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseExtendedPicker.prototype, "selectedItemsListProps", {
get: function () {
return this.props.selectedItemsListProps;
},
enumerable: false,
configurable: true
});
BaseExtendedPicker.prototype.canAddItems = function () {
var itemLimit = this.props.itemLimit;
return itemLimit === undefined || this.items.length < itemLimit;
};
BaseExtendedPicker.prototype.renderFloatingPicker = function () {
var FloatingPicker = this.props.onRenderFloatingPicker;
return (React.createElement(FloatingPicker,
tslib_1.__assign({ componentRef: this.floatingPicker, onChange:
this._onSuggestionSelected, onSuggestionsHidden: this._onSuggestionsShownOrHidden,
onSuggestionsShown: this._onSuggestionsShownOrHidden, inputElement:
this.input.current ? this.input.current.inputElement : undefined, selectedItems:
this.items, suggestionItems: this.props.suggestionItems ?
this.props.suggestionItems : undefined }, this.floatingPickerProps)));
};
BaseExtendedPicker.prototype.renderSelectedItemsList = function () {
var SelectedItems = this.props.onRenderSelectedItems;
return (React.createElement(SelectedItems, tslib_1.__assign({ componentRef:
this.selectedItemsList, selection: this.selection, selectedItems:
this.props.selectedItems ? this.props.selectedItems : undefined, onItemsDeleted:
this.props.selectedItems ? this.props.onItemsRemoved : undefined },
this.selectedItemsListProps)));
};
BaseExtendedPicker.prototype._addProcessedItem = function (newItem) {
// If this is a controlled component, call the on item selected callback
// Otherwise add it to the selectedItemsList
if (this.props.onItemAdded) {
this.props.onItemAdded(newItem);
}
if (this.selectedItemsList.current) {
this.selectedItemsList.current.addItems([newItem]);
}
this.input.current.clear();
}
if (this.floatingPicker.current) {
this.floatingPicker.current.hidePicker();
}
this.focus();
};
return BaseExtendedPicker;
exports.BaseExtendedPicker = BaseExtendedPicker;
//# sourceMappingURL=BaseExtendedPicker.js.map
/***/ }),
/***/ 98490:
"use strict";

exports.pickerInput = exports.pickerText = void 0;
/* eslint-disable */
var load_themed_styles_1 = __webpack_require__(38660);
load_themed_styles_1.loadStyles([{ "rawString": ".pickerText_9f838726{display:-
webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-
webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-
sizing:border-box;box-sizing:border-box;border:1px solid " }, { "theme":
"neutralTertiary", "defaultValue": "#a19f9d" }, { "rawString": ";min-
width:180px;padding:1px;min-height:32px}.pickerText_9f838726:hover{border-
color:" }, { "theme": "themeLight", "defaultValue": "#c7e0f4" }, { "rawString":
"}.pickerInput_9f838726{height:34px;border:none;-webkit-box-flex:1;-ms-flex-
positive:1;flex-grow:1;outline:0;padding:0 6px
0;margin:1px}.pickerInput_9f838726::-ms-clear{display:none}" }]);
exports.pickerText = "pickerText_9f838726";
exports.pickerInput = "pickerInput_9f838726";
//# sourceMappingURL=BaseExtendedPicker.scss.js.map
/***/ }),
/***/ 55128:
"use strict";

//# sourceMappingURL=BaseExtendedPicker.types.js.map
/***/ }),
/***/ 3828:
"use strict";

exports.ExtendedPeoplePicker = exports.BaseExtendedPeoplePicker = void 0;
var BaseExtendedPicker_1 = __webpack_require__(28029);
/**
* {@docCategory ExtendedPeoplePicker}
*/
var BaseExtendedPeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(BaseExtendedPeoplePicker, _super);
function BaseExtendedPeoplePicker() {
}
return BaseExtendedPeoplePicker;
}(BaseExtendedPicker_1.BaseExtendedPicker));
exports.BaseExtendedPeoplePicker = BaseExtendedPeoplePicker;
/**
* {@docCategory ExtendedPeoplePicker}
*/
var ExtendedPeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(ExtendedPeoplePicker, _super);
function ExtendedPeoplePicker() {
}
return ExtendedPeoplePicker;
}(BaseExtendedPeoplePicker));
exports.ExtendedPeoplePicker = ExtendedPeoplePicker;
//# sourceMappingURL=ExtendedPeoplePicker.js.map
/***/ }),
/***/ 72973:
"use strict";

exports.peoplePickerPersonaContent = exports.peoplePicker =
exports.peoplePickerPersona = exports.resultItem = exports.resultContent = void 0;
load_themed_styles_1.loadStyles([{ "rawString":
".resultContent_4cc31f3f{display:table-
row}.resultContent_4cc31f3f .resultItem_4cc31f3f{display:table-cell;vertical-
align:bottom}.peoplePickerPersona_4cc31f3f{width:180px}.peoplePickerPersona_4cc31f3
f .ms-Persona-details{width:100%}.peoplePicker_4cc31f3f .ms-BasePicker-text{min-
height:40px}.peoplePickerPersonaContent_4cc31f3f{display:-webkit-box;display:-ms-
flexbox;display:flex;width:100%;-webkit-box-pack:justify;-ms-flex-
pack:justify;justify-content:space-between;-webkit-box-align:center;-ms-flex-
align:center;align-items:center}" }]);
exports.resultContent = "resultContent_4cc31f3f";
exports.resultItem = "resultItem_4cc31f3f";
exports.peoplePickerPersona = "peoplePickerPersona_4cc31f3f";
exports.peoplePicker = "peoplePicker_4cc31f3f";
exports.peoplePickerPersonaContent = "peoplePickerPersonaContent_4cc31f3f";
//# sourceMappingURL=ExtendedPeoplePicker.scss.js.map
/***/ }),
/***/ 51124:
"use strict";

/***/ }),
/***/ 48819:
"use strict";

exports.FabricBase = void 0;
var getFabricTheme = Utilities_1.memoizeFunction(function (theme, isRTL) { return
Styling_1.createTheme(tslib_1.__assign(tslib_1.__assign({}, theme), { rtl:
isRTL })); });
var getDir = function (_a) {
var theme = _a.theme, dir = _a.dir;
var contextDir = Utilities_1.getRTL(theme) ? 'rtl' : 'ltr';
var pageDir = Utilities_1.getRTL() ? 'rtl' : 'ltr';
var componentDir = dir ? dir : contextDir;
return {
// If Fabric dir !== contextDir
// Or If contextDir !== pageDir
// Then we need to set dir of the Fabric root
rootDir: componentDir !== contextDir || componentDir !== pageDir ?
componentDir : dir,
// If dir !== contextDir || pageDir
// then set contextual theme around content
needsTheme: componentDir !== contextDir,
};
};
exports.FabricBase = React.forwardRef(function (props, ref) {
var className = props.className, theme = props.theme, applyTheme =
props.applyTheme, applyThemeToBody = props.applyThemeToBody, styles = props.styles;
theme: theme,
applyTheme: applyTheme,
});
var rootElement = React.useRef(null);
useApplyThemeToBody(applyThemeToBody, classNames, rootElement);
Utilities_1.useFocusRects(rootElement);
return React.createElement(React.Fragment, null, useRenderedContent(props,
classNames, rootElement, ref));
});
exports.FabricBase.displayName = 'FabricBase';
function useRenderedContent(props, _a, rootElement, ref) {
var root = _a.root;
var _b = props.as, Root = _b === void 0 ? 'div' : _b, dir = props.dir, theme =
props.theme;
var divProps = Utilities_1.getNativeProps(props, Utilities_1.divProperties,
['dir']);
var _c = getDir(props), rootDir = _c.rootDir, needsTheme = _c.needsTheme;
var renderedContent = React.createElement(Root, tslib_1.__assign({ dir: rootDir
}, divProps, { className: root, ref: react_hooks_1.useMergedRefs(rootElement,
ref) }));
// Create the contextual theme if component direction does not match parent
direction.
if (needsTheme) {
// Disabling ThemeProvider here because theme doesn't need to be re-
provided by ThemeProvider if dir has changed.
renderedContent = (
React.createElement(Utilities_1.Customizer, { settings: { theme:
getFabricTheme(theme, dir === 'rtl') } }, renderedContent));
}
return renderedContent;
}
function useApplyThemeToBody(applyThemeToBody, _a, rootElement) {
var bodyThemed = _a.bodyThemed;
if (applyThemeToBody) {
var currentDoc_1 = Utilities_1.getDocument(rootElement.current);
if (currentDoc_1) {
currentDoc_1.body.classList.add(bodyThemed);
currentDoc_1.body.classList.remove(bodyThemed);
};
}
}
}, [bodyThemed, applyThemeToBody, rootElement]);
return rootElement;
}
//# sourceMappingURL=Fabric.base.js.map
/***/ }),
/***/ 43728:
"use strict";

exports.Fabric = void 0;
var Fabric_base_1 = __webpack_require__(48819);
var Fabric_styles_1 = __webpack_require__(62817);
/**
* @deprecated This component is deprecated as of `@fluentui/react` version 8. Use
`ThemeProvider` instead.
*/
exports.Fabric = Utilities_1.styled(Fabric_base_1.FabricBase,
Fabric_styles_1.getStyles, undefined, {
scope: 'Fabric',
});
//# sourceMappingURL=Fabric.js.map
/***/ }),
/***/ 62817:
"use strict";

var inheritFont = { fontFamily: 'inherit' };
root: 'ms-Fabric',
bodyThemed: 'ms-Fabric-bodyThemed',
};
var theme = props.theme, className = props.className, applyTheme =
props.applyTheme;
return {
root: [
classNames.root,
theme.fonts.medium,
{
selectors: {
'& button': inheritFont,
'& input': inheritFont,
'& textarea': inheritFont,
},
},
// apply theme to only if applyTheme is true
applyTheme && {
backgroundColor: theme.semanticColors.bodyBackground,
},
className,
],
bodyThemed: [
{
backgroundColor: theme.semanticColors.bodyBackground,
},
],
};
};
//# sourceMappingURL=Fabric.styles.js.map
/***/ }),
/***/ 28990:
"use strict";

//# sourceMappingURL=Fabric.types.js.map
/***/ }),
/***/ 29966:
"use strict";

/***/ }),
/***/ 71671:
"use strict";

exports.FacepileBase = void 0;
var Facepile_types_1 = __webpack_require__(19475);
var FacepileButton_1 = __webpack_require__(69518);
/**
* FacePile with no default styles.
* [Use the `styles` API to add your own
styles.](https://github.com/microsoft/fluentui/wiki/Component-Styling)
*/
var FacepileBase = /** @class */ (function (_super) {
tslib_1.__extends(FacepileBase, _super);
function FacepileBase(props) {
_this._classNames = getClassNames(_this.props.styles, {
theme: _this.props.theme,
className: _this.props.className,
});
_this._getPersonaControl = function (persona) {
var _a = _this.props, getPersonaProps = _a.getPersonaProps, personaSize
= _a.personaSize;
var personaStyles = {
details: {
flex: '1 0 auto',
},
};
return (React.createElement(Persona_1.Persona,
tslib_1.__assign({ imageInitials: persona.imageInitials, imageUrl:
persona.imageUrl, initialsColor: persona.initialsColor, allowPhoneInitials:
persona.allowPhoneInitials, text: persona.personaName, size: personaSize },
(getPersonaProps ? getPersonaProps(persona) : null), { styles: personaStyles })));
};
_this._getPersonaCoinControl = function (persona) {
var _a = _this.props, getPersonaProps = _a.getPersonaProps, personaSize
= _a.personaSize;
return (React.createElement(PersonaCoin_1.PersonaCoin,
tslib_1.__assign({ imageInitials: persona.imageInitials, imageUrl:
persona.imageUrl, initialsColor: persona.initialsColor, allowPhoneInitials:
persona.allowPhoneInitials, text: persona.personaName, size: personaSize },
(getPersonaProps ? getPersonaProps(persona) : null))));
};
_this._ariaDescriptionId = Utilities_1.getId();
return _this;
}
FacepileBase.prototype.render = function () {
var overflowButtonProps = this.props.overflowButtonProps;
var _a = this.props, chevronButtonProps = _a.chevronButtonProps, // eslint-
disable-line deprecation/deprecation
maxDisplayablePersonas = _a.maxDisplayablePersonas, personas = _a.personas,
overflowPersonas = _a.overflowPersonas, showAddButton = _a.showAddButton, ariaLabel
= _a.ariaLabel, _b = _a.showTooltip, showTooltip = _b === void 0 ? true : _b;
var _classNames = this._classNames;
// Add a check to make sure maxDisplayalePersonas is defined to cover the
edge case of it being 0.
var numPersonasToShow = typeof maxDisplayablePersonas === 'number' ?
Math.min(personas.length, maxDisplayablePersonas) : personas.length;
// Added for deprecating chevronButtonProps. Can remove after v1.0
if (chevronButtonProps && !overflowButtonProps) {
overflowButtonProps = chevronButtonProps;
}
var hasOverflowPersonas = overflowPersonas && overflowPersonas.length > 0;
var personasPrimary = hasOverflowPersonas ? personas : personas.slice(0,
numPersonasToShow);
var personasOverflow = (hasOverflowPersonas ? overflowPersonas :
personas.slice(numPersonasToShow)) || [];
return (React.createElement("div", { className: _classNames.root },
this.onRenderAriaDescription(),
React.createElement("div", { className: _classNames.itemContainer },
showAddButton ? this._getAddNewElement() : null,
React.createElement("ul", { className: _classNames.members, "aria-
label": ariaLabel }, this._onRenderVisiblePersonas(personasPrimary,
personasOverflow.length === 0 && personas.length === 1, showTooltip)),
overflowButtonProps ? this._getOverflowElement(personasOverflow) :
null)));
};
FacepileBase.prototype.onRenderAriaDescription = function () {
var ariaDescription = this.props.ariaDescription;
ariaDescriptionSpan,
// otherwise it will be assigned to descriptionSpan.
return (ariaDescription && (React.createElement("span", { className:
_classNames.screenReaderOnly, id: this._ariaDescriptionId }, ariaDescription)));
};
FacepileBase.prototype._onRenderVisiblePersonas = function (personas,
singlePersona, showTooltip) {
var _this = this;
var _a = this.props, _b = _a.onRenderPersona, onRenderPersona = _b === void
0 ? this._getPersonaControl : _b, _c = _a.onRenderPersonaCoin, onRenderPersonaCoin
= _c === void 0 ? this._getPersonaCoinControl : _c, onRenderPersonaWrapper =
_a.onRenderPersonaWrapper;
return personas.map(function (persona, index) {
var personaControl = singlePersona
? onRenderPersona(persona, _this._getPersonaControl)
: onRenderPersonaCoin(persona, _this._getPersonaCoinControl);
var defaultPersonaRender = persona.onClick
? function () { return
_this._getElementWithOnClickEvent(personaControl, persona, showTooltip, index); }
: function () { return
_this._getElementWithoutOnClickEvent(personaControl, persona, showTooltip,
index); };
return (React.createElement("li", { key: (singlePersona ? 'persona' :
'personaCoin') + "-" + index, className: _this._classNames.member },
onRenderPersonaWrapper ? onRenderPersonaWrapper(persona, defaultPersonaRender) :
defaultPersonaRender()));
});
};
FacepileBase.prototype._getElementWithOnClickEvent = function (personaControl,
persona, showTooltip, index) {
var keytipProps = persona.keytipProps;
return (React.createElement(FacepileButton_1.FacepileButton,
tslib_1.__assign({}, Utilities_1.getNativeProps(persona,
Utilities_1.buttonProperties), this._getElementProps(persona, showTooltip, index),
{ keytipProps: keytipProps,
onClick: this._onPersonaClick.bind(this, persona) }), personaControl));
};
FacepileBase.prototype._getElementWithoutOnClickEvent = function
(personaControl, persona, showTooltip, index) {
return (React.createElement("div", tslib_1.__assign({},
Utilities_1.getNativeProps(persona, Utilities_1.buttonProperties),
this._getElementProps(persona, showTooltip, index)), personaControl));
};
FacepileBase.prototype._getElementProps = function (persona, showTooltip,
index) {
return {
key: (persona.imageUrl ? 'i' : '') + index,
className: _classNames.itemButton,
title: showTooltip ? persona.personaName : undefined,
onMouseMove: this._onPersonaMouseMove.bind(this, persona),
onMouseOut: this._onPersonaMouseOut.bind(this, persona),
};
};
FacepileBase.prototype._getOverflowElement = function (personasOverflow) {
switch (this.props.overflowButtonType) {
case Facepile_types_1.OverflowButtonType.descriptive:
return this._getDescriptiveOverflowElement(personasOverflow);
case Facepile_types_1.OverflowButtonType.downArrow:
return this._getIconElement('ChevronDown');
case Facepile_types_1.OverflowButtonType.more:
return this._getIconElement('More');
default:
return null;
}
};
FacepileBase.prototype._getDescriptiveOverflowElement = function
(personasOverflow) {
var personaSize = this.props.personaSize;
if (!personasOverflow || personasOverflow.length < 1) {
return null;
}
var personaNames = personasOverflow.map(function (p) { return
p.personaName; }).join(', ');
var overflowButtonProps = tslib_1.__assign({ title: personaNames },
this.props.overflowButtonProps);
var numPersonasNotPictured = Math.max(personasOverflow.length, 0);
tslib_1.__assign({}, overflowButtonProps, { ariaDescription:
overflowButtonProps.title, className: _classNames.descriptiveOverflowButton }),
React.createElement(PersonaCoin_1.PersonaCoin, { size: personaSize,
onRenderInitials: this._renderInitialsNotPictured(numPersonasNotPictured),
initialsColor: PersonaCoin_1.PersonaInitialsColor.transparent })));
};
FacepileBase.prototype._getIconElement = function (icon) {
var _a = this.props, overflowButtonProps = _a.overflowButtonProps,
personaSize = _a.personaSize;
var overflowInitialsIcon = true;
tslib_1.__assign({}, overflowButtonProps, { className:
_classNames.overflowButton }),
onRenderInitials: this._renderInitials(icon, overflowInitialsIcon), initialsColor:
PersonaCoin_1.PersonaInitialsColor.transparent })));
};
FacepileBase.prototype._getAddNewElement = function () {
var _a = this.props, addButtonProps = _a.addButtonProps, personaSize =
_a.personaSize;
tslib_1.__assign({}, addButtonProps, { className: _classNames.addButton }),
onRenderInitials: this._renderInitials('AddFriend') })));
};
FacepileBase.prototype._onPersonaClick = function (persona, ev) {
persona.onClick(ev, persona);
};
FacepileBase.prototype._onPersonaMouseMove = function (persona, ev) {
if (persona.onMouseMove) {
persona.onMouseMove(ev, persona);
}
};
FacepileBase.prototype._onPersonaMouseOut = function (persona, ev) {
if (persona.onMouseOut) {
persona.onMouseOut(ev, persona);
}
};
FacepileBase.prototype._renderInitials = function (iconName, overflowButton) {
return React.createElement(Icon_1.Icon, { iconName: iconName,
className: overflowButton ? _classNames.overflowInitialsIcon : '' });
};
};
FacepileBase.prototype._renderInitialsNotPictured = function
(numPersonasNotPictured) {
return (React.createElement("span", { className:
_classNames.overflowInitialsIcon }, numPersonasNotPictured < 100 ? '+' +
numPersonasNotPictured : '99+'));
};
};
FacepileBase.defaultProps = {
maxDisplayablePersonas: 5,
personas: [],
overflowPersonas: [],
personaSize: PersonaCoin_1.PersonaSize.size32,
};
return FacepileBase;
exports.FacepileBase = FacepileBase;
//# sourceMappingURL=Facepile.base.js.map
/***/ }),
/***/ 17496:
"use strict";

exports.Facepile = void 0;
var Facepile_base_1 = __webpack_require__(71671);
var Facepile_styles_1 = __webpack_require__(42890);
/**
* The Facepile shows a list of faces or initials in a horizontal lockup. Each
circle represents a person.
*/
exports.Facepile = Utilities_1.styled(Facepile_base_1.FacepileBase,
Facepile_styles_1.styles, undefined, {
scope: 'Facepile',
});
//# sourceMappingURL=Facepile.js.map
/***/ }),
/***/ 42890:
"use strict";

root: 'ms-Facepile',
addButton: 'ms-Facepile-addButton ms-Facepile-itemButton',
descriptiveOverflowButton: 'ms-Facepile-descriptiveOverflowButton ms-Facepile-
itemButton',
itemButton: 'ms-Facepile-itemButton ms-Facepile-person',
itemContainer: 'ms-Facepile-itemContainer',
members: 'ms-Facepile-members',
member: 'ms-Facepile-member',
overflowButton: 'ms-Facepile-overflowButton ms-Facepile-itemButton',
};
var _a;
var className = props.className, theme = props.theme, _b =
props.spacingAroundItemButton, spacingAroundItemButton = _b === void 0 ? 2 : _b;
var ItemButtonStyles = {
padding: 0,
display: 'inline',
border: 'none',
selectors: {
'&::-moz-focus-inner': {
padding: 0,
border: 0,
},
},
};
return {
root: [
classNames.root,
theme.fonts.medium,
{
width: 'auto',
},
className,
],
addButton: [
classNames.addButton,
ItemButtonStyles,
{
marginRight: spacingAroundItemButton * 2 + 'px',
selectors: {
'&:hover': {
backgroundColor: palette.themeDark,
},
'&:focus': {
},
'&:active': {
backgroundColor: palette.themeDarker,
},
'&:disabled': {
backgroundColor: palette.neutralTertiaryAlt,
},
},
},
],
descriptiveOverflowButton: [
classNames.descriptiveOverflowButton,
ItemButtonStyles,
{
marginLeft: spacingAroundItemButton * 2 + "px",
},
],
itemButton: [classNames.itemButton, ItemButtonStyles],
itemContainer: [
classNames.itemContainer,
{
display: 'flex',
},
],
members: [
classNames.members,
{
display: 'flex',
overflow: 'hidden',
padding: 0,
margin: "-" + spacingAroundItemButton + "px",
},
],
member: [
classNames.member,
{
flex: '0 0 auto',
margin: spacingAroundItemButton + "px",
},
],
overflowButton: [
classNames.overflowButton,
ItemButtonStyles,
{
marginLeft: spacingAroundItemButton * 2 + "px",
},
],
overflowInitialsIcon: [
{
},
_a),
},
],
screenReaderOnly: Styling_1.hiddenContentStyle,
};
};
//# sourceMappingURL=Facepile.styles.js.map
/***/ }),
/***/ 19475:
"use strict";

exports.OverflowButtonType = void 0;
/**
* {@docCategory Facepile}
*/
var OverflowButtonType;
(function (OverflowButtonType) {
/** No overflow */
OverflowButtonType[OverflowButtonType["none"] = 0] = "none";
/** +1 overflow icon */
OverflowButtonType[OverflowButtonType["descriptive"] = 1] = "descriptive";
/** More overflow icon */
OverflowButtonType[OverflowButtonType["more"] = 2] = "more";
/** Chevron overflow icon */
OverflowButtonType[OverflowButtonType["downArrow"] = 3] = "downArrow";
})(OverflowButtonType = exports.OverflowButtonType || (exports.OverflowButtonType =
{}));
//# sourceMappingURL=Facepile.types.js.map
/***/ }),
/***/ 69518:
"use strict";

exports.FacepileButton = void 0;
var FacepileButton_styles_1 = __webpack_require__(39722);
var FacepileButton = /** @class */ (function (_super) {
tslib_1.__extends(FacepileButton, _super);
function FacepileButton() {
}
FacepileButton.prototype.render = function () {
var _a = this.props, className = _a.className, styles = _a.styles, rest =
tslib_1.__rest(_a, ["className", "styles"]);
var customStyles = FacepileButton_styles_1.getStyles(this.props.theme,
className, styles);
return (React.createElement(Button_1.BaseButton, tslib_1.__assign({}, rest,
{ variantClassName: "ms-Button--facepile", styles: customStyles,
};
FacepileButton = tslib_1.__decorate([
Utilities_1.customizable('FacepileButton', ['theme', 'styles'], true)
], FacepileButton);
return FacepileButton;
exports.FacepileButton = FacepileButton;
//# sourceMappingURL=FacepileButton.js.map
/***/ }),
/***/ 39722:
"use strict";

exports.getStyles = Utilities_1.memoizeFunction(function (theme, className,
customStyles) {
var customButtonStyles = Styling_1.concatStyleSets(baseButtonStyles,
customStyles);
return tslib_1.__assign(tslib_1.__assign({}, customButtonStyles), { root:
[baseButtonStyles.root, className, theme.fonts.medium, customStyles &&
customStyles.root] });
});
//# sourceMappingURL=FacepileButton.styles.js.map
/***/ }),
/***/ 93612:
"use strict";

/***/ }),
/***/ 10996:
"use strict";

exports.BaseFloatingPicker = void 0;
var SuggestionsControl_1 = __webpack_require__(99911);
var BaseFloatingPicker = /** @class */ (function (_super) {
tslib_1.__extends(BaseFloatingPicker, _super);
function BaseFloatingPicker(basePickerProps) {
_this.suggestionsControl = React.createRef();
_this.SuggestionsControlOfProperType =
SuggestionsControl_1.SuggestionsControl;
_this.isComponentMounted = false;
_this.onQueryStringChanged = function (queryString) {
if (queryString !== _this.state.queryString) {
_this.setState({
queryString: queryString,
});
if (_this.props.onInputChanged) {
_this.props.onInputChanged(queryString);
}
_this.updateValue(queryString);
}
};
_this.hidePicker = function () {
var wasShownBeforeUpdate = _this.isSuggestionsShown;
_this.setState({
suggestionsVisible: false,
});
if (_this.props.onSuggestionsHidden && wasShownBeforeUpdate) {
_this.props.onSuggestionsHidden();
}
};
_this.showPicker = function (updateValue) {
if (updateValue === void 0) { updateValue = false; }
var wasShownBeforeUpdate = _this.isSuggestionsShown;
_this.setState({
suggestionsVisible: true,
});
// Update the suggestions if updateValue == true
var value = _this.props.inputElement ? _this.props.inputElement.value :
'';
if (updateValue) {
_this.updateValue(value);
}
if (_this.props.onSuggestionsShown && !wasShownBeforeUpdate) {
_this.props.onSuggestionsShown();
}
};
_this.completeSuggestion = function () {
if (_this.suggestionsControl.current &&
_this.suggestionsControl.current.hasSuggestionSelected()) {
_this.onChange(_this.suggestionsControl.current.currentSuggestion.item);
}
};
_this.onSuggestionClick = function (ev, item, index) {
_this.onChange(item);
_this._updateSuggestionsVisible(false /*shouldShow*/);
};
_this.onSuggestionRemove = function (ev, item, index) {
if (_this.props.onRemoveSuggestion) {
_this.props.onRemoveSuggestion(item);
}
if (_this.suggestionsControl.current) {
_this.suggestionsControl.current.removeSuggestion(index);
}
};
_this.onKeyDown = function (ev) {
if (!_this.state.suggestionsVisible ||
(_this.props.inputElement && !
_this.props.inputElement.contains(ev.target))) {
return;
}
var keyCode = ev.which;
switch (keyCode) {
_this.hidePicker();
break;
if (!ev.shiftKey &&
!ev.ctrlKey &&
_this.suggestionsControl.current &&
_this.suggestionsControl.current.handleKeyDown(keyCode)) {
}
else {
_this._onValidateInput();
}
break;
case Utilities_1.KeyCodes.del:
if (_this.props.onRemoveSuggestion &&
_this.suggestionsControl.current &&
_this.suggestionsControl.current.hasSuggestionSelected &&
_this.suggestionsControl.current.currentSuggestion &&
ev.shiftKey) {
_this.props.onRemoveSuggestion(_this.suggestionsControl.current.currentSuggestion.i
tem);
_this.suggestionsControl.current.removeSuggestion();
}
break;
_this._updateActiveDescendant();
}
break;
_this._updateActiveDescendant();
}
break;
}
};
_this._onValidateInput = function () {
if (_this.state.queryString && _this.props.onValidateInput &&
_this.props.createGenericItem) {
var itemToConvert =
_this.props.createGenericItem(_this.state.queryString,
_this.props.onValidateInput(_this.state.queryString));
var convertedItems =
_this.suggestionStore.convertSuggestionsToSuggestionItems([itemToConvert]);
_this.onChange(convertedItems[0].item);
}
};
_this.suggestionStore = basePickerProps.suggestionsStore;
_this.state = {
queryString: '',
didBind: false,
};
return _this;
}
Object.defineProperty(BaseFloatingPicker.prototype, "inputText", {
get: function () {
return this.state.queryString;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseFloatingPicker.prototype, "suggestions", {
get: function () {
return this.suggestionStore.suggestions;
},
enumerable: false,
configurable: true
});
BaseFloatingPicker.prototype.forceResolveSuggestion = function () {
if (this.suggestionsControl.current &&
this.suggestionsControl.current.hasSuggestionSelected()) {
this.completeSuggestion();
}
else {
this._onValidateInput();
}
};
Object.defineProperty(BaseFloatingPicker.prototype,
"currentSelectedSuggestionIndex", {
get: function () {
return this.suggestionsControl.current ?
this.suggestionsControl.current.currentSuggestionIndex : -1;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseFloatingPicker.prototype, "isSuggestionsShown", {
get: function () {
return this.state.suggestionsVisible === undefined ? false :
this.state.suggestionsVisible;
},
enumerable: false,
configurable: true
});
BaseFloatingPicker.prototype.componentDidMount = function () {
this._bindToInputElement();
this.isComponentMounted = true;
this._onResolveSuggestions =
this._async.debounce(this._onResolveSuggestions, this.props.resolveDelay);
};
BaseFloatingPicker.prototype.componentDidUpdate = function () {
this._bindToInputElement();
};
BaseFloatingPicker.prototype.componentWillUnmount = function () {
this._unbindFromInputElement();
this.isComponentMounted = false;
};
BaseFloatingPicker.prototype.updateSuggestions = function (suggestions,
forceUpdate) {
if (forceUpdate === void 0) { forceUpdate = false; }
this.suggestionStore.updateSuggestions(suggestions);
if (forceUpdate) {
this.forceUpdate();
}
};
BaseFloatingPicker.prototype.render = function () {
var className = this.props.className;
Utilities_1.css('ms-BasePicker ms-BaseFloatingPicker', className ? className :
'') }, this.renderSuggestions()));
};
BaseFloatingPicker.prototype.renderSuggestions = function () {
var TypedSuggestionsControl = this.SuggestionsControlOfProperType;
if (this.props.suggestionItems) {
this.suggestionStore.updateSuggestions(this.props.suggestionItems);
}
return this.state.suggestionsVisible ?
(React.createElement(Callout_1.Callout, tslib_1.__assign({ className:
styles.callout, isBeakVisible: false, gapSpace: 5, target: this.props.inputElement,
onDismiss: this.hidePicker, directionalHint:
DirectionalHint_1.DirectionalHint.bottomLeftEdge, directionalHintForRTL:
DirectionalHint_1.DirectionalHint.bottomRightEdge, calloutWidth:
this.props.calloutWidth ? this.props.calloutWidth : 0 },
this.props.pickerCalloutProps),
React.createElement(TypedSuggestionsControl,
tslib_1.__assign({ onRenderSuggestion: this.props.onRenderSuggestionsItem,
onSuggestionClick: this.onSuggestionClick, onSuggestionRemove:
this.onSuggestionRemove, suggestions: this.suggestionStore.getSuggestions(),
componentRef: this.suggestionsControl, completeSuggestion: this.completeSuggestion,
shouldLoopSelection: false }, this.props.pickerSuggestionsProps)))) : null;
};
BaseFloatingPicker.prototype.onSelectionChange = function () {
this.forceUpdate();
};
BaseFloatingPicker.prototype.updateValue = function (updatedValue) {
if (updatedValue === '') {
this.updateSuggestionWithZeroState();
}
else {
this._onResolveSuggestions(updatedValue);
}
};
BaseFloatingPicker.prototype.updateSuggestionWithZeroState = function () {
if (this.props.onZeroQuerySuggestion) {
var onEmptyInputFocus = this.props.onZeroQuerySuggestion;
var suggestions = onEmptyInputFocus(this.props.selectedItems);
this.updateSuggestionsList(suggestions);
}
else {
this.hidePicker();
}
};
BaseFloatingPicker.prototype.updateSuggestionsList = function (suggestions) {
var _this = this;
// Check to see if the returned value is an array, if it is then just pass
it into the next function.
// If the returned value is not an array then check to see if it's a
promise or PromiseLike.
if (Array.isArray(suggestions)) {
this.updateSuggestions(suggestions, true /*forceUpdate*/);
}
else if (suggestions && suggestions.then) {
// Ensure that the promise will only use the callback if it was the
most recent one.
this.currentPromise = suggestions;
suggestions.then(function (newSuggestions) {
// Only update if the next promise has not yet resolved and
// the floating picker is still mounted.
if (suggestions === _this.currentPromise &&
_this.isComponentMounted) {
_this.updateSuggestions(newSuggestions, true /*forceUpdate*/);
}
});
}
};
BaseFloatingPicker.prototype.onChange = function (item) {
if (this.props.onChange) {
this.props.onChange(item);
}
};
BaseFloatingPicker.prototype._updateActiveDescendant = function () {
if (this.props.inputElement && this.suggestionsControl.current &&
this.suggestionsControl.current.selectedElement) {
var selectedElId =
this.suggestionsControl.current.selectedElement.getAttribute('id');
if (selectedElId) {
this.props.inputElement.setAttribute('aria-activedescendant',
selectedElId);
}
}
};
BaseFloatingPicker.prototype._onResolveSuggestions = function (updatedValue) {
var suggestions = this.props.onResolveSuggestions(updatedValue,
this.props.selectedItems);
this._updateSuggestionsVisible(true /*shouldShow*/);
if (suggestions !== null) {
}
};
BaseFloatingPicker.prototype._updateSuggestionsVisible = function (shouldShow)
{
if (shouldShow) {
this.showPicker();
}
else {
this.hidePicker();
}
};
BaseFloatingPicker.prototype._bindToInputElement = function () {
if (this.props.inputElement && !this.state.didBind) {
this.props.inputElement.addEventListener('keydown', this.onKeyDown);
this.setState({ didBind: true });
}
};
BaseFloatingPicker.prototype._unbindFromInputElement = function () {
if (this.props.inputElement && this.state.didBind) {
this.props.inputElement.removeEventListener('keydown', this.onKeyDown);
this.setState({ didBind: false });
}
};
return BaseFloatingPicker;
exports.BaseFloatingPicker = BaseFloatingPicker;
//# sourceMappingURL=BaseFloatingPicker.js.map
/***/ }),
/***/ 99701:
"use strict";

exports.callout = void 0;
load_themed_styles_1.loadStyles([{ "rawString": ".callout_ad5629e1 .ms-Suggestions-
itemButton{padding:0;border:none}.callout_ad5629e1 .ms-Suggestions{min-
width:300px}" }]);
exports.callout = "callout_ad5629e1";
//# sourceMappingURL=BaseFloatingPicker.scss.js.map
/***/ }),
/***/ 4826:
"use strict";
//# sourceMappingURL=BaseFloatingPicker.types.js.map
/***/ }),
/***/ 87575:
"use strict";

exports.createItem = exports.FloatingPeoplePicker =
exports.BaseFloatingPeoplePicker = void 0;
var BaseFloatingPicker_1 = __webpack_require__(10996);
var SuggestionItemDefault_1 = __webpack_require__(30762);
/**
* {@docCategory FloatingPeoplePicker}
*/
var BaseFloatingPeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(BaseFloatingPeoplePicker, _super);
function BaseFloatingPeoplePicker() {
}
return BaseFloatingPeoplePicker;
}(BaseFloatingPicker_1.BaseFloatingPicker));
exports.BaseFloatingPeoplePicker = BaseFloatingPeoplePicker;
var FloatingPeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(FloatingPeoplePicker, _super);
function FloatingPeoplePicker() {
}
FloatingPeoplePicker.defaultProps = {
onRenderSuggestionsItem: function (props, itemProps) {
return
SuggestionItemDefault_1.SuggestionItemNormal(tslib_1.__assign({}, props),
tslib_1.__assign({}, itemProps));
},
createGenericItem: createItem,
};
return FloatingPeoplePicker;
}(BaseFloatingPeoplePicker));
exports.FloatingPeoplePicker = FloatingPeoplePicker;
function createItem(name, isValid) {
var personaToConvert = {
key: name,
primaryText: name,
imageInitials: '!',
isValid: isValid,
};
if (!isValid) {
personaToConvert.imageInitials = Utilities_1.getInitials(name,
Utilities_1.getRTL());
}
return personaToConvert;
}
exports.createItem = createItem;
//# sourceMappingURL=FloatingPeoplePicker.js.map
/***/ }),
/***/ 83481:
"use strict";

exports.peoplePickerPersonaContent = exports.peoplePicker =
exports.peoplePickerPersona = exports.resultItem = exports.resultContent = void 0;
".resultContent_f73be5be{display:table-
row}.resultContent_f73be5be .resultItem_f73be5be{display:table-cell;vertical-
align:bottom}.peoplePickerPersona_f73be5be{width:180px}.peoplePickerPersona_f73be5b
e .ms-Persona-details{width:100%}.peoplePicker_f73be5be .ms-BasePicker-text{min-
height:40px}.peoplePickerPersonaContent_f73be5be{display:-webkit-box;display:-ms-
flexbox;display:flex;width:100%;-webkit-box-pack:justify;-ms-flex-
pack:justify;justify-content:space-between;-webkit-box-align:center;-ms-flex-
align:center;align-items:center;padding:7px 12px}" }]);
exports.resultContent = "resultContent_f73be5be";
exports.resultItem = "resultItem_f73be5be";
exports.peoplePickerPersona = "peoplePickerPersona_f73be5be";
exports.peoplePicker = "peoplePicker_f73be5be";
exports.peoplePickerPersonaContent = "peoplePickerPersonaContent_f73be5be";
//# sourceMappingURL=PeoplePicker.scss.js.map
/***/ }),
/***/ 30762:
"use strict";

exports.SuggestionItemNormal = void 0;
var SuggestionItemNormal = function (personaProps, suggestionItemProps) {
return (React.createElement("div", { className: Utilities_1.css('ms-
PeoplePicker-personaContent', stylesImport.peoplePickerPersonaContent) },
React.createElement(Persona_1.Persona, tslib_1.__assign({ presence:
personaProps.presence !== undefined ? personaProps.presence :
Persona_1.PersonaPresence.none, size: Persona_1.PersonaSize.size40, className:
Utilities_1.css('ms-PeoplePicker-Persona', stylesImport.peoplePickerPersona),
showSecondaryText: true }, personaProps))));
};
exports.SuggestionItemNormal = SuggestionItemNormal;
//# sourceMappingURL=SuggestionItemDefault.js.map
/***/ }),
/***/ 41120:
"use strict";

//# sourceMappingURL=Suggestions.types.js.map
/***/ }),
/***/ 99911:
"use strict";

exports.SuggestionsControl = exports.SuggestionsHeaderFooterItem =
exports.SuggestionItemType = void 0;
var SuggestionsCore_1 = __webpack_require__(97873);
var SuggestionItemType;
(function (SuggestionItemType) {
SuggestionItemType[SuggestionItemType["header"] = 0] = "header";
SuggestionItemType[SuggestionItemType["suggestion"] = 1] = "suggestion";
SuggestionItemType[SuggestionItemType["footer"] = 2] = "footer";
})(SuggestionItemType = exports.SuggestionItemType || (exports.SuggestionItemType =
{}));
var SuggestionsHeaderFooterItem = /** @class */ (function (_super) {
tslib_1.__extends(SuggestionsHeaderFooterItem, _super);
function SuggestionsHeaderFooterItem(props) {
return _this;
}
SuggestionsHeaderFooterItem.prototype.render = function () {
var _a;
var _b = this.props, renderItem = _b.renderItem, onExecute = _b.onExecute,
isSelected = _b.isSelected, id = _b.id, className = _b.className;
return onExecute ? (React.createElement("div", { id: id, onClick:
onExecute, className: Utilities_1.css('ms-Suggestions-sectionButton', className,
styles.actionButton, (_a = {},
_a['is-selected ' + styles.buttonSelected] = isSelected,
_a)) }, renderItem())) : (React.createElement("div", { id: id,
className: Utilities_1.css('ms-Suggestions-section', className,
styles.suggestionsTitle) }, renderItem()));
};
return SuggestionsHeaderFooterItem;
exports.SuggestionsHeaderFooterItem = SuggestionsHeaderFooterItem;
/**
* Class when used with SuggestionsStore, renders a suggestions control with
customizable headers and footers
*/
var SuggestionsControl = /** @class */ (function (_super) {
tslib_1.__extends(SuggestionsControl, _super);
function SuggestionsControl(suggestionsProps) {
var _this = _super.call(this, suggestionsProps) || this;
_this._suggestions = React.createRef();
_this.SuggestionsOfProperType = SuggestionsCore_1.SuggestionsCore;
_this.state = {
selectedHeaderIndex: -1,
selectedFooterIndex: -1,
suggestions: suggestionsProps.suggestions,
};
return _this;
}
SuggestionsControl.prototype.componentDidMount = function () {
this.resetSelectedItem();
};
SuggestionsControl.prototype.componentDidUpdate = function (oldProps) {
var _this = this;
this.scrollSelected();
if (oldProps.suggestions && oldProps.suggestions !==
this.props.suggestions) {
this.setState({ suggestions: this.props.suggestions }, function () {
_this.resetSelectedItem();
});
}
};
SuggestionsControl.prototype.componentWillUnmount = function () {
var _a;
(_a = this._suggestions.current) === null || _a === void 0 ? void 0 :
_a.deselectAllSuggestions();
};
SuggestionsControl.prototype.render = function () {
var _a = this.props, className = _a.className, headerItemsProps =
_a.headerItemsProps, footerItemsProps = _a.footerItemsProps,
suggestionsAvailableAlertText = _a.suggestionsAvailableAlertText;
var screenReaderTextStyles =
Styling_1.mergeStyles(Styling_1.hiddenContentStyle);
var shouldAlertSuggestionsAvailableText = this.state.suggestions &&
this.state.suggestions.length > 0 && suggestionsAvailableAlertText;
Suggestions', className ? className : '', styles.root) },
headerItemsProps && this.renderHeaderItems(),
this._renderSuggestions(),
footerItemsProps && this.renderFooterItems(),
shouldAlertSuggestionsAvailableText ? (React.createElement("span",
{ role: "alert", "aria-live": "polite", className: screenReaderTextStyles },
suggestionsAvailableAlertText)) : null));
};
Object.defineProperty(SuggestionsControl.prototype, "currentSuggestion", {
get: function () {
var _a;
return ((_a = this._suggestions.current) === null || _a === void 0 ?
void 0 : _a.getCurrentItem()) || undefined;
},
enumerable: false,
configurable: true
});
Object.defineProperty(SuggestionsControl.prototype, "currentSuggestionIndex", {
get: function () {
return this._suggestions.current ?
this._suggestions.current.currentIndex : -1;
},
enumerable: false,
configurable: true
});
Object.defineProperty(SuggestionsControl.prototype, "selectedElement", {
get: function () {
var _a;
return this._selectedElement.current ? this._selectedElement.current :
_a.selectedElement;
},
enumerable: false,
configurable: true
});
SuggestionsControl.prototype.hasSuggestionSelected = function () {
var _a;
return ((_a = this._suggestions.current) === null || _a === void 0 ? void 0
: _a.hasSuggestionSelected()) || false;
};
SuggestionsControl.prototype.hasSelection = function () {
var _a = this.state, selectedHeaderIndex = _a.selectedHeaderIndex,
selectedFooterIndex = _a.selectedFooterIndex;
return selectedHeaderIndex !== -1 || this.hasSuggestionSelected() ||
selectedFooterIndex !== -1;
};
SuggestionsControl.prototype.executeSelectedAction = function () {
var _a;
var _b = this.props, headerItemsProps = _b.headerItemsProps,
footerItemsProps = _b.footerItemsProps;
var _c = this.state, selectedHeaderIndex = _c.selectedHeaderIndex,
selectedFooterIndex = _c.selectedFooterIndex;
if (headerItemsProps && selectedHeaderIndex !== -1 && selectedHeaderIndex <
headerItemsProps.length) {
var selectedHeaderItem = headerItemsProps[selectedHeaderIndex];
if (selectedHeaderItem.onExecute) {
selectedHeaderItem.onExecute();
}
}
else if ((_a = this._suggestions.current) === null || _a === void 0 ? void
0 : _a.hasSuggestionSelected()) {
this.props.completeSuggestion();
}
else if (footerItemsProps && selectedFooterIndex !== -1 &&
selectedFooterIndex < footerItemsProps.length) {
var selectedFooterItem = footerItemsProps[selectedFooterIndex];
if (selectedFooterItem.onExecute) {
selectedFooterItem.onExecute();
}
}
};
SuggestionsControl.prototype.removeSuggestion = function (index) {
var _a, _b;
_a.removeSuggestion(index ? index : (_b = this._suggestions.current) === null || _b
=== void 0 ? void 0 : _b.currentIndex);
};
/**
* Handles the key down, returns true, if the event was handled, false
otherwise
* @param keyCode - The keyCode to handle
*/
SuggestionsControl.prototype.handleKeyDown = function (keyCode) {
var _a, _b, _c, _d;
var _e = this.state, selectedHeaderIndex = _e.selectedHeaderIndex,
selectedFooterIndex = _e.selectedFooterIndex;
var isKeyDownHandled = false;
if (keyCode === Utilities_1.KeyCodes.down) {
if (selectedHeaderIndex === -1 &&
!((_a = this._suggestions.current) === null || _a === void 0 ? void
0 : _a.hasSuggestionSelected()) &&
selectedFooterIndex === -1) {
this.selectFirstItem();
}
else if (selectedHeaderIndex !== -1) {
this.selectNextItem(SuggestionItemType.header);
isKeyDownHandled = true;
}
else if ((_b = this._suggestions.current) === null || _b === void 0 ?
void 0 : _b.hasSuggestionSelected()) {
this.selectNextItem(SuggestionItemType.suggestion);
}
else if (selectedFooterIndex !== -1) {
this.selectNextItem(SuggestionItemType.footer);
}
}
else if (keyCode === Utilities_1.KeyCodes.up) {
if (selectedHeaderIndex === -1 &&
!((_c = this._suggestions.current) === null || _c === void 0 ? void
0 : _c.hasSuggestionSelected()) &&
selectedFooterIndex === -1) {
this.selectLastItem();
}
else if (selectedHeaderIndex !== -1) {
this.selectPreviousItem(SuggestionItemType.header);
}
else if ((_d = this._suggestions.current) === null || _d === void 0 ?
void 0 : _d.hasSuggestionSelected()) {
this.selectPreviousItem(SuggestionItemType.suggestion);
}
else if (selectedFooterIndex !== -1) {
this.selectPreviousItem(SuggestionItemType.footer);
}
}
else if (keyCode === Utilities_1.KeyCodes.enter || keyCode ===
Utilities_1.KeyCodes.tab) {
if (this.hasSelection()) {
this.executeSelectedAction();
}
}
return isKeyDownHandled;
};
// TODO get the element to scroll into view properly regardless of direction.
SuggestionsControl.prototype.scrollSelected = function () {
if (this._selectedElement.current) {
this._selectedElement.current.scrollIntoView(false);
}
};
SuggestionsControl.prototype.renderHeaderItems = function () {
var _this = this;
var _a = this.props, headerItemsProps = _a.headerItemsProps,
suggestionsHeaderContainerAriaLabel = _a.suggestionsHeaderContainerAriaLabel;
var selectedHeaderIndex = this.state.selectedHeaderIndex;
return headerItemsProps ? (React.createElement("div", { className:
Utilities_1.css('ms-Suggestions-headerContainer', styles.suggestionsContainer), id:
"suggestionHeader-list", role: "list", "aria-label":
suggestionsHeaderContainerAriaLabel }, headerItemsProps.map(function
(headerItemProps, index) {
var isSelected = selectedHeaderIndex !== -1 && selectedHeaderIndex ===
index;
return headerItemProps.shouldShow() ? (React.createElement("div",
{ ref: isSelected ? _this._selectedElement : undefined, id: 'sug-header' + index,
key: 'sug-header' + index, role: "listitem", "aria-label":
headerItemProps.ariaLabel },
React.createElement(SuggestionsHeaderFooterItem, { id: 'sug-header-
item' + index, isSelected: isSelected, renderItem: headerItemProps.renderItem,
onExecute: headerItemProps.onExecute, className: headerItemProps.className }))) :
null;
}))) : null;
};
SuggestionsControl.prototype.renderFooterItems = function () {
var _this = this;
var _a = this.props, footerItemsProps = _a.footerItemsProps,
suggestionsFooterContainerAriaLabel = _a.suggestionsFooterContainerAriaLabel;
var selectedFooterIndex = this.state.selectedFooterIndex;
return footerItemsProps ? (React.createElement("div", { className:
Utilities_1.css('ms-Suggestions-footerContainer', styles.suggestionsContainer), id:
"suggestionFooter-list", role: "list", "aria-label":
suggestionsFooterContainerAriaLabel }, footerItemsProps.map(function
(footerItemProps, index) {
var isSelected = selectedFooterIndex !== -1 && selectedFooterIndex ===
index;
return footerItemProps.shouldShow() ? (React.createElement("div",
{ ref: isSelected ? _this._selectedElement : undefined, id: 'sug-footer' + index,
key: 'sug-footer' + index, role: "listitem", "aria-label":
footerItemProps.ariaLabel },
React.createElement(SuggestionsHeaderFooterItem, { id: 'sug-footer-
item' + index, isSelected: isSelected, renderItem: footerItemProps.renderItem,
onExecute: footerItemProps.onExecute, className: footerItemProps.className }))) :
null;
}))) : null;
};
SuggestionsControl.prototype._renderSuggestions = function () {
var TypedSuggestions = this.SuggestionsOfProperType;
return React.createElement(TypedSuggestions, tslib_1.__assign({ ref:
this._suggestions }, this.props, { suggestions: this.state.suggestions }));
};
/**
* Selects the next selectable item
*/
SuggestionsControl.prototype.selectNextItem = function (itemType,
originalItemType) {
// If the recursive calling has not found a selectable item in the other
suggestion item type groups
// And the method is being called again with the original item type,
// Select the first selectable item of this suggestion item type group
(could be the currently selected item)
if (itemType === originalItemType) {
this._selectNextItemOfItemType(itemType);
return;
}
var startedItemType = originalItemType !== undefined ? originalItemType :
itemType;
// Try to set the selection to the next selectable item, of the same
suggestion item type group
// If this is the original item type, use the current index
var selectionChanged = this._selectNextItemOfItemType(itemType,
startedItemType === itemType ? this._getCurrentIndexForType(itemType) : undefined);
// If the selection did not change, try to select from the next suggestion
type group
if (!selectionChanged) {
this.selectNextItem(this._getNextItemSectionType(itemType),
startedItemType);
}
};
/**
* Selects the previous selectable item
*/
SuggestionsControl.prototype.selectPreviousItem = function (itemType,
originalItemType) {
// If the recursive calling has not found a selectable item in the other
suggestion item type groups
// And the method is being called again with the original item type,
// Select the last selectable item of this suggestion item type group
(could be the currently selected item)
if (itemType === originalItemType) {
this._selectPreviousItemOfItemType(itemType);
return;
}
var startedItemType = originalItemType !== undefined ? originalItemType :
itemType;
// Try to set the selection to the previous selectable item, of the same
suggestion item type group
var selectionChanged = this._selectPreviousItemOfItemType(itemType,
startedItemType === itemType ? this._getCurrentIndexForType(itemType) : undefined);
// If the selection did not change, try to select from the previous
suggestion type group
if (!selectionChanged) {
this.selectPreviousItem(this._getPreviousItemSectionType(itemType),
startedItemType);
}
};
/**
* Resets the selected state and selects the first selectable item
*/
SuggestionsControl.prototype.resetSelectedItem = function () {
var _a;
this.setState({ selectedHeaderIndex: -1, selectedFooterIndex: -1 });
_a.deselectAllSuggestions();
// Select the first item if the shouldSelectFirstItem prop is not set or it
is set and it returns true
if (this.props.shouldSelectFirstItem === undefined ||
this.props.shouldSelectFirstItem()) {
this.selectFirstItem();
}
};
/**
* Selects the first item
*/
SuggestionsControl.prototype.selectFirstItem = function () {
if (this._selectNextItemOfItemType(SuggestionItemType.header)) {
return;
}
if (this._selectNextItemOfItemType(SuggestionItemType.suggestion)) {
return;
}
this._selectNextItemOfItemType(SuggestionItemType.footer);
};
/**
* Selects the last item
*/
SuggestionsControl.prototype.selectLastItem = function () {
if (this._selectPreviousItemOfItemType(SuggestionItemType.footer)) {
return;
}
if (this._selectPreviousItemOfItemType(SuggestionItemType.suggestion)) {
return;
}
this._selectPreviousItemOfItemType(SuggestionItemType.header);
};
/**
* Selects the next item in the suggestion item type group, given the current
index
* If none is able to be selected, returns false, otherwise returns true
* @param itemType - The suggestion item type
* @param currentIndex - The current index, default is -1
*/
SuggestionsControl.prototype._selectNextItemOfItemType = function (itemType,
currentIndex) {
var _a, _b;
if (currentIndex === void 0) { currentIndex = -1; }
if (itemType === SuggestionItemType.suggestion) {
if (this.state.suggestions.length > currentIndex + 1) {
(_a = this._suggestions.current) === null || _a === void 0 ? void 0
: _a.setSelectedSuggestion(currentIndex + 1);
this.setState({ selectedHeaderIndex: -1, selectedFooterIndex: -
1 });
return true;
}
}
else {
var isHeader = itemType === SuggestionItemType.header;
var itemProps = isHeader ? this.props.headerItemsProps :
this.props.footerItemsProps;
if (itemProps && itemProps.length > currentIndex + 1) {
for (var i = currentIndex + 1; i < itemProps.length; i++) {
var item = itemProps[i];
if (item.onExecute && item.shouldShow()) {
this.setState({ selectedHeaderIndex: isHeader ? i : -1 });
this.setState({ selectedFooterIndex: isHeader ? -1 : i });
(_b = this._suggestions.current) === null || _b === void
0 ? void 0 : _b.deselectAllSuggestions();
return true;
}
}
}
}
return false;
};
/**
* Selects the previous item in the suggestion item type group, given the
current index
* If none is able to be selected, returns false, otherwise returns true
* @param itemType - The suggestion item type
* @param currentIndex - The current index. If none is provided, the default is
the items length of specified type
*/
SuggestionsControl.prototype._selectPreviousItemOfItemType = function
(itemType, currentIndex) {
var _a, _b;
if (itemType === SuggestionItemType.suggestion) {
var index = currentIndex !== undefined ? currentIndex :
this.state.suggestions.length;
if (index > 0) {
(_a = this._suggestions.current) === null || _a === void 0 ? void 0
: _a.setSelectedSuggestion(index - 1);
this.setState({ selectedHeaderIndex: -1, selectedFooterIndex: -
1 });
return true;
}
}
else {
var isHeader = itemType === SuggestionItemType.header;
var itemProps = isHeader ? this.props.headerItemsProps :
this.props.footerItemsProps;
if (itemProps) {
var index = currentIndex !== undefined ? currentIndex :
itemProps.length;
if (index > 0) {
for (var i = index - 1; i >= 0; i--) {
var item = itemProps[i];
if (item.onExecute && item.shouldShow()) {
this.setState({ selectedHeaderIndex: isHeader ? i : -
1 });
this.setState({ selectedFooterIndex: isHeader ? -1 :
i });
(_b = this._suggestions.current) === null || _b ===
void 0 ? void 0 : _b.deselectAllSuggestions();
return true;
}
}
}
}
}
return false;
};
SuggestionsControl.prototype._getCurrentIndexForType = function (itemType) {
switch (itemType) {
case SuggestionItemType.header:
return this.state.selectedHeaderIndex;
case SuggestionItemType.suggestion:
return this._suggestions.current.currentIndex;
case SuggestionItemType.footer:
return this.state.selectedFooterIndex;
}
};
SuggestionsControl.prototype._getNextItemSectionType = function (itemType) {
switch (itemType) {
return SuggestionItemType.suggestion;
return SuggestionItemType.footer;
return SuggestionItemType.header;
}
};
SuggestionsControl.prototype._getPreviousItemSectionType = function (itemType)
{
switch (itemType) {
return SuggestionItemType.footer;
return SuggestionItemType.header;
return SuggestionItemType.suggestion;
}
};
return SuggestionsControl;
exports.SuggestionsControl = SuggestionsControl;
//# sourceMappingURL=SuggestionsControl.js.map
/***/ }),
/***/ 70307:
"use strict";

exports.screenReaderOnly = exports.itemButton = exports.suggestionsSpinner =
exports.suggestionsTitle = exports.buttonSelected = exports.actionButton =
exports.root = void 0;
load_themed_styles_1.loadStyles([{ "rawString": ".root_ade399af{min-
width:260px}.actionButton_ade399af{background:0 0;background-
color:transparent;border:0;cursor:pointer;margin:0;padding:0;position:relative;widt
h:100%;font-size:12px}html[dir=ltr] .actionButton_ade399af{text-
align:left}html[dir=rtl] .actionButton_ade399af{text-
align:right}.actionButton_ade399af:hover{background-color:" }, { "theme":
"neutralLighter", "defaultValue": "#f3f2f1" }, { "rawString":
";cursor:pointer}.actionButton_ade399af:active,.actionButton_ade399af:focus{backgro
und-color:" }, { "theme": "themeLight", "defaultValue": "#c7e0f4" }, { "rawString":
"}.actionButton_ade399af .ms-Button-icon{font-
size:16px;width:25px}.actionButton_ade399af .ms-Button-label{margin:0 4px 0
9px}html[dir=rtl] .actionButton_ade399af .ms-Button-label{margin:0 9px 0
4px}.buttonSelected_ade399af{background-color:" }, { "theme": "themeLighter",
"defaultValue": "#deecf9" }, { "rawString":
"}.buttonSelected_ade399af:hover{background-color:" }, { "theme": "themeLight",
"defaultValue": "#c7e0f4" }, { "rawString": ";cursor:pointer}@media screen and (-
ms-high-contrast:active),screen and (forced-colors:active)
{.buttonSelected_ade399af:hover{background-
color:Highlight;color:HighlightText}}@media screen and (-ms-high-
contrast:active),screen and (forced-colors:active)
{.buttonSelected_ade399af{background-color:Highlight;color:HighlightText;-ms-high-
contrast-adjust:none}}.suggestionsTitle_ade399af{font-
size:12px}.suggestionsSpinner_ade399af{margin:5px 0;white-space:nowrap;line-
height:20px;font-size:12px}html[dir=ltr] .suggestionsSpinner_ade399af{padding-
left:14px}html[dir=rtl] .suggestionsSpinner_ade399af{padding-
right:14px}html[dir=ltr] .suggestionsSpinner_ade399af{text-align:left}html[dir=rtl]
.suggestionsSpinner_ade399af{text-align:right}.suggestionsSpinner_ade399af .ms-
Spinner-circle{display:inline-block;vertical-
align:middle}.suggestionsSpinner_ade399af .ms-Spinner-label{display:inline-
block;margin:0 10px 0 16px;vertical-
align:middle}html[dir=rtl] .suggestionsSpinner_ade399af .ms-Spinner-label{margin:0
16px 0 10px}.itemButton_ade399af{height:100%;width:100%;padding:7px 12px}@media
screen and (-ms-high-contrast:active),screen and (forced-colors:active)
{.itemButton_ade399af{color:WindowText}}.screenReaderOnly_ade399af{position:absolut
e;width:1px;height:1px;padding:0;margin:-
1px;overflow:hidden;clip:rect(0,0,0,0);border:0}" }]);
exports.root = "root_ade399af";
exports.actionButton = "actionButton_ade399af";
exports.buttonSelected = "buttonSelected_ade399af";
exports.suggestionsTitle = "suggestionsTitle_ade399af";
exports.suggestionsSpinner = "suggestionsSpinner_ade399af";
exports.itemButton = "itemButton_ade399af";
exports.screenReaderOnly = "screenReaderOnly_ade399af";
//# sourceMappingURL=SuggestionsControl.scss.js.map
/***/ }),
/***/ 97873:
"use strict";

exports.SuggestionsCore = void 0;
var Pickers_1 = __webpack_require__(85641);
/**
* Class when used with SuggestionsStore, renders a basic suggestions control
*/
var SuggestionsCore = /** @class */ (function (_super) {
tslib_1.__extends(SuggestionsCore, _super);
function SuggestionsCore(suggestionsProps) {
_this.SuggestionsItemOfProperType = Pickers_1.SuggestionsItem;
_this._onClickTypedSuggestionsItem = function (item, index) {
_this.props.onSuggestionClick(ev, item, index);
};
};
_this._onRemoveTypedSuggestionsItem = function (item, index) {
var onSuggestionRemove = _this.props.onSuggestionRemove;
onSuggestionRemove(ev, item, index);
};
};
_this.currentIndex = -1;
return _this;
}
/**
* Increments the selected suggestion index
*/
SuggestionsCore.prototype.nextSuggestion = function () {
var suggestions = this.props.suggestions;
if (suggestions && suggestions.length > 0) {
if (this.currentIndex === -1) {
this.setSelectedSuggestion(0);
return true;
}
else if (this.currentIndex < suggestions.length - 1) {
this.setSelectedSuggestion(this.currentIndex + 1);
return true;
}
else if (this.props.shouldLoopSelection && this.currentIndex ===
suggestions.length - 1) {
return true;
}
}
return false;
};
/**
* Decrements the selected suggestion index
*/
SuggestionsCore.prototype.previousSuggestion = function () {
if (suggestions && suggestions.length > 0) {
if (this.currentIndex === -1) {
this.setSelectedSuggestion(suggestions.length - 1);
return true;
}
else if (this.currentIndex > 0) {
this.setSelectedSuggestion(this.currentIndex - 1);
return true;
}
else if (this.props.shouldLoopSelection && this.currentIndex === 0) {
this.setSelectedSuggestion(suggestions.length - 1);
return true;
}
}
return false;
};
Object.defineProperty(SuggestionsCore.prototype, "selectedElement", {
get: function () {
return this._selectedElement.current || undefined;
},
enumerable: false,
configurable: true
});
SuggestionsCore.prototype.getCurrentItem = function () {
return this.props.suggestions[this.currentIndex];
};
SuggestionsCore.prototype.getSuggestionAtIndex = function (index) {
return this.props.suggestions[index];
};
SuggestionsCore.prototype.hasSuggestionSelected = function () {
return this.currentIndex !== -1 && this.currentIndex <
this.props.suggestions.length;
};
SuggestionsCore.prototype.removeSuggestion = function (index) {
this.props.suggestions.splice(index, 1);
};
SuggestionsCore.prototype.deselectAllSuggestions = function () {
if (this.currentIndex > -1 && this.props.suggestions[this.currentIndex]) {
this.props.suggestions[this.currentIndex].selected = false;
this.currentIndex = -1;
this.forceUpdate();
}
};
SuggestionsCore.prototype.setSelectedSuggestion = function (index) {
if (index > suggestions.length - 1 || index < 0) {
this.currentIndex = 0;
this.currentSuggestion.selected = false;
this.currentSuggestion = suggestions[0];
this.currentSuggestion.selected = true;
}
else {
if (this.currentIndex > -1 && suggestions[this.currentIndex]) {
suggestions[this.currentIndex].selected = false;
}
suggestions[index].selected = true;
this.currentIndex = index;
this.currentSuggestion = suggestions[index];
}
this.forceUpdate();
};
SuggestionsCore.prototype.componentDidUpdate = function () {
};
SuggestionsCore.prototype.render = function () {
var _this = this;
var _a = this.props, onRenderSuggestion = _a.onRenderSuggestion,
suggestionsItemClassName = _a.suggestionsItemClassName, resultsMaximumNumber =
_a.resultsMaximumNumber, showRemoveButtons = _a.showRemoveButtons,
suggestionsContainerAriaLabel = _a.suggestionsContainerAriaLabel;
var TypedSuggestionsItem = this.SuggestionsItemOfProperType;
if (resultsMaximumNumber) {
suggestions = suggestions.slice(0, resultsMaximumNumber);
}
Suggestions-container', styles.suggestionsContainer), id: "suggestion-list", role:
"list", "aria-label": suggestionsContainerAriaLabel }, suggestions.map(function
(suggestion, index) { return (React.createElement("div", { ref: suggestion.selected
|| index === _this.currentIndex ? _this._selectedElement : undefined, key:
suggestion.item.key ? suggestion.item.key : index, id: 'sug-' + index, role:
"listitem", "aria-label": suggestion.ariaLabel },
React.createElement(TypedSuggestionsItem, { id: 'sug-item' + index,
suggestionModel: suggestion, RenderSuggestion: onRenderSuggestion, onClick:
_this._onClickTypedSuggestionsItem(suggestion.item, index), className:
suggestionsItemClassName, showRemoveButton: showRemoveButtons, onRemoveItem:
_this._onRemoveTypedSuggestionsItem(suggestion.item, index), isSelectedOverride:
index === _this.currentIndex }))); })));
};
// TODO get the element to scroll into view properly regardless of direction.
SuggestionsCore.prototype.scrollSelected = function () {
var _a;
if (((_a = this._selectedElement.current) === null || _a === void 0 ? void
0 : _a.scrollIntoView) !== undefined) {
this._selectedElement.current.scrollIntoView(false);
}
};
return SuggestionsCore;
exports.SuggestionsCore = SuggestionsCore;
//# sourceMappingURL=SuggestionsCore.js.map
/***/ }),
/***/ 44891:
"use strict";

exports.suggestionsContainer = void 0;
".suggestionsContainer_44c59fda{overflow-y:auto;overflow-x:hidden;max-
height:300px}.suggestionsContainer_44c59fda .ms-Suggestion-item:hover{background-
color:" }, { "theme": "neutralLighter", "defaultValue": "#f3f2f1" }, { "rawString":
";cursor:pointer}.suggestionsContainer_44c59fda .is-suggested{background-color:" },
{ "theme": "themeLighter", "defaultValue": "#deecf9" }, { "rawString":
"}.suggestionsContainer_44c59fda .is-suggested:hover{background-color:" },
{ "theme": "themeLight", "defaultValue": "#c7e0f4" }, { "rawString":
";cursor:pointer}" }]);
exports.suggestionsContainer = "suggestionsContainer_44c59fda";
//# sourceMappingURL=SuggestionsCore.scss.js.map
/***/ }),
/***/ 61799:
"use strict";

exports.SuggestionsStore = void 0;
var SuggestionsStore = /** @class */ (function () {
function SuggestionsStore(options) {
var _this = this;
this._isSuggestionModel = function (value) {
return value.item !== undefined;
};
this._ensureSuggestionModel = function (suggestion) {
if (_this._isSuggestionModel(suggestion)) {
return suggestion;
}
else {
return {
item: suggestion,
selected: false,
ariaLabel: _this.getAriaLabel !== undefined
? _this.getAriaLabel(suggestion)
: suggestion.name ||
suggestion.text ||
suggestion.primaryText,
};
}
};
this.suggestions = [];
this.getAriaLabel = options && options.getAriaLabel;
}
SuggestionsStore.prototype.updateSuggestions = function (newSuggestions) {
if (newSuggestions && newSuggestions.length > 0) {
this.suggestions =
this.convertSuggestionsToSuggestionItems(newSuggestions);
}
else {
}
};
SuggestionsStore.prototype.getSuggestions = function () {
return this.suggestions;
};
SuggestionsStore.prototype.getSuggestionAtIndex = function (index) {
return this.suggestions[index];
};
SuggestionsStore.prototype.removeSuggestion = function (index) {
this.suggestions.splice(index, 1);
};
SuggestionsStore.prototype.convertSuggestionsToSuggestionItems = function
(suggestions) {
return Array.isArray(suggestions) ?
suggestions.map(this._ensureSuggestionModel) : [];
};
return SuggestionsStore;
}());
exports.SuggestionsStore = SuggestionsStore;
//# sourceMappingURL=SuggestionsStore.js.map
/***/ }),
/***/ 37521:
"use strict";

/***/ }),
/***/ 44170:
"use strict";

exports.FocusTrapZone = void 0;
var WindowProvider_1 = __webpack_require__(71189);
var COMPONENT_NAME = 'FocusTrapZone';
disabled: false,
disableFirstFocus: false,
forceFocusInsideTrap: true,
isClickableOutsideFocusTrap: false,
};
var useComponentRef = function (componentRef, previouslyFocusedElement, focusFTZ) {
get previouslyFocusedElement() {
return previouslyFocusedElement;
},
focus: focusFTZ,
}); }, [focusFTZ, previouslyFocusedElement]);
};
exports.FocusTrapZone = React.forwardRef(function (propsWithoutDefaults, ref) {
var _a;
var root = React.useRef(null);
var firstBumper = React.useRef(null);
var lastBumper = React.useRef(null);
var mergedRootRef = react_hooks_1.useMergedRefs(root, ref);
var doc = WindowProvider_1.useDocument();
var isFirstRender = (_a = react_hooks_1.usePrevious(false)) !== null && _a !==
void 0 ? _a : true;
var internalState = react_hooks_1.useConst({
hasFocus: false,
focusStackId: react_hooks_1.useId('ftz-', props.id),
});
var children = props.children, componentRef = props.componentRef, disabled =
props.disabled, disableFirstFocus = props.disableFirstFocus, forceFocusInsideTrap =
props.forceFocusInsideTrap, focusPreviouslyFocusedInnerElement =
props.focusPreviouslyFocusedInnerElement,
firstFocusableSelector = props.firstFocusableSelector, firstFocusableTarget =
props.firstFocusableTarget,
_b = props.disableRestoreFocus,
disableRestoreFocus = _b === void 0 ? props.ignoreExternalFocusing : _b,
isClickableOutsideFocusTrap = props.isClickableOutsideFocusTrap,
enableAriaHiddenSiblings = props.enableAriaHiddenSiblings;
var bumperProps = {
style: {
position: 'fixed', // 'fixed' prevents browsers from scrolling to
bumpers when viewport does not contain them
},
tabIndex: disabled ? -1 : 0,
'data-is-visible': true,
'data-is-focus-trap-zone-bumper': true,
};
var focusElementAsync = React.useCallback(function (element) {
if (element !== firstBumper.current && element !== lastBumper.current) {
Utilities_1.focusAsync(element);
}
}, []);
/**
* Callback to force focus into FTZ (named to avoid overlap with global focus()
callback).
* useEventCallback always returns the same callback reference but updates the
implementation
* every render to avoid stale captured values.
*/
var focusFTZ = react_hooks_1.useEventCallback(function () {
if (!root.current) {
return; // not done mounting
}
var previouslyFocusedElementInTrapZone =
internalState.previouslyFocusedElementInTrapZone;
if (focusPreviouslyFocusedInnerElement &&
previouslyFocusedElementInTrapZone &&
Utilities_1.elementContains(root.current,
previouslyFocusedElementInTrapZone)) {
// focus on the last item that had focus in the zone before we left the
zone
focusElementAsync(previouslyFocusedElementInTrapZone);
return;
}
var firstFocusableChild = null;
if (typeof firstFocusableTarget === 'string') {
firstFocusableChild = root.current.querySelector(firstFocusableTarget);
}
else if (firstFocusableTarget) {
firstFocusableChild = firstFocusableTarget(root.current);
}
else if (firstFocusableSelector) {
var focusSelector = typeof firstFocusableSelector === 'string' ?
firstFocusableSelector : firstFocusableSelector();
firstFocusableChild = root.current.querySelector('.' + focusSelector);
}
// Fall back to first element if query selector did not match any elements.
if (!firstFocusableChild) {
firstFocusableChild = Utilities_1.getNextElement(root.current,
root.current.firstChild, false, false, false, true);
}
if (firstFocusableChild) {
focusElementAsync(firstFocusableChild);
}
});
/** Used in root div focus/blur handlers */
var focusBumper = function (isFirstBumper) {
if (disabled || !root.current) {
return;
}
var nextFocusable = isFirstBumper === internalState.hasFocus
? Utilities_1.getLastTabbable(root.current, lastBumper.current, true,
false)
: Utilities_1.getFirstTabbable(root.current, firstBumper.current, true,
false);
if (nextFocusable) {
if (nextFocusable === firstBumper.current || nextFocusable ===
lastBumper.current) {
// This can happen when FTZ contains no tabbable elements.
// focusFTZ() will take care of finding a focusable element in FTZ.
focusFTZ();
}
else {
nextFocusable.focus();
}
}
};
/** Root div blur handler (doesn't need useCallback since it's for a native
element) */
var onRootBlurCapture = function (ev) {
var _a;
(_a = props.onBlurCapture) === null || _a === void 0 ? void 0 :
_a.call(props, ev);
var relatedTarget = ev.relatedTarget;
if (ev.relatedTarget === null) {
// In IE11, due to lack of support, event.relatedTarget is always
// null making every onBlur call to be "outside" of the root
// even when it's not. Using document.activeElement is another way
// for us to be able to get what the relatedTarget without relying
// on the event
relatedTarget = doc.activeElement;
}
if (!Utilities_1.elementContains(root.current, relatedTarget)) {
internalState.hasFocus = false;
}
};
/** Root div focus handler (doesn't need useCallback since it's for a native
element) */
var onRootFocusCapture = function (ev) {
var _a;
(_a = props.onFocusCapture) === null || _a === void 0 ? void 0 :
_a.call(props, ev);
if (ev.target === firstBumper.current) {
focusBumper(true);
}
else if (ev.target === lastBumper.current) {
focusBumper(false);
}
internalState.hasFocus = true;
if (ev.target !== ev.currentTarget && !(ev.target === firstBumper.current
|| ev.target === lastBumper.current)) {
// every time focus changes within the trap zone, remember the focused
element so that
// it can be restored if focus leaves the pane and returns via
keystroke (i.e. via a call to this.focus(true))
internalState.previouslyFocusedElementInTrapZone = ev.target;
}
};
/** Called to restore focus on unmount or props change. (useEventCallback
ensures latest prop values are used.) */
var returnFocusToInitiator = react_hooks_1.useEventCallback(function
(elementToFocusOnDismiss) {
exports.FocusTrapZone.focusStack =
exports.FocusTrapZone.focusStack.filter(function (value) { return
internalState.focusStackId !== value; });
if (!doc) {
return;
}
var activeElement = doc.activeElement;
if (!disableRestoreFocus &&
typeof (elementToFocusOnDismiss === null || elementToFocusOnDismiss ===
void 0 ? void 0 : elementToFocusOnDismiss.focus) === 'function' &&
// only restore focus if the current focused element is within the FTZ,
or if nothing is focused
(Utilities_1.elementContains(root.current, activeElement) ||
activeElement === doc.body)) {
focusElementAsync(elementToFocusOnDismiss);
}
});
/** Called in window event handlers. (useEventCallback ensures latest prop
values are used.) */
var forceFocusOrClickInTrap = react_hooks_1.useEventCallback(function (ev) {
// be sure to use the latest values here
if (disabled) {
return;
}
if (internalState.focusStackId === exports.FocusTrapZone.focusStack.slice(-
1)[0]) {
var targetElement = ev.target;
if (targetElement && !Utilities_1.elementContains(root.current,
targetElement)) {
focusFTZ();
internalState.hasFocus = true; // set focus here since we stop
event propagation
}
}
});
// Update window event handlers when relevant props change
var disposables = [];
if (forceFocusInsideTrap) {
disposables.push(Utilities_1.on(window, 'focus',
forceFocusOrClickInTrap, true));
}
if (!isClickableOutsideFocusTrap) {
disposables.push(Utilities_1.on(window, 'click',
forceFocusOrClickInTrap, true));
}
disposables.forEach(function (dispose) { return dispose(); });
};
when these two props change
}, [forceFocusInsideTrap, isClickableOutsideFocusTrap]);
// On prop change or first render, focus the FTZ and update focusStack if
appropriate
// Do nothing if disabled, or if it's a re-render and forceFocusInsideTrap
is false
// (to match existing behavior, the FTZ handles first focus even if
forceFocusInsideTrap
// is false, though it's debatable whether it should do this)
if (disabled || (!isFirstRender && !forceFocusInsideTrap) || !root.current)
{
return;
}
// Transition from forceFocusInsideTrap / FTZ disabled to enabled (or
initial mount)
exports.FocusTrapZone.focusStack.push(internalState.focusStackId);
var elementToFocusOnDismiss = props.elementToFocusOnDismiss ||
doc.activeElement;
if (!disableFirstFocus && !Utilities_1.elementContains(root.current,
elementToFocusOnDismiss)) {
focusFTZ();
}
// To match existing behavior, always return focus on cleanup (even if we
didn't handle
// initial focus), but it's debatable whether that's correct
return function () { return
returnFocusToInitiator(elementToFocusOnDismiss); };
when these two props change
}, [forceFocusInsideTrap, disabled]);
// Handle modalization separately from first focus
if (!disabled && enableAriaHiddenSiblings) {
var unmodalize = Utilities_1.modalize(root.current);
return unmodalize;
}
}, [disabled, enableAriaHiddenSiblings, root]);
// Cleanup lifecyle method for internalState.
react_hooks_1.useUnmount(function () {
// Dispose of element references so the DOM Nodes can be garbage-collected
delete internalState.previouslyFocusedElementInTrapZone;
});
useComponentRef(componentRef, internalState.previouslyFocusedElementInTrapZone,
focusFTZ);
return (React.createElement("div", tslib_1.__assign({ "aria-labelledby":
props.ariaLabelledBy }, Utilities_1.getNativeProps(props,
Utilities_1.divProperties), { ref: mergedRootRef, onFocusCapture:
onRootFocusCapture, onBlurCapture: onRootBlurCapture }),
React.createElement("div", tslib_1.__assign({}, bumperProps, { ref:
firstBumper })),
children,
React.createElement("div", tslib_1.__assign({}, bumperProps, { ref:
lastBumper }))));
});
exports.FocusTrapZone.displayName = COMPONENT_NAME;
exports.FocusTrapZone.focusStack = [];
//# sourceMappingURL=FocusTrapZone.js.map
/***/ }),
/***/ 918:
"use strict";

//# sourceMappingURL=FocusTrapZone.types.js.map
/***/ }),
/***/ 75635:
"use strict";

/***/ }),
/***/ 5423:
"use strict";

exports.GroupFooterBase = void 0;
var GroupFooterBase = function (props) {
var group = props.group, groupLevel = props.groupLevel, footerText =
props.footerText, indentWidth = props.indentWidth, styles = props.styles, theme =
props.theme;
var classNames = getClassNames(styles, { theme: theme });
if (group && footerText) {
indentWidth, count: groupLevel }),
footerText));
}
return null;
};
exports.GroupFooterBase = GroupFooterBase;
//# sourceMappingURL=GroupFooter.base.js.map
/***/ }),
/***/ 98194:
"use strict";

exports.GroupFooter = void 0;
var GroupFooter_styles_1 = __webpack_require__(8595);
var GroupFooter_base_1 = __webpack_require__(5423);
exports.GroupFooter = Utilities_1.styled(GroupFooter_base_1.GroupFooterBase,
GroupFooter_styles_1.getStyles, undefined, {
scope: 'GroupFooter',
});
//# sourceMappingURL=GroupFooter.js.map
/***/ }),
/***/ 8595:
"use strict";

root: 'ms-groupFooter',
};
return {
root: [
theme.fonts.medium,
classNames.root,
{
},
className,
],
};
};
//# sourceMappingURL=GroupFooter.styles.js.map
/***/ }),
/***/ 57180:
"use strict";

exports.GroupHeaderBase = void 0;
var Check_1 = __webpack_require__(19774);
var Spinner_1 = __webpack_require__(36875);
var GroupHeaderBase = /** @class */ (function (_super) {
tslib_1.__extends(GroupHeaderBase, _super);
function GroupHeaderBase(props) {
_this._toggleCollapse = function () {
var _a = _this.props, group = _a.group, onToggleCollapse =
_a.onToggleCollapse, isGroupLoading = _a.isGroupLoading;
var isCollapsed = _this.state.isCollapsed;
var newCollapsed = !isCollapsed;
var newLoadingVisible = !newCollapsed && isGroupLoading &&
isGroupLoading(group);
_this.setState({
isCollapsed: newCollapsed,
isLoadingVisible: newLoadingVisible,
});
if (onToggleCollapse) {
onToggleCollapse(group);
}
};
_this._onKeyUp = function (ev) {
var _a = _this.props, group = _a.group, onGroupHeaderKeyUp =
_a.onGroupHeaderKeyUp;
if (onGroupHeaderKeyUp) {
onGroupHeaderKeyUp(ev, group);
}
var shouldOpen = _this.state.isCollapsed && ev.which ===
Utilities_1.getRTLSafeKeyCode(Utilities_1.KeyCodes.right, _this.props.theme);
var shouldClose = !_this.state.isCollapsed && ev.which ===
Utilities_1.getRTLSafeKeyCode(Utilities_1.KeyCodes.left, _this.props.theme);
if (shouldClose || shouldOpen) {
_this._toggleCollapse();
}
}
};
_this._onToggleClick = function (ev) {
_this._toggleCollapse();
};
_this._onToggleSelectGroupClick = function (ev) {
var _a = _this.props, onToggleSelectGroup = _a.onToggleSelectGroup,
group = _a.group;
if (onToggleSelectGroup) {
onToggleSelectGroup(group);
}
};
_this._onHeaderClick = function () {
var _a = _this.props, group = _a.group, onGroupHeaderClick =
_a.onGroupHeaderClick, onToggleSelectGroup = _a.onToggleSelectGroup;
if (onGroupHeaderClick) {
onGroupHeaderClick(group);
}
else if (onToggleSelectGroup) {
onToggleSelectGroup(group);
}
};
_this._onRenderTitle = function (props) {
var group = props.group, ariaColSpan = props.ariaColSpan;
if (!group) {
return null;
}
_this._classNames.title, id: _this._id, role: "gridcell", "aria-colspan":
ariaColSpan },
React.createElement("span", null, group.name),
_this._classNames.headerCount },
"(",
group.count,
group.hasMoreData && '+',
")")));
};
_this._id = Utilities_1.getId('GroupHeader');
_this.state = {
isCollapsed: (_this.props.group && _this.props.group.isCollapsed),
isLoadingVisible: false,
};
return _this;
}
GroupHeaderBase.getDerivedStateFromProps = function (nextProps, previousState)
{
if (nextProps.group) {
var newCollapsed = nextProps.group.isCollapsed;
var isGroupLoading = nextProps.isGroupLoading;
var newLoadingVisible = !newCollapsed && isGroupLoading &&
isGroupLoading(nextProps.group);
{ isCollapsed: newCollapsed || false, isLoadingVisible: newLoadingVisible ||
false });
}
return previousState;
};
GroupHeaderBase.prototype.render = function () {
var _a = this.props, group = _a.group, _b = _a.groupLevel, groupLevel = _b
=== void 0 ? 0 : _b, viewport = _a.viewport, selectionMode = _a.selectionMode,
loadingText = _a.loadingText,
_c = _a.isSelected,
isSelected = _c === void 0 ? false : _c, _d = _a.selected, selected = _d
=== void 0 ? false : _d, indentWidth = _a.indentWidth, _e = _a.onRenderTitle,
onRenderTitle = _e === void 0 ? this._onRenderTitle : _e,
onRenderGroupHeaderCheckbox = _a.onRenderGroupHeaderCheckbox, _f =
_a.isCollapsedGroupSelectVisible, isCollapsedGroupSelectVisible = _f === void 0 ?
true : _f, expandButtonProps = _a.expandButtonProps, expandButtonIcon =
_a.expandButtonIcon, selectAllButtonProps = _a.selectAllButtonProps, theme =
_a.theme, styles = _a.styles, className = _a.className, compact = _a.compact,
ariaPosInSet = _a.ariaPosInSet, ariaSetSize = _a.ariaSetSize, ariaRowIndex =
_a.ariaRowIndex, useFastIcons = _a.useFastIcons;
var defaultCheckboxRender = useFastIcons ?
this._fastDefaultCheckboxRender : this._defaultCheckboxRender;
var onRenderCheckbox = onRenderGroupHeaderCheckbox
? Utilities_1.composeRenderFunction(onRenderGroupHeaderCheckbox,
defaultCheckboxRender)
: defaultCheckboxRender;
var _g = this.state, isCollapsed = _g.isCollapsed, isLoadingVisible =
_g.isLoadingVisible;
var canSelectGroup = selectionMode === Selection_1.SelectionMode.multiple;
var isSelectionCheckVisible = canSelectGroup &&
(isCollapsedGroupSelectVisible || !(group && group.isCollapsed));
var currentlySelected = selected || isSelected;
theme: theme,
selected: currentlySelected,
isCollapsed: isCollapsed,
compact: compact,
});
if (!group) {
return null;
}
style: viewport ? { minWidth: viewport.width } : {}, onClick: this._onHeaderClick,
role: "row", "aria-setsize": ariaSetSize, "aria-posinset": ariaPosInSet, "aria-
rowindex": ariaRowIndex, "data-is-focusable": true, onKeyUp: this._onKeyUp, "aria-
label": group.ariaLabel, "aria-labelledby": group.ariaLabel ? undefined : this._id,
"aria-expanded": !this.state.isCollapsed, "aria-selected": canSelectGroup ?
currentlySelected : undefined, "aria-level": groupLevel + 1 },
this._classNames.groupHeaderContainer, role: "presentation" },
isSelectionCheckVisible ? (React.createElement("div", { role:
"gridcell" },
React.createElement("button", tslib_1.__assign({ "data-is-
focusable": false, type: "button", className: this._classNames.check, role:
"checkbox", id: this._id + "-check", "aria-checked": currentlySelected, "aria-
labelledby": this._id + "-check " + this._id, "data-selection-toggle": true,
onClick: this._onToggleSelectGroupClick }, selectAllButtonProps),
onRenderCheckbox({ checked: currentlySelected, theme: theme }, onRenderCheckbox))))
: (
// To make the group header align properly with the column headers,
this spacer
// needs to be the same width as the check cell in the column
header.
selectionMode !== Selection_1.SelectionMode.none &&
DetailsRowCheck_styles_1.CHECK_CELL_WIDTH, count: 1 })),
indentWidth, count: groupLevel }),
React.createElement("div", { className: this._classNames.dropIcon,
role: "presentation" },
React.createElement(Icon_1.Icon, { iconName: "Tag" })),
React.createElement("div", { role: "gridcell" },
React.createElement("button", tslib_1.__assign({ "data-is-
focusable": false, type: "button", className: this._classNames.expand, onClick:
this._onToggleClick, "aria-expanded": !this.state.isCollapsed },
expandButtonProps),
React.createElement(Icon_1.Icon, { className:
this._classNames.expandIsCollapsed, iconName: expandButtonIcon || (isRTL ?
'ChevronLeftMed' : 'ChevronRightMed') }))),
onRenderTitle(this.props, this._onRenderTitle),
isLoadingVisible && React.createElement(Spinner_1.Spinner, { label:
loadingText }))));
};
GroupHeaderBase.prototype._defaultCheckboxRender = function (checkboxProps) {
return React.createElement(Check_1.Check, { checked:
checkboxProps.checked });
};
GroupHeaderBase.prototype._fastDefaultCheckboxRender = function (checkboxProps)
{
return React.createElement(FastCheck, { theme: checkboxProps.theme,
checked: checkboxProps.checked });
};
GroupHeaderBase.defaultProps = {
expandButtonProps: { 'aria-label': 'expand collapse group' },
};
return GroupHeaderBase;
exports.GroupHeaderBase = GroupHeaderBase;
var FastCheck = React.memo(function (props) {
return React.createElement(Check_1.Check, { theme: props.theme, checked:
props.checked, className: props.className, useFastIcons: true });
});
//# sourceMappingURL=GroupHeader.base.js.map
/***/ }),
/***/ 35761:
"use strict";

exports.GroupHeader = void 0;
var GroupHeader_styles_1 = __webpack_require__(4641);
var GroupHeader_base_1 = __webpack_require__(57180);
exports.GroupHeader = Utilities_1.styled(GroupHeader_base_1.GroupHeaderBase,
GroupHeader_styles_1.getStyles, undefined, {
scope: 'GroupHeader',
});
//# sourceMappingURL=GroupHeader.js.map
/***/ }),
/***/ 4641:
"use strict";

root: 'ms-GroupHeader',
compact: 'ms-GroupHeader--compact',
check: 'ms-GroupHeader-check',
dropIcon: 'ms-GroupHeader-dropIcon',
expand: 'ms-GroupHeader-expand',
title: 'ms-GroupHeader-title',
iconTag: 'ms-Icon--Tag',
group: 'ms-GroupedList-group',
isDropping: 'is-dropping',
};
var beziers = {
easeOutCirc: 'cubic-bezier(0.075, 0.820, 0.165, 1.000)',
easeOutSine: 'cubic-bezier(0.390, 0.575, 0.565, 1.000)',
easeInBack: 'cubic-bezier(0.600, -0.280, 0.735, 0.045)',
};
var DEFAULT_GROUP_HEADER_HEIGHT = 48;
var COMPACT_GROUP_HEADER_HEIGHT = 40;
var _a, _b, _c, _d, _e;
var theme = props.theme, className = props.className, selected =
props.selected, isCollapsed = props.isCollapsed, compact = props.compact;
// padding from the source to align GroupHeader title with DetailsRow's first
cell.
var cellLeftPadding =
DetailsRow_styles_1.DEFAULT_CELL_STYLE_PROPS.cellLeftPadding;
var finalRowHeight = compact ? COMPACT_GROUP_HEADER_HEIGHT :
DEFAULT_GROUP_HEADER_HEIGHT;
theme.fonts;
var checkExpandResetStyles = [
{
cursor: 'default',
background: 'none',
border: 'none',
padding: 0, // cancel default <button> padding
},
];
return {
root: [
classNames.root,
theme.fonts.medium,
{
// keep the border for height but color it so it's invisible.
borderBottom: "1px solid " + semanticColors.listBackground,
cursor: 'default',
userSelect: 'none',
selectors: (_a = {
':hover': {
background: semanticColors.listItemBackgroundHovered,
color: semanticColors.actionLinkHovered,
}
},
_a["&:hover ." + classNames.check] = {
opacity: 1,
},
_a["." + Utilities_1.IsFocusVisibleClassName + " &:focus ." +
classNames.check] = {
opacity: 1,
},
_a[":global(." + classNames.group + "." + classNames.isDropping
+ ")"] = {
_b["& > ." + classNames.root + " ." +
classNames.dropIcon] = {
transition: "transform " +
Styling_1.AnimationVariables.durationValue4 + " " + beziers.easeOutCirc + " " +
("opacity " +
Styling_1.AnimationVariables.durationValue1 + " " + beziers.easeOutSine),
transitionDelay:
Styling_1.AnimationVariables.durationValue3,
opacity: 1,
transform: "rotate(0.2deg) scale(1);", // rotation
prevents jittery motion in IE
},
_b["." + classNames.check] = {
opacity: 0,
},
_b),
},
_a),
},
selected && [
{
background: semanticColors.listItemBackgroundChecked,
selectors: (_c = {
':hover': {
background:
semanticColors.listItemBackgroundCheckedHovered,
}
},
_c["" + classNames.check] = {
opacity: 1,
},
_c),
},
],
compact && [classNames.compact, { border: 'none' }],
className,
],
groupHeaderContainer: [
{
display: 'flex',
height: finalRowHeight,
},
],
headerCount: [
{
padding: '0px 4px',
},
],
check: [
classNames.check,
checkExpandResetStyles,
{
display: 'flex',
// paddingTop and marginTop brought from the DetailsRow.styles.ts
with explanation below.
// Ensure that the check cell covers the top border of the cell.
// This ensures the click target does not leave a spot which would
// cause other items to be deselected.
paddingTop: 1,
marginTop: -1,
opacity: 0,
width: DetailsRowCheck_styles_1.CHECK_CELL_WIDTH,
_d["." + Utilities_1.IsFocusVisibleClassName + " &:focus"] = {
opacity: 1,
},
_d),
},
],
expand: [
classNames.expand,
checkExpandResetStyles,
{
display: 'flex',
flexShrink: 0,
width: GroupSpacer_1.SPACER_WIDTH,
color: selected ? palette.neutralPrimary :
palette.neutralSecondary,
selectors: {
':hover': {
backgroundColor: selected ? palette.neutralQuaternary :
palette.neutralLight,
},
':active': {
backgroundColor: selected ? palette.neutralTertiaryAlt :
palette.neutralQuaternaryAlt,
},
},
},
],
expandIsCollapsed: [
isCollapsed
? [
classNames.isCollapsed,
{
},
]
: {
transform: Utilities_1.getRTL(theme) ? 'rotate(-90deg)' :
'rotate(90deg)',
},
],
title: [
classNames.title,
{
paddingLeft: cellLeftPadding,
fontSize: compact ? fonts.medium.fontSize :
fonts.mediumPlus.fontSize,
fontWeight: isCollapsed ? Styling_1.FontWeights.regular :
Styling_1.FontWeights.semibold,
cursor: 'pointer',
outline: 0,
overflow: 'hidden',
},
],
dropIcon: [
classNames.dropIcon,
{
left: -26,
transition: "transform " +
Styling_1.AnimationVariables.durationValue2 + " " + beziers.easeInBack + ", " +
("opacity " + Styling_1.AnimationVariables.durationValue4 + " "
+ beziers.easeOutSine),
opacity: 0,
transform: 'rotate(0.2deg) scale(0.65)',
transformOrigin: '10px 10px',
_e[":global(." + classNames.iconTag + ")"] = {
},
_e),
},
],
};
};
//# sourceMappingURL=GroupHeader.styles.js.map
/***/ }),
/***/ 58377:
"use strict";

exports.GroupShowAllBase = void 0;
var GroupShowAllBase = function (props) {
var group = props.group, groupLevel = props.groupLevel, _a =
props.showAllLinkText, showAllLinkText = _a === void 0 ? 'Show All' : _a, styles =
props.styles, theme = props.theme, onToggleSummarize = props.onToggleSummarize;
var classNames = getClassNames(styles, { theme: theme });
var memoizedOnClick = react_1.useCallback(function (ev) {
onToggleSummarize(group);
}, [onToggleSummarize, group]);
if (group) {
React.createElement(GroupSpacer_1.GroupSpacer, { count: groupLevel }),
React.createElement(Link_1.Link, { onClick: memoizedOnClick },
showAllLinkText)));
}
return null;
};
exports.GroupShowAllBase = GroupShowAllBase;
//# sourceMappingURL=GroupShowAll.base.js.map
/***/ }),
/***/ 49455:
"use strict";

exports.GroupShowAll = void 0;
var GroupShowAll_styles_1 = __webpack_require__(62135);
var GroupShowAll_base_1 = __webpack_require__(58377);
exports.GroupShowAll = Utilities_1.styled(GroupShowAll_base_1.GroupShowAllBase,
GroupShowAll_styles_1.getStyles, undefined, { scope: 'GroupShowAll' });
//# sourceMappingURL=GroupShowAll.js.map
/***/ }),
/***/ 62135:
"use strict";

root: 'ms-GroupShowAll',
link: 'ms-Link',
};
var _a;
var fonts = theme.fonts;
return {
root: [
classNames.root,
{
cursor: 'pointer',
_a["." + classNames.link] = {
},
_a),
},
],
};
};
//# sourceMappingURL=GroupShowAll.styles.js.map
/***/ }),
/***/ 56388:
"use strict";

exports.GroupSpacer = exports.SPACER_WIDTH = void 0;
exports.SPACER_WIDTH = 36;
var GroupSpacer = function (props) {
var count = props.count, _a = props.indentWidth, indentWidth = _a === void 0 ?
exports.SPACER_WIDTH : _a, _b = props.role, role = _b === void 0 ? 'presentation' :
_b;
var width = count * indentWidth;
return count > 0 ? (React.createElement("span", { className: 'ms-GroupSpacer',
style: { display: 'inline-block', width: width }, role: role })) : null;
};
exports.GroupSpacer = GroupSpacer;
//# sourceMappingURL=GroupSpacer.js.map
/***/ }),
/***/ 61689:
"use strict";

//# sourceMappingURL=GroupSpacer.types.js.map
/***/ }),
/***/ 60490:
"use strict";

exports.GroupedListBase = void 0;
var GroupedListSection_1 = __webpack_require__(79462);
var ROW_HEIGHT = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.rowHeight,
COMPACT_ROW_HEIGHT = DetailsRow_styles_1.DEFAULT_ROW_HEIGHTS.compactRowHeight;
var GroupedListBase = /** @class */ (function (_super) {
tslib_1.__extends(GroupedListBase, _super);
function GroupedListBase(props) {
_this._renderGroup = function (group, groupIndex) {
var _a = _this.props, dragDropEvents = _a.dragDropEvents,
dragDropHelper = _a.dragDropHelper, eventsToRegister = _a.eventsToRegister,
groupProps = _a.groupProps, items = _a.items, listProps = _a.listProps,
onRenderCell = _a.onRenderCell, selectionMode = _a.selectionMode, selection =
_a.selection, viewport = _a.viewport, onShouldVirtualize = _a.onShouldVirtualize,
groups = _a.groups, compact = _a.compact;
// override group header/footer props as needed
var dividerProps = {
onToggleSelectGroup: _this._onToggleSelectGroup,
onToggleCollapse: _this._onToggleCollapse,
onToggleSummarize: _this._onToggleSummarize,
};
var headerProps = tslib_1.__assign(tslib_1.__assign({},
groupProps.headerProps), dividerProps);
var showAllProps = tslib_1.__assign(tslib_1.__assign({},
groupProps.showAllProps), dividerProps);
var footerProps = tslib_1.__assign(tslib_1.__assign({},
groupProps.footerProps), dividerProps);
var groupNestingDepth = _this._getGroupNestingDepth();
if (!groupProps.showEmptyGroups && group && group.count === 0) {
return null;
}
var finalListProps = tslib_1.__assign(tslib_1.__assign({}, (listProps
|| {})), { version: _this.state.version });
return (React.createElement(GroupedListSection_1.GroupedListSection,
{ key: _this._getGroupKey(group, groupIndex), dragDropEvents: dragDropEvents,
dragDropHelper: dragDropHelper, eventsToRegister: eventsToRegister, footerProps:
footerProps, getGroupItemLimit: groupProps && groupProps.getGroupItemLimit, group:
group, groupIndex: groupIndex, groupNestingDepth: groupNestingDepth, groupProps:
groupProps, headerProps: headerProps, listProps: finalListProps, items: items,
onRenderCell: onRenderCell, onRenderGroupHeader: groupProps.onRenderHeader,
onRenderGroupShowAll: groupProps.onRenderShowAll, onRenderGroupFooter:
groupProps.onRenderFooter, selectionMode: selectionMode, selection: selection,
showAllProps: showAllProps, viewport: viewport, onShouldVirtualize:
onShouldVirtualize, groupedListClassNames: _this._classNames, groups: groups,
compact: compact }));
};
_this._getDefaultGroupItemLimit = function (group) {
return group.children && group.children.length > 0 ?
group.children.length : group.count;
};
_this._getGroupItemLimit = function (group) {
var groupProps = _this.props.groupProps;
var getGroupItemLimit = groupProps && groupProps.getGroupItemLimit ?
groupProps.getGroupItemLimit : _this._getDefaultGroupItemLimit;
return getGroupItemLimit(group);
};
_this._getGroupHeight = function (group) {
var rowHeight = _this.props.compact ? COMPACT_ROW_HEIGHT : ROW_HEIGHT;
return rowHeight + (group.isCollapsed ? 0 : rowHeight *
_this._getGroupItemLimit(group));
};
_this._getPageHeight = function (itemIndex) {
var groups = _this.state.groups;
var _a = _this.props.getGroupHeight, getGroupHeight = _a === void 0 ?
_this._getGroupHeight : _a;
var pageGroup = groups && groups[itemIndex];
if (pageGroup) {
return getGroupHeight(pageGroup, itemIndex);
}
else {
return 0;
}
};
_this._onToggleCollapse = function (group) {
var onToggleCollapse = groupProps && groupProps.headerProps &&
groupProps.headerProps.onToggleCollapse;
if (group) {
if (onToggleCollapse) {
onToggleCollapse(group);
}
group.isCollapsed = !group.isCollapsed;
_this._updateIsSomeGroupExpanded();
}
};
_this._onToggleSelectGroup = function (group) {
var _a = _this.props, selection = _a.selection, selectionMode =
_a.selectionMode;
if (group && selection && selectionMode ===
Selection_1.SelectionMode.multiple) {
selection.toggleRangeSelected(group.startIndex, group.count);
}
};
_this._isInnerZoneKeystroke = function (ev) {
return ev.which ===
Utilities_1.getRTLSafeKeyCode(Utilities_1.KeyCodes.right);
};
_this._onToggleSummarize = function (group) {
var onToggleSummarize = groupProps && groupProps.showAllProps &&
groupProps.showAllProps.onToggleSummarize;
if (onToggleSummarize) {
onToggleSummarize(group);
}
else {
if (group) {
group.isShowingAll = !group.isShowingAll;
}
}
};
_this._getPageSpecification = function (itemIndex) {
var groups = _this.state.groups;
var pageGroup = groups && groups[itemIndex];
return {
key: pageGroup && pageGroup.key,
};
};
_this._isSomeGroupExpanded =
_this._computeIsSomeGroupExpanded(props.groups);
var _a = props.listProps, _b = _a === void 0 ? {} : _a, _c = _b.version,
version = _c === void 0 ? {} : _c;
_this.state = {
groups: props.groups,
items: props.items,
listProps: props.listProps,
version: version,
};
return _this;
}
GroupedListBase.getDerivedStateFromProps = function (nextProps, previousState)
{
var groups = nextProps.groups, selectionMode = nextProps.selectionMode,
compact = nextProps.compact, items = nextProps.items, listProps =
nextProps.listProps;
var listVersion = listProps && listProps.version;
var nextState = tslib_1.__assign(tslib_1.__assign({}, previousState),
{ selectionMode: selectionMode, compact: compact, groups: groups, listProps:
listProps });
var shouldForceUpdates = false;
var previousListVersion = previousState.listProps &&
previousState.listProps.version;
if (listVersion !== previousListVersion ||
items !== previousState.items ||
groups !== previousState.groups ||
selectionMode !== previousState.selectionMode ||
compact !== previousState.compact) {
// If there are any props not passed explicitly to `List` which have an
impact on the behavior of ònRenderCell`,
// these need to 'force-update' this component by revving the version.
Otherwise, the List might render with stale
// data.
}
if (groups !== previousState.groups) {
nextState = tslib_1.__assign(tslib_1.__assign({}, nextState), { groups:
groups });
}
if (selectionMode !== previousState.selectionMode || compact !==
previousState.compact) {
}
if (shouldForceUpdates) {
{ version: {} });
}
return nextState;
};
GroupedListBase.prototype.scrollToIndex = function (index, measureItem,
scrollToMode) {
this._list.current.scrollToIndex(index, measureItem, scrollToMode);
}
};
GroupedListBase.prototype.getStartItemIndexInView = function () {
return this._list.current.getStartItemIndexInView() || 0;
};
GroupedListBase.prototype.componentDidMount = function () {
var _a = this.props, groupProps = _a.groupProps, _b = _a.groups, groups =
_b === void 0 ? [] : _b;
if (groupProps && groupProps.isAllGroupsCollapsed) {
this._setGroupsCollapsedState(groups, groupProps.isAllGroupsCollapsed);
}
};
GroupedListBase.prototype.render = function () {
var _a = this.props, className = _a.className, usePageCache =
_a.usePageCache, onShouldVirtualize = _a.onShouldVirtualize, theme = _a.theme, _b =
_a.role, role = _b === void 0 ? 'treegrid' : _b, styles = _a.styles, compact =
_a.compact, _c = _a.focusZoneProps, focusZoneProps = _c === void 0 ? {} : _c, _d =
_a.rootListProps, rootListProps = _d === void 0 ? {} : _d;
var _e = this.state, groups = _e.groups, version = _e.version;
theme: theme,
compact: compact,
});
var _f = focusZoneProps.shouldEnterInnerZone, shouldEnterInnerZone = _f ===
void 0 ? this._isInnerZoneKeystroke : _f;
return (React.createElement(FocusZone_1.FocusZone,
tslib_1.__assign({ direction: FocusZone_1.FocusZoneDirection.vertical, "data-
automationid": "GroupedList", "data-is-scrollable": "false", role:
"presentation" }, focusZoneProps, { shouldEnterInnerZone: shouldEnterInnerZone,
className: Utilities_1.css(this._classNames.root, focusZoneProps.className) }), !
groups ? (this._renderGroup(undefined, 0)) : (React.createElement(List_1.List,
tslib_1.__assign({ ref: this._list, role: role, items: groups, onRenderCell:
this._renderGroup, getItemCountForPage: this._returnOne, getPageHeight:
this._getPageHeight, getPageSpecification: this._getPageSpecification,
usePageCache: usePageCache, onShouldVirtualize: onShouldVirtualize, version:
version }, rootListProps)))));
};
GroupedListBase.prototype.forceUpdate = function () {
this._forceListUpdates();
};
GroupedListBase.prototype.toggleCollapseAll = function (allCollapsed) {
var _a = this.state.groups, groups = _a === void 0 ? [] : _a;
var groupProps = this.props.groupProps;
var onToggleCollapseAll = groupProps && groupProps.onToggleCollapseAll;
if (groups.length > 0) {
if (onToggleCollapseAll) {
onToggleCollapseAll(allCollapsed);
}
this._setGroupsCollapsedState(groups, allCollapsed);
this._updateIsSomeGroupExpanded();
this.forceUpdate();
}
};
GroupedListBase.prototype._setGroupsCollapsedState = function (groups,
isCollapsed) {
for (var groupIndex = 0; groupIndex < groups.length; groupIndex++) {
groups[groupIndex].isCollapsed = isCollapsed;
}
};
GroupedListBase.prototype._returnOne = function () {
return 1;
};
GroupedListBase.prototype._getGroupKey = function (group, index) {
return 'group-' + (group && group.key ? group.key : String(index));
};
GroupedListBase.prototype._getGroupNestingDepth = function () {
var groups = this.state.groups;
var level = 0;
level++;
}
return level;
};
GroupedListBase.prototype._forceListUpdates = function (groups) {
this.setState({
version: {},
});
};
GroupedListBase.prototype._computeIsSomeGroupExpanded = function (groups) {
var _this = this;
return !!(groups &&
groups.some(function (group) { return (group.children ?
_this._computeIsSomeGroupExpanded(group.children) : !group.isCollapsed); }));
};
GroupedListBase.prototype._updateIsSomeGroupExpanded = function () {
var groups = this.state.groups;
var onGroupExpandStateChanged = this.props.onGroupExpandStateChanged;
var newIsSomeGroupExpanded = this._computeIsSomeGroupExpanded(groups);
if (this._isSomeGroupExpanded !== newIsSomeGroupExpanded) {
if (onGroupExpandStateChanged) {
onGroupExpandStateChanged(newIsSomeGroupExpanded);
}
this._isSomeGroupExpanded = newIsSomeGroupExpanded;
}
};
GroupedListBase.defaultProps = {
selectionMode: Selection_1.SelectionMode.multiple,
isHeaderVisible: true,
groupProps: {},
compact: false,
};
return GroupedListBase;
exports.GroupedListBase = GroupedListBase;
//# sourceMappingURL=GroupedList.base.js.map
/***/ }),
/***/ 41308:
"use strict";

exports.GroupedList = void 0;
var GroupedList_styles_1 = __webpack_require__(2320);
var GroupedList_base_1 = __webpack_require__(60490);
exports.GroupedList = Utilities_1.styled(GroupedList_base_1.GroupedListBase,
GroupedList_styles_1.getStyles, undefined, {
scope: 'GroupedList',
});
//# sourceMappingURL=GroupedList.js.map
/***/ }),
/***/ 2320:
"use strict";

root: 'ms-GroupedList',
compact: 'ms-GroupedList--Compact',
group: 'ms-GroupedList-group',
link: 'ms-Link',
listCell: 'ms-List-cell',
};
var beziers = {
easeInOutSine: 'cubic-bezier(0.445, 0.050, 0.550, 0.950)',
};
var _a, _b;
var theme = props.theme, className = props.className, compact = props.compact;
return {
root: [
classNames.root,
theme.fonts.small,
{
_a["." + classNames.listCell] = {
minHeight: 38, // be consistent with DetailsList styles
},
_a),
},
compact && [
classNames.compact,
{
_b["." + classNames.listCell] = {
minHeight: 32, // be consistent with DetailsList styles
},
_b),
},
],
className,
],
group: [
classNames.group,
{
transition: "background-color " +
Styling_1.AnimationVariables.durationValue2 + " " + beziers.easeInOutSine,
},
],
groupIsDropping: {
},
};
};
//# sourceMappingURL=GroupedList.styles.js.map
/***/ }),
/***/ 83850:
"use strict";

exports.CollapseAllVisibility = void 0;
/**
* {@docCategory GroupedList}
*/
var CollapseAllVisibility;
(function (CollapseAllVisibility) {
CollapseAllVisibility[CollapseAllVisibility["hidden"] = 0] = "hidden";
CollapseAllVisibility[CollapseAllVisibility["visible"] = 1] = "visible";
})(CollapseAllVisibility = exports.CollapseAllVisibility ||
(exports.CollapseAllVisibility = {}));
//# sourceMappingURL=GroupedList.types.js.map
/***/ }),
/***/ 79462:
"use strict";

exports.GroupedListSection = void 0;
var GroupHeader_1 = __webpack_require__(35761);
var GroupShowAll_1 = __webpack_require__(49455);
var GroupFooter_1 = __webpack_require__(98194);
var DEFAULT_DROPPING_CSS_CLASS = 'is-dropping';
var GroupedListSection = /** @class */ (function (_super) {
tslib_1.__extends(GroupedListSection, _super);
function GroupedListSection(props) {
_this._subGroupRefs = {};
_this._droppingClassName = '';
_this._onRenderGroupHeader = function (props) {
return React.createElement(GroupHeader_1.GroupHeader,
};
_this._onRenderGroupShowAll = function (props) {
return React.createElement(GroupShowAll_1.GroupShowAll,
};
_this._onRenderGroupFooter = function (props) {
return React.createElement(GroupFooter_1.GroupFooter,
};
_this._renderSubGroup = function (subGroup, subGroupIndex) {
var _a = _this.props, dragDropEvents = _a.dragDropEvents,
dragDropHelper = _a.dragDropHelper, eventsToRegister = _a.eventsToRegister,
getGroupItemLimit = _a.getGroupItemLimit, groupNestingDepth = _a.groupNestingDepth,
groupProps = _a.groupProps, items = _a.items, headerProps = _a.headerProps,
showAllProps = _a.showAllProps, footerProps = _a.footerProps, listProps =
_a.listProps, onRenderCell = _a.onRenderCell, selection = _a.selection,
selectionMode = _a.selectionMode, viewport = _a.viewport, onRenderGroupHeader =
_a.onRenderGroupHeader, onRenderGroupShowAll = _a.onRenderGroupShowAll,
onRenderGroupFooter = _a.onRenderGroupFooter, onShouldVirtualize =
_a.onShouldVirtualize, group = _a.group, compact = _a.compact;
var nestingDepth = subGroup.level ? subGroup.level + 1 :
groupNestingDepth;
return !subGroup || subGroup.count > 0 || (groupProps &&
groupProps.showEmptyGroups) ? (React.createElement(GroupedListSection, { ref:
function (ref) { return (_this._subGroupRefs['subGroup_' + subGroupIndex] =
ref); }, key: _this._getGroupKey(subGroup, subGroupIndex), dragDropEvents:
dragDropEvents, dragDropHelper: dragDropHelper, eventsToRegister: eventsToRegister,
footerProps: footerProps, getGroupItemLimit: getGroupItemLimit, group: subGroup,
groupIndex: subGroupIndex, groupNestingDepth: nestingDepth, groupProps: groupProps,
headerProps: headerProps, items: items, listProps: listProps, onRenderCell:
onRenderCell, selection: selection, selectionMode: selectionMode, showAllProps:
showAllProps, viewport: viewport, onRenderGroupHeader: onRenderGroupHeader,
onRenderGroupShowAll: onRenderGroupShowAll, onRenderGroupFooter:
onRenderGroupFooter, onShouldVirtualize: onShouldVirtualize, groups: group ?
group.children : [], compact: compact })) : null;
};
/**
* collect all the data we need to enable drag/drop for a group
*/
_this._getGroupDragDropOptions = function () {
var _a = _this.props, group = _a.group, groupIndex = _a.groupIndex,
dragDropEvents = _a.dragDropEvents, eventsToRegister = _a.eventsToRegister;
var options = {
eventMap: eventsToRegister,
selectionIndex: -1,
context: { data: group, index: groupIndex, isGroup: true },
updateDropState: _this._updateDroppingState,
canDrag: dragDropEvents.canDrag,
canDrop: dragDropEvents.canDrop,
onDrop: dragDropEvents.onDrop,
onDragStart: dragDropEvents.onDragStart,
onDragEnter: dragDropEvents.onDragEnter,
onDragLeave: dragDropEvents.onDragLeave,
onDragEnd: dragDropEvents.onDragEnd,
onDragOver: dragDropEvents.onDragOver,
};
return options;
};
/**
* update groupIsDropping state based on the input value, which is used to
change style during drag and drop
*
* @param newValue - new isDropping state value
* @param event - the event trigger dropping state change which can be
dragenter, dragleave etc
*/
_this._updateDroppingState = function (newIsDropping, event) {
var isDropping = _this.state.isDropping;
var _a = _this.props, dragDropEvents = _a.dragDropEvents, group =
_a.group;
if (isDropping !== newIsDropping) {
if (isDropping) {
if (dragDropEvents && dragDropEvents.onDragLeave) {
dragDropEvents.onDragLeave(group, event);
}
}
else {
if (dragDropEvents && dragDropEvents.onDragEnter) {
_this._droppingClassName =
dragDropEvents.onDragEnter(group, event);
}
}
_this.setState({ isDropping: newIsDropping });
}
};
var selection = props.selection, group = props.group;
_this._id = Utilities_1.getId('GroupedListSection');
_this.state = {
isDropping: false,
isSelected: selection && group ?
selection.isRangeSelected(group.startIndex, group.count) : false,
};
return _this;
}
GroupedListSection.prototype.componentDidMount = function () {
var _a = this.props, dragDropHelper = _a.dragDropHelper, selection =
_a.selection;
if (dragDropHelper && this._root.current) {
dragDropHelper.subscribe(this._root.current, this._events,
this._getGroupDragDropOptions());
}
if (selection) {
this._onSelectionChange);
}
};
GroupedListSection.prototype.componentWillUnmount = function () {
}
};
GroupedListSection.prototype.componentDidUpdate = function (previousProps) {
if (this.props.group !== previousProps.group ||
this.props.groupIndex !== previousProps.groupIndex ||
this.props.dragDropHelper !== previousProps.dragDropHelper) {
}
if (this.props.dragDropHelper && this._root.current) {
this._getGroupDragDropOptions());
}
}
};
GroupedListSection.prototype.render = function () {
var _a = this.props, getGroupItemLimit = _a.getGroupItemLimit, group =
_a.group, groupIndex = _a.groupIndex, headerProps = _a.headerProps, showAllProps =
_a.showAllProps, footerProps = _a.footerProps, viewport = _a.viewport,
selectionMode = _a.selectionMode, _b = _a.onRenderGroupHeader, onRenderGroupHeader
= _b === void 0 ? this._onRenderGroupHeader : _b, _c = _a.onRenderGroupShowAll,
onRenderGroupShowAll = _c === void 0 ? this._onRenderGroupShowAll : _c, _d =
_a.onRenderGroupFooter, onRenderGroupFooter = _d === void 0 ?
this._onRenderGroupFooter : _d, onShouldVirtualize = _a.onShouldVirtualize,
groupedListClassNames = _a.groupedListClassNames, groups = _a.groups, compact =
_a.compact, _e = _a.listProps, listProps = _e === void 0 ? {} : _e;
var isSelected = this.state.isSelected;
var renderCount = group && getGroupItemLimit ? getGroupItemLimit(group) :
Infinity;
var isShowAllVisible = group &&
!group.children &&
!group.isCollapsed &&
!group.isShowingAll &&
(group.count > renderCount || group.hasMoreData);
var hasNestedGroups = group && group.children && group.children.length > 0;
var version = listProps.version;
var dividerProps = {
group: group,
groupIndex: groupIndex,
groupLevel: group ? group.level : 0,
selected: isSelected,
viewport: viewport,
groups: groups,
compact: compact,
};
var ariaControlsProps = {
groupedListId: this._id,
ariaSetSize: groups ? groups.length : undefined,
ariaPosInSet: groupIndex !== undefined ? groupIndex + 1 : undefined,
};
var groupHeaderProps =
tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, headerProps), dividerProps),
ariaControlsProps);
var groupShowAllProps = tslib_1.__assign(tslib_1.__assign({},
showAllProps), dividerProps);
var groupFooterProps = tslib_1.__assign(tslib_1.__assign({}, footerProps),
dividerProps);
var isDraggable = !!this.props.dragDropHelper &&
this._getGroupDragDropOptions().canDrag(group) &&
!!this.props.dragDropEvents.canDragGroups;
return (React.createElement("div", tslib_1.__assign({ ref: this._root },
(isDraggable && { draggable: true }), { className:
Utilities_1.css(groupedListClassNames && groupedListClassNames.group,
this._getDroppingClassName()), role: "presentation" }),
onRenderGroupHeader(groupHeaderProps, this._onRenderGroupHeader),
group && group.isCollapsed ? null : hasNestedGroups ?
(React.createElement(List_1.List, { role: "presentation", ref: this._list, items:
group ? group.children : [], onRenderCell: this._renderSubGroup,
getItemCountForPage: this._returnOne, onShouldVirtualize: onShouldVirtualize,
version: version, id: this._id })) : (this._onRenderGroup(renderCount)),
group && group.isCollapsed
? null
: isShowAllVisible && onRenderGroupShowAll(groupShowAllProps,
this._onRenderGroupShowAll),
onRenderGroupFooter(groupFooterProps, this._onRenderGroupFooter)));
};
GroupedListSection.prototype.forceUpdate = function () {
this.forceListUpdate();
};
GroupedListSection.prototype.forceListUpdate = function () {
var group = this.props.group;
this._list.current.forceUpdate();
if (group && group.children && group.children.length > 0) {
var subGroupCount = group.children.length;
for (var i = 0; i < subGroupCount; i++) {
var subGroup = this._list.current.pageRefs['subGroup_' +
String(i)];
if (subGroup) {
subGroup.forceListUpdate();
}
}
}
}
else {
var subGroup = this._subGroupRefs['subGroup_' + String(0)];
if (subGroup) {
subGroup.forceListUpdate();
}
}
};
GroupedListSection.prototype._onSelectionChange = function () {
var _a = this.props, group = _a.group, selection = _a.selection;
if (selection && group) {
var isSelected = selection.isRangeSelected(group.startIndex,
group.count);
if (isSelected !== this.state.isSelected) {
this.setState({ isSelected: isSelected });
}
}
};
GroupedListSection.prototype._onRenderGroupCell = function (onRenderCell,
groupNestingDepth, group) {
return function (item, itemIndex) {
return onRenderCell(groupNestingDepth, item, itemIndex, group);
};
};
GroupedListSection.prototype._onRenderGroup = function (renderCount) {
var _a = this.props, group = _a.group, items = _a.items, onRenderCell =
_a.onRenderCell, listProps = _a.listProps, groupNestingDepth =
_a.groupNestingDepth, onShouldVirtualize = _a.onShouldVirtualize, groupProps =
_a.groupProps;
var count = group && !group.isShowingAll ? group.count : items.length;
var startIndex = group ? group.startIndex : 0;
return (React.createElement(List_1.List, tslib_1.__assign({ role:
groupProps && groupProps.role ? groupProps.role : 'rowgroup', "aria-label": group
=== null || group === void 0 ? void 0 : group.name, items: items, onRenderCell:
this._onRenderGroupCell(onRenderCell, groupNestingDepth, group), ref: this._list,
renderCount: Math.min(count, renderCount), startIndex: startIndex,
onShouldVirtualize: onShouldVirtualize, id: this._id }, listProps)));
};
GroupedListSection.prototype._returnOne = function () {
return 1;
};
GroupedListSection.prototype._getGroupKey = function (group, index) {
return 'group-' + (group && group.key ? group.key : String(group.level) +
String(index));
};
/**
* get the correct css class to reflect the dropping state for a given group
*
* If the group is the current drop target, return the default dropping class
name
* Otherwise, return '';
*
*/
GroupedListSection.prototype._getDroppingClassName = function () {
var isDropping = this.state.isDropping;
var _a = this.props, group = _a.group, groupedListClassNames =
_a.groupedListClassNames;
isDropping = !!(group && isDropping);
return Utilities_1.css(isDropping && this._droppingClassName, isDropping &&
DEFAULT_DROPPING_CSS_CLASS, isDropping && groupedListClassNames &&
groupedListClassNames.groupIsDropping);
};
return GroupedListSection;
exports.GroupedListSection = GroupedListSection;
//# sourceMappingURL=GroupedListSection.js.map
/***/ }),
/***/ 91149:
"use strict";

exports.GroupSpacer = void 0;
Object.defineProperty(exports, "GroupSpacer", ({ enumerable: true, get: function ()
{ return GroupSpacer_1.GroupSpacer; } }));
/***/ }),
/***/ 52540:
"use strict";

exports.CardCallout = void 0;
var CardCallout = function (props) {
var _a = props.gapSpace, gapSpace = _a === void 0 ? 0 : _a, _b =
props.directionalHint, directionalHint = _b === void 0 ?
DirectionalHint_1.DirectionalHint.bottomLeftEdge : _b, directionalHintFixed =
props.directionalHintFixed, targetElement = props.targetElement, firstFocus =
props.firstFocus, trapFocus = props.trapFocus, onLeave = props.onLeave, className =
props.className, finalHeight = props.finalHeight, content = props.content,
calloutProps = props.calloutProps;
var mergedCalloutProps = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({},
Utilities_1.getNativeProps(props, Utilities_1.divProperties)), { className:
className, target: targetElement, isBeakVisible: false, directionalHint:
directionalHint, directionalHintFixed: directionalHintFixed, finalHeight:
finalHeight, minPagePadding: 24, onDismiss: onLeave, gapSpace: gapSpace }),
calloutProps);
return (React.createElement(React.Fragment, null, trapFocus ?
(React.createElement(Callout_1.FocusTrapCallout, tslib_1.__assign({},
mergedCalloutProps, { focusTrapProps: {
forceFocusInsideTrap: false,
isClickableOutsideFocusTrap: true,
disableFirstFocus: !firstFocus,
} }), content)) : (React.createElement(Callout_1.Callout,
tslib_1.__assign({}, mergedCalloutProps), content))));
};
exports.CardCallout = CardCallout;
//# sourceMappingURL=CardCallout.js.map
/***/ }),
/***/ 49849:
"use strict";

exports.ExpandingCardBase = void 0;
var ExpandingCard_types_1 = __webpack_require__(51024);
var CardCallout_1 = __webpack_require__(52540);
var ExpandingCardBase = /** @class */ (function (_super) {
tslib_1.__extends(ExpandingCardBase, _super);
function ExpandingCardBase(props) {
_this._expandedElem = React.createRef();
if (ev.which === Utilities_1.KeyCodes.escape) {
_this.props.onLeave && _this.props.onLeave(ev);
}
};
_this._onRenderCompactCard = function () {
_this._classNames.compactCard },
_this.props.onRenderCompactCard(_this.props.renderData));
};
_this._onRenderExpandedCard = function () {
// firstFrameRendered helps in initially setting height of expanded
card to 1px, even if mode prop is set to
// ExpandingCardMode.expanded on first render. This is to make sure
transition animation takes place.
!_this.state.firstFrameRendered &&
_this._async.requestAnimationFrame(function () {
_this.setState({
firstFrameRendered: true,
});
});
_this._classNames.expandedCard, ref: _this._expandedElem },
_this._classNames.expandedCardScroll }, _this.props.onRenderExpandedCard &&
_this.props.onRenderExpandedCard(_this.props.renderData))));
};
_this._checkNeedsScroll = function () {
var expandedCardHeight = _this.props.expandedCardHeight;
_this._async.requestAnimationFrame(function () {
if (_this._expandedElem.current &&
_this._expandedElem.current.scrollHeight >= expandedCardHeight) {
_this.setState({
needsScroll: true,
});
}
});
};
_this.state = {
firstFrameRendered: false,
needsScroll: false,
};
return _this;
}
ExpandingCardBase.prototype.componentDidMount = function () {
this._checkNeedsScroll();
};
ExpandingCardBase.prototype.componentWillUnmount = function () {
};
ExpandingCardBase.prototype.render = function () {
var _a = this.props, styles = _a.styles, compactCardHeight =
_a.compactCardHeight, expandedCardHeight = _a.expandedCardHeight, theme = _a.theme,
mode = _a.mode, className = _a.className;
var _b = this.state, needsScroll = _b.needsScroll, firstFrameRendered =
_b.firstFrameRendered;
var finalHeight = compactCardHeight + expandedCardHeight;
theme: theme,
compactCardHeight: compactCardHeight,
expandedCardHeight: expandedCardHeight,
needsScroll: needsScroll,
expandedCardFirstFrameRendered: mode ===
ExpandingCard_types_1.ExpandingCardMode.expanded && firstFrameRendered,
});
var content = (React.createElement("div", { onMouseEnter:
this.props.onEnter, onMouseLeave: this.props.onLeave, onKeyDown: this._onKeyDown },
this._onRenderCompactCard(),
this._onRenderExpandedCard()));
return (React.createElement(CardCallout_1.CardCallout, tslib_1.__assign({},
this.props, { content: content, finalHeight: finalHeight, className:
this._classNames.root })));
};
ExpandingCardBase.defaultProps = {
compactCardHeight: 156,
expandedCardHeight: 384,
directionalHintFixed: true,
};
return ExpandingCardBase;
exports.ExpandingCardBase = ExpandingCardBase;
//# sourceMappingURL=ExpandingCard.base.js.map
/***/ }),
/***/ 84730:
"use strict";

exports.ExpandingCard = void 0;
var ExpandingCard_styles_1 = __webpack_require__(14018);
var ExpandingCard_base_1 = __webpack_require__(49849);
exports.ExpandingCard = Utilities_1.styled(ExpandingCard_base_1.ExpandingCardBase,
ExpandingCard_styles_1.getStyles, undefined, {
scope: 'ExpandingCard',
});
//# sourceMappingURL=ExpandingCard.js.map
/***/ }),
/***/ 14018:
"use strict";

root: 'ms-ExpandingCard-root',
compactCard: 'ms-ExpandingCard-compactCard',
expandedCard: 'ms-ExpandingCard-expandedCard',
expandedCardScroll: 'ms-ExpandingCard-expandedCardScrollRegion',
};
var _a;
var theme = props.theme, needsScroll = props.needsScroll,
expandedCardFirstFrameRendered = props.expandedCardFirstFrameRendered,
compactCardHeight = props.compactCardHeight, expandedCardHeight =
props.expandedCardHeight, className = props.className;
return {
root: [
classNames.root,
{
width: 320,
},
_a),
},
className,
],
compactCard: [
classNames.compactCard,
{
pointerEvents: 'auto',
height: compactCardHeight,
},
],
expandedCard: [
classNames.expandedCard,
{
height: 1,
transition: 'height 0.467s cubic-bezier(0.5, 0, 0, 1)',
selectors: {
':before': {
content: '""',
display: 'block',
top: 0,
left: 24,
width: 272,
height: 1,
},
},
},
expandedCardFirstFrameRendered && {
height: expandedCardHeight,
},
],
expandedCardScroll: [
classNames.expandedCardScroll,
needsScroll && {
height: '100%',
overflowY: 'auto',
},
],
};
}
//# sourceMappingURL=ExpandingCard.styles.js.map
/***/ }),
/***/ 51024:
"use strict";

exports.ExpandingCardMode = void 0;
/**
* {@docCategory HoverCard}
*/
var ExpandingCardMode;
(function (ExpandingCardMode) {
/**
* To have top compact card only
*/
ExpandingCardMode[ExpandingCardMode["compact"] = 0] = "compact";
/**
* To have both top compact and bottom expanded card
*/
ExpandingCardMode[ExpandingCardMode["expanded"] = 1] = "expanded";
})(ExpandingCardMode = exports.ExpandingCardMode || (exports.ExpandingCardMode =
{}));
//# sourceMappingURL=ExpandingCard.types.js.map
/***/ }),
/***/ 92045:
"use strict";

exports.HoverCardBase = void 0;
var HoverCard_types_1 = __webpack_require__(93841);
var ExpandingCard_1 = __webpack_require__(84730);
var ExpandingCard_types_1 = __webpack_require__(51024);
var PlainCard_1 = __webpack_require__(64661);
var HoverCardBase = /** @class */ (function (_super) {
tslib_1.__extends(HoverCardBase, _super);
// Constructor
function HoverCardBase(props) {
// The wrapping div that gets the hover events
_this._hoverCard = React.createRef();
_this.dismiss = function (withTimeOut) {
_this._async.clearTimeout(_this._openTimerId);
_this._async.clearTimeout(_this._dismissTimerId);
if (!withTimeOut) {
_this._setDismissedState();
}
else {
_this._dismissTimerId = _this._async.setTimeout(function () {
_this._setDismissedState();
}, _this.props.cardDismissDelay);
}
};
// Show HoverCard
_this._cardOpen = function (ev) {
if (_this._shouldBlockHoverCard() || (ev.type === 'keydown' && !
(ev.which === _this.props.openHotKey))) {
return;
}
if (ev.type === 'mouseenter') {
_this._currentMouseTarget = ev.currentTarget;
}
_this._executeCardOpen(ev);
};
_this._executeCardOpen = function (ev) {
_this._openTimerId = _this._async.setTimeout(function () {
_this.setState(function (prevState) {
if (!prevState.isHoverCardVisible) {
return {
isHoverCardVisible: true,
mode: ExpandingCard_types_1.ExpandingCardMode.compact,
openMode: ev.type === 'keydown' ?
HoverCard_types_1.OpenCardMode.hotKey : HoverCard_types_1.OpenCardMode.hover,
};
}
return prevState;
});
}, _this.props.cardOpenDelay);
};
/**
* Hide HoverCard
* How we dismiss the card depends on where the callback is coming from.
* This is provided by the ìsNativeEvent` argument.
* true: Event is coming from event listeners set up in componentDidMount.
* false: Event is coming from the ònLeave` prop from the HoverCard
component.
*/
_this._cardDismiss = function (isNativeEvent, ev) {
if (isNativeEvent) {
// We expect these to be MouseEvents, If not, return.
if (!(ev instanceof MouseEvent)) {
return;
}
if (ev.type === 'keydown' && ev.which !==
Utilities_1.KeyCodes.escape) {
return;
}
// Dismiss if not sticky and currentTarget is the same element that
mouse last entered
if (!_this.props.sticky && (_this._currentMouseTarget ===
ev.currentTarget || ev.which === Utilities_1.KeyCodes.escape)) {
_this.dismiss(true);
}
}
else {
// If this is a mouseleave event and the component is sticky, do
not dismiss.
if (_this.props.sticky &&
!(ev instanceof MouseEvent) &&
ev.nativeEvent instanceof MouseEvent &&
ev.type === 'mouseleave') {
return;
}
_this.dismiss(true);
}
};
_this._setDismissedState = function () {
_this.setState({
isHoverCardVisible: false,
openMode: HoverCard_types_1.OpenCardMode.hover,
});
};
_this._instantOpenAsExpanded = function (ev) {
_this.setState(function (prevState) {
if (!prevState.isHoverCardVisible) {
return {
isHoverCardVisible: true,
mode: ExpandingCard_types_1.ExpandingCardMode.expanded,
};
}
return prevState;
});
};
_this._setEventListeners = function () {
var _a = _this.props, trapFocus = _a.trapFocus, instantOpenOnClick =
_a.instantOpenOnClick, eventListenerTarget = _a.eventListenerTarget;
var target = eventListenerTarget
? _this._getTargetElement(eventListenerTarget)
: _this._getTargetElement(_this.props.target);
var nativeEventDismiss = _this._nativeDismissEvent;
// target can be undefined if ref isn't available, only assign
// events when defined to avoid throwing exception.
if (target) {
_this._events.on(target, 'mouseenter', _this._cardOpen);
_this._events.on(target, 'mouseleave', nativeEventDismiss);
if (trapFocus) {
_this._events.on(target, 'keydown', _this._cardOpen);
}
else {
_this._events.on(target, 'focus', _this._cardOpen);
_this._events.on(target, 'blur', nativeEventDismiss);
}
if (instantOpenOnClick) {
_this._events.on(target, 'click',
_this._instantOpenAsExpanded);
}
else {
_this._events.on(target, 'mousedown', nativeEventDismiss);
_this._events.on(target, 'keydown', nativeEventDismiss);
}
}
};
_this._nativeDismissEvent = _this._cardDismiss.bind(_this, true);
_this._childDismissEvent = _this._cardDismiss.bind(_this, false);
_this.state = {
isHoverCardVisible: false,
openMode: HoverCard_types_1.OpenCardMode.hover,
};
return _this;
}
HoverCardBase.prototype.componentDidMount = function () {
this._setEventListeners();
};
HoverCardBase.prototype.componentWillUnmount = function () {
};
HoverCardBase.prototype.componentDidUpdate = function (prevProps, prevState) {
var _this = this;
if (prevProps.target !== this.props.target) {
this._events.off();
this._setEventListeners();
}
if (prevState.isHoverCardVisible !== this.state.isHoverCardVisible) {
if (this.state.isHoverCardVisible) {
_this.setState({
mode: ExpandingCard_types_1.ExpandingCardMode.expanded,
}, function () {
_this.props.onCardExpand && _this.props.onCardExpand();
});
}, this.props.expandedCardOpenDelay);
this.props.onCardVisible && this.props.onCardVisible();
}
else {
this.setState({
});
this.props.onCardHide && this.props.onCardHide();
}
}
};
// Render
HoverCardBase.prototype.render = function () {
var _a = this.props, expandingCardProps = _a.expandingCardProps, children =
_a.children, id = _a.id, _b = _a.setAriaDescribedBy, setAriaDescribedBy = _b ===
void 0 ? true : _b, customStyles = _a.styles, theme = _a.theme, className =
_a.className, type = _a.type, plainCardProps = _a.plainCardProps, trapFocus =
_a.trapFocus, setInitialFocus = _a.setInitialFocus;
var _c = this.state, isHoverCardVisible = _c.isHoverCardVisible, mode =
_c.mode, openMode = _c.openMode;
var hoverCardId = id || Utilities_1.getId('hoverCard');
this._classNames = getClassNames(customStyles, {
theme: theme,
});
// Common props for both card types.
var commonCardProps = tslib_1.__assign(tslib_1.__assign({},
Utilities_1.getNativeProps(this.props, Utilities_1.divProperties)), { id:
hoverCardId, trapFocus: !!trapFocus, firstFocus: setInitialFocus || openMode ===
HoverCard_types_1.OpenCardMode.hotKey, targetElement:
this._getTargetElement(this.props.target), onEnter: this._cardOpen, onLeave:
this._childDismissEvent });
var finalExpandedCardProps =
tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, expandingCardProps),
commonCardProps), { mode: mode });
var finalPlainCardProps = tslib_1.__assign(tslib_1.__assign({},
plainCardProps), commonCardProps);
return (React.createElement("div", { className: this._classNames.host, ref:
this._hoverCard, "aria-describedby": setAriaDescribedBy && isHoverCardVisible ?
hoverCardId : undefined, "data-is-focusable": !this.props.target },
children,
isHoverCardVisible &&
(type === HoverCard_types_1.HoverCardType.expanding ?
(React.createElement(ExpandingCard_1.ExpandingCard, tslib_1.__assign({},
finalExpandedCardProps))) : (React.createElement(PlainCard_1.PlainCard,
tslib_1.__assign({}, finalPlainCardProps))))));
};
HoverCardBase.prototype._getTargetElement = function (target) {
switch (typeof target) {
case 'string':
return Utilities_1.getDocument().querySelector(target);
case 'object':
return target;
default:
return this._hoverCard.current || undefined;
}
};
HoverCardBase.prototype._shouldBlockHoverCard = function () {
return !!(this.props.shouldBlockHoverCard &&
this.props.shouldBlockHoverCard());
};
HoverCardBase.defaultProps = {
cardOpenDelay: 500,
cardDismissDelay: 100,
expandedCardOpenDelay: 1500,
instantOpenOnClick: false,
setInitialFocus: false,
openHotKey: Utilities_1.KeyCodes.c,
type: HoverCard_types_1.HoverCardType.expanding,
};
return HoverCardBase;
exports.HoverCardBase = HoverCardBase;
//# sourceMappingURL=HoverCard.base.js.map
/***/ }),
/***/ 48747:
"use strict";

exports.HoverCard = void 0;
var HoverCard_styles_1 = __webpack_require__(95394);
var HoverCard_base_1 = __webpack_require__(92045);
exports.HoverCard = Utilities_1.styled(HoverCard_base_1.HoverCardBase,
HoverCard_styles_1.getStyles, undefined, {
scope: 'HoverCard',
});
//# sourceMappingURL=HoverCard.js.map
/***/ }),
/***/ 95394:
"use strict";

host: 'ms-HoverCard-host',
};
return {
host: [classNames.host, className],
};
}
//# sourceMappingURL=HoverCard.styles.js.map
/***/ }),
/***/ 93841:
"use strict";

exports.HoverCardType = exports.OpenCardMode = void 0;
/**
*/
var OpenCardMode;
(function (OpenCardMode) {
/**
* Open card by hover
*/
OpenCardMode[OpenCardMode["hover"] = 0] = "hover";
/**
* Open card by hot key
*/
OpenCardMode[OpenCardMode["hotKey"] = 1] = "hotKey";
})(OpenCardMode = exports.OpenCardMode || (exports.OpenCardMode = {}));
/**
*/
var HoverCardType;
(function (HoverCardType) {
/**
* Plain card consisting of one part responsive to the size of content.
*/
HoverCardType["plain"] = "PlainCard";
/**
* File card consisting of two parts: compact and expanded. Has some default
sizes if not specified.
*/
HoverCardType["expanding"] = "ExpandingCard";
})(HoverCardType = exports.HoverCardType || (exports.HoverCardType = {}));
//# sourceMappingURL=HoverCard.types.js.map
/***/ }),
/***/ 95353:
"use strict";

exports.PlainCardBase = void 0;
var CardCallout_1 = __webpack_require__(52540);
var PlainCardBase = /** @class */ (function (_super) {
tslib_1.__extends(PlainCardBase, _super);
function PlainCardBase(props) {
_this.props.onLeave && _this.props.onLeave(ev);
}
};
return _this;
}
PlainCardBase.prototype.render = function () {
var _a = this.props, styles = _a.styles, theme = _a.theme, className =
_a.className;
theme: theme,
});
var content = (React.createElement("div", { onMouseEnter:
this.props.onEnter, onMouseLeave: this.props.onLeave, onKeyDown: this._onKeyDown },
this.props.onRenderPlainCard(this.props.renderData)));
return React.createElement(CardCallout_1.CardCallout, tslib_1.__assign({},
this.props, { content: content, className: this._classNames.root }));
};
return PlainCardBase;
exports.PlainCardBase = PlainCardBase;
//# sourceMappingURL=PlainCard.base.js.map
/***/ }),
/***/ 64661:
"use strict";

exports.PlainCard = void 0;
var PlainCard_styles_1 = __webpack_require__(31756);
var PlainCard_base_1 = __webpack_require__(95353);
exports.PlainCard = Utilities_1.styled(PlainCard_base_1.PlainCardBase,
PlainCard_styles_1.getStyles, undefined, {
scope: 'PlainCard',
});
//# sourceMappingURL=PlainCard.js.map
/***/ }),
/***/ 31756:
"use strict";

root: 'ms-PlainCard-root',
};
var _a;
return {
root: [
classNames.root,
{
},
_a),
},
className,
],
};
}
//# sourceMappingURL=PlainCard.styles.js.map
/***/ }),
/***/ 94062:
"use strict";

//# sourceMappingURL=PlainCard.types.js.map
/***/ }),
/***/ 48315:
"use strict";

/***/ }),
/***/ 83103:
"use strict";

exports.getFontIcon = exports.FontIcon = exports.getIconContent = void 0;
var Icon_styles_1 = __webpack_require__(93750);
exports.getIconContent = Utilities_1.memoizeFunction(function (iconName) {
var _a = Styling_1.getIcon(iconName) || {
subset: {},
code: undefined,
}, code = _a.code, subset = _a.subset;
if (!code) {
return null;
}
return {
children: code,
iconClassName: subset.className,
fontFamily: subset.fontFace && subset.fontFace.fontFamily,
mergeImageProps: subset.mergeImageProps,
};
}, undefined, true /*ignoreNullOrUndefinedResult */);
/**
* Fast icon component which only supports font glyphs (not images) and can't be
targeted by customizations.
* To style the icon, use `className` or reference `ms-Icon` in CSS.
* {@docCategory Icon}
*/
var FontIcon = function (props) {
var iconName = props.iconName, className = props.className, _a = props.style,
style = _a === void 0 ? {} : _a;
var iconContent = exports.getIconContent(iconName) || {};
var iconClassName = iconContent.iconClassName, children = iconContent.children,
fontFamily = iconContent.fontFamily, mergeImageProps = iconContent.mergeImageProps;
var nativeProps = Utilities_1.getNativeProps(props,
Utilities_1.htmlElementProperties);
var accessibleName = props['aria-label'] || props.title;
var containerProps = props['aria-label'] || props['aria-labelledby'] ||
props.title
? {
role: mergeImageProps ? undefined : 'img',
}
: {
};
var finalChildren = children;
if (mergeImageProps) {
if (typeof children === 'object' && typeof children.props === 'object' &&
accessibleName) {
finalChildren = React.cloneElement(children, { alt: accessibleName });
}
}
return (React.createElement("i", tslib_1.__assign({ "data-icon-name":
iconName }, containerProps, nativeProps, (mergeImageProps
? {
title: undefined,
'aria-label': undefined,
}
: {}), { className: Utilities_1.css(Icon_styles_1.MS_ICON,
Icon_styles_1.classNames.root, iconClassName, !iconName &&
Icon_styles_1.classNames.placeholder, className),
// Apply the font family this way to ensure it doesn't get overridden by
Fabric Core ms-Icon styles
// https://github.com/microsoft/fluentui/issues/10449
style: tslib_1.__assign({ fontFamily: fontFamily }, style) }),
finalChildren));
};
exports.FontIcon = FontIcon;
/**
* Memoized helper for rendering a FontIcon.
* @param iconName - The name of the icon to use from the icon font.
* @param className - Class name for styling the icon.
* @param ariaLabel - Label for the icon for the benefit of screen readers.
*/
exports.getFontIcon = Utilities_1.memoizeFunction(function (iconName, className,
ariaLabel) {
return exports.FontIcon({ iconName: iconName, className: className, 'aria-
label': ariaLabel });
});
//# sourceMappingURL=FontIcon.js.map
/***/ }),
/***/ 3162:
"use strict";

exports.IconBase = void 0;
var Icon_types_1 = __webpack_require__(89399);
var Image_types_1 = __webpack_require__(4972);
var FontIcon_1 = __webpack_require__(83103);
// Icon is used a lot by other components.
// It's likely to see expected cases which pass different className to the
Icon.
// Therefore setting a larger cache size.
cacheSize: 100,
});
var IconBase = /** @class */ (function (_super) {
tslib_1.__extends(IconBase, _super);
function IconBase(props) {
_this._onImageLoadingStateChange = function (state) {
if (_this.props.imageProps &&
_this.props.imageProps.onLoadingStateChange) {
_this.props.imageProps.onLoadingStateChange(state);
}
if (state === Image_types_1.ImageLoadState.error) {
_this.setState({ imageLoadError: true });
}
};
_this.state = {
imageLoadError: false,
};
return _this;
}
IconBase.prototype.render = function () {
var _a = this.props, children = _a.children, className = _a.className,
styles = _a.styles, iconName = _a.iconName, imageErrorAs = _a.imageErrorAs, theme =
_a.theme;
var isPlaceholder = typeof iconName === 'string' && iconName.length === 0;
var isImage =
!!this.props.imageProps || this.props.iconType ===
Icon_types_1.IconType.image || this.props.iconType === Icon_types_1.IconType.Image;
var iconContent = FontIcon_1.getIconContent(iconName) || {};
var iconClassName = iconContent.iconClassName, iconContentChildren =
iconContent.children, mergeImageProps = iconContent.mergeImageProps;
theme: theme,
iconClassName: iconClassName,
isImage: isImage,
isPlaceholder: isPlaceholder,
});
var RootType = isImage ? 'span' : 'i';
'aria-label',
]);
var imageLoadError = this.state.imageLoadError;
var imageProps = tslib_1.__assign(tslib_1.__assign({},
this.props.imageProps), { onLoadingStateChange: this._onImageLoadingStateChange });
var ImageType = (imageLoadError && imageErrorAs) || Image_1.Image;
var ariaLabel = this.props['aria-label'] || this.props.ariaLabel;
var accessibleName = imageProps.alt || ariaLabel || this.props.title;
var hasName = !!(accessibleName ||
this.props['aria-labelledby'] ||
imageProps['aria-label'] ||
imageProps['aria-labelledby']);
var containerProps = hasName
? {
role: isImage || mergeImageProps ? undefined : 'img',
'aria-label': isImage || mergeImageProps ? undefined :
accessibleName,
}
: {
};
var finalIconContentChildren = iconContentChildren;
if (mergeImageProps && iconContentChildren && typeof iconContentChildren
=== 'object' && accessibleName) {
finalIconContentChildren = React.cloneElement(iconContentChildren, {
alt: accessibleName,
});
}
return (React.createElement(RootType, tslib_1.__assign({ "data-icon-name":
iconName }, containerProps, nativeProps, (mergeImageProps
? {
title: undefined,
'aria-label': undefined,
}
: {}), { className: classNames.root }), isImage ?
React.createElement(ImageType, tslib_1.__assign({}, imageProps)) : children ||
finalIconContentChildren));
};
return IconBase;
exports.IconBase = IconBase;
//# sourceMappingURL=Icon.base.js.map
/***/ }),
/***/ 80775:
"use strict";

exports.Icon = void 0;
var Icon_base_1 = __webpack_require__(3162);
/**
* Legacy Icon component which can be targeted by customization. It's recommended
to use `FontIcon`
* or ÌmageIcon` instead, especially in scenarios where rendering performance is
important.
*/
exports.Icon = Utilities_1.styled(Icon_base_1.IconBase, Icon_styles_1.getStyles,
undefined, {
scope: 'Icon',
}, true);
exports.Icon.displayName = 'Icon';
//# sourceMappingURL=Icon.js.map
/***/ }),
/***/ 93750:
"use strict";

exports.getStyles = exports.MS_ICON = exports.classNames = void 0;
/** Class names used in themeable and non-themeable Icon components */
exports.classNames = Styling_1.mergeStyleSets({
root: {
},
placeholder: [
'ms-Icon-placeHolder',
{
width: '1em',
},
],
image: [
'ms-Icon-imageContainer',
{
overflow: 'hidden',
},
],
});
/** Class name used only in non-themeable Icon components */
exports.MS_ICON = 'ms-Icon';
var className = props.className, iconClassName = props.iconClassName,
isPlaceholder = props.isPlaceholder, isImage = props.isImage, styles =
props.styles;
return {
root: [
isPlaceholder && exports.classNames.placeholder,
exports.classNames.root,
isImage && exports.classNames.image,
iconClassName,
className,
styles && styles.root,
styles && styles.imageContainer,
],
};
};
//# sourceMappingURL=Icon.styles.js.map
/***/ }),
/***/ 89399:
"use strict";

exports.IconType = void 0;
/**
* @deprecated Icon type is inferred based on presence of ÌIconProps.imageProps`
*/
var IconType;
(function (IconType) {
/**
* Render using the fabric icon font.
* @deprecated Icon type is inferred based on presence of
ÌIconProps.imageProps`
*/
IconType[IconType["default"] = 0] = "default";
/**
* Render using an image, where imageProps would be used.
*/
IconType[IconType["image"] = 1] = "image";
/**
*/
IconType[IconType["Default"] = 100000] = "Default";
/**
*/
IconType[IconType["Image"] = 100001] = "Image";
})(IconType = exports.IconType || (exports.IconType = {}));
//# sourceMappingURL=Icon.types.js.map
/***/ }),
/***/ 48815:
"use strict";

exports.ImageIcon = void 0;
/**
* Fast icon component which only supports images (not font glyphs) and can't be
targeted by customizations.
* To style the icon, use `className` or reference `ms-Icon` in CSS.
*/
var ImageIcon = function (props) {
var className = props.className, imageProps = props.imageProps;
'aria-label',
'aria-labelledby',
'title',
'aria-describedby',
]);
var altText = imageProps.alt || props['aria-label'];
var hasName = altText ||
props['aria-labelledby'] ||
props.title ||
imageProps['aria-label'] ||
imageProps['aria-labelledby'] ||
imageProps.title;
// move naming or describing attributes from the container (where they are
invalid) to the image
var imageNameProps = {
'aria-labelledby': props['aria-labelledby'],
'aria-describedby': props['aria-describedby'],
title: props.title,
};
var containerProps = hasName
? {}
: {
};
return (React.createElement("div", tslib_1.__assign({}, containerProps,
nativeProps, { className: Utilities_1.css(Icon_styles_1.MS_ICON,
Icon_styles_1.classNames.root, Icon_styles_1.classNames.image, className) }),
React.createElement(Image_1.Image, tslib_1.__assign({}, imageNameProps,
imageProps, { alt: hasName ? altText : '' }))));
};
exports.ImageIcon = ImageIcon;
//# sourceMappingURL=ImageIcon.js.map
/***/ }),
/***/ 86028:
"use strict";

/***/ }),
/***/ 57683:
"use strict";

exports.ImageBase = void 0;
var Image_types_1 = __webpack_require__(4972);
var SVG_REGEX = /\.svg$/i;
var KEY_PREFIX = 'fabricImage';
function useLoadState(props, imageElement) {
var onLoadingStateChange = props.onLoadingStateChange, onLoad = props.onLoad,
onError = props.onError, src = props.src;
var _a = React.useState(Image_types_1.ImageLoadState.notLoaded), loadState =
_a[0], setLoadState = _a[1];
// If the src property changes, reset the load state
// (does nothing if the load state is already notLoaded)
setLoadState(Image_types_1.ImageLoadState.notLoaded);
}, [src]);
// eslint-disable-next-line react-hooks/exhaustive-deps -- intended to run
every render
if (loadState === Image_types_1.ImageLoadState.notLoaded) {
// testing if naturalWidth and naturalHeight are greater than zero is
better than checking
// .complete, because .complete will also be set to true if the image
breaks. However,
// for some browsers, SVG images do not have a naturalWidth or
naturalHeight, so fall back
// to checking .complete for these images.
var isLoaded = imageElement.current
? (src && imageElement.current.naturalWidth > 0 &&
imageElement.current.naturalHeight > 0) ||
(imageElement.current.complete && SVG_REGEX.test(src))
: false;
if (isLoaded) {
setLoadState(Image_types_1.ImageLoadState.loaded);
}
}
});
onLoadingStateChange === null || onLoadingStateChange === void 0 ? void 0 :
onLoadingStateChange(loadState);
when loadState changes
}, [loadState]);
var onImageLoaded = React.useCallback(function (ev) {
onLoad === null || onLoad === void 0 ? void 0 : onLoad(ev);
if (src) {
setLoadState(Image_types_1.ImageLoadState.loaded);
}
}, [src, onLoad]);
var onImageError = React.useCallback(function (ev) {
onError === null || onError === void 0 ? void 0 : onError(ev);
setLoadState(Image_types_1.ImageLoadState.error);
}, [onError]);
return [loadState, onImageLoaded, onImageError];
}
exports.ImageBase = React.forwardRef(function (props, forwardedRef) {
var frameElement = React.useRef();
var imageElement = React.useRef();
var _a = useLoadState(props, imageElement), loadState = _a[0], onImageLoaded =
_a[1], onImageError = _a[2];
var imageProps = Utilities_1.getNativeProps(props, Utilities_1.imgProperties, [
'width',
'height',
]);
var src = props.src, alt = props.alt, width = props.width, height =
props.height, _b = props.shouldFadeIn, shouldFadeIn = _b === void 0 ? true : _b,
shouldStartVisible = props.shouldStartVisible, className = props.className,
imageFit = props.imageFit, role = props.role, maximizeFrame = props.maximizeFrame,
styles = props.styles, theme = props.theme, loading = props.loading;
var coverStyle = useCoverStyle(props, loadState, imageElement, frameElement);
theme: theme,
width: width,
height: height,
maximizeFrame: maximizeFrame,
shouldFadeIn: shouldFadeIn,
shouldStartVisible: shouldStartVisible,
isLoaded: loadState === Image_types_1.ImageLoadState.loaded || (loadState
=== Image_types_1.ImageLoadState.notLoaded && props.shouldStartVisible),
isLandscape: coverStyle === Image_types_1.ImageCoverStyle.landscape,
isCenter: imageFit === Image_types_1.ImageFit.center,
isCenterContain: imageFit === Image_types_1.ImageFit.centerContain,
isCenterCover: imageFit === Image_types_1.ImageFit.centerCover,
isContain: imageFit === Image_types_1.ImageFit.contain,
isCover: imageFit === Image_types_1.ImageFit.cover,
isNone: imageFit === Image_types_1.ImageFit.none,
isError: loadState === Image_types_1.ImageLoadState.error,
isNotImageFit: imageFit === undefined,
});
// If image dimensions aren't specified, the natural size of the image is used.
return (React.createElement("div", { className: classNames.root, style:
{ width: width, height: height }, ref: frameElement },
React.createElement("img", tslib_1.__assign({}, imageProps, { onLoad:
onImageLoaded, onError: onImageError, key: KEY_PREFIX + props.src || '', className:
classNames.image, ref: react_hooks_1.useMergedRefs(imageElement, forwardedRef),
src: src, alt: alt, role: role, loading: loading }))));
});
exports.ImageBase.displayName = 'ImageBase';
function useCoverStyle(props, loadState, imageElement, frameElement) {
var previousLoadState = React.useRef(loadState);
var coverStyle = React.useRef();
if (coverStyle === undefined ||
(previousLoadState.current === Image_types_1.ImageLoadState.notLoaded &&
loadState === Image_types_1.ImageLoadState.loaded)) {
coverStyle.current = computeCoverStyle(props, loadState, imageElement,
frameElement);
}
previousLoadState.current = loadState;
return coverStyle.current;
}
function computeCoverStyle(props, loadState, imageElement, frameElement) {
var imageFit = props.imageFit, width = props.width, height = props.height;
// Do not compute cover style if it was already specified in props
if (props.coverStyle !== undefined) {
return props.coverStyle;
}
else if (loadState === Image_types_1.ImageLoadState.loaded &&
(imageFit === Image_types_1.ImageFit.cover ||
imageFit === Image_types_1.ImageFit.contain ||
imageFit === Image_types_1.ImageFit.centerContain ||
imageFit === Image_types_1.ImageFit.centerCover) &&
imageElement.current &&
frameElement.current) {
// Determine the desired ratio using the width and height props.
// If those props aren't available, measure measure the frame.
var desiredRatio = void 0;
if (typeof width === 'number' &&
typeof height === 'number' &&
imageFit !== Image_types_1.ImageFit.centerContain &&
imageFit !== Image_types_1.ImageFit.centerCover) {
desiredRatio = width / height;
}
else {
desiredRatio = frameElement.current.clientWidth /
frameElement.current.clientHeight;
}
// Examine the source image to determine its original ratio.
var naturalRatio = imageElement.current.naturalWidth /
imageElement.current.naturalHeight;
// Should we crop from the top or the sides?
if (naturalRatio > desiredRatio) {
return Image_types_1.ImageCoverStyle.landscape;
}
}
return Image_types_1.ImageCoverStyle.portrait;
}
//# sourceMappingURL=Image.base.js.map
/***/ }),
/***/ 51705:
"use strict";

exports.Image = void 0;
var Image_base_1 = __webpack_require__(57683);
var Image_styles_1 = __webpack_require__(46907);
exports.Image = Utilities_1.styled(Image_base_1.ImageBase,
Image_styles_1.getStyles, undefined, {
scope: 'Image',
}, true);
exports.Image.displayName = 'Image';
//# sourceMappingURL=Image.js.map
/***/ }),
/***/ 46907:
"use strict";

root: 'ms-Image',
rootMaximizeFrame: 'ms-Image--maximizeFrame',
image: 'ms-Image-image',
imageCenter: 'ms-Image-image--center',
imageContain: 'ms-Image-image--contain',
imageCover: 'ms-Image-image--cover',
imageCenterContain: 'ms-Image-image--centerContain',
imageCenterCover: 'ms-Image-image--centerCover',
imageNone: 'ms-Image-image--none',
imageLandscape: 'ms-Image-image--landscape',
imagePortrait: 'ms-Image-image--portrait',
};
var className = props.className, width = props.width, height = props.height,
maximizeFrame = props.maximizeFrame, isLoaded = props.isLoaded, shouldFadeIn =
props.shouldFadeIn, shouldStartVisible = props.shouldStartVisible, isLandscape =
props.isLandscape, isCenter = props.isCenter, isContain = props.isContain, isCover
= props.isCover, isCenterContain = props.isCenterContain, isCenterCover =
props.isCenterCover, isNone = props.isNone, isError = props.isError, isNotImageFit
= props.isNotImageFit, theme = props.theme;
var ImageFitStyles = {
left: '50% /* @noflip */',
top: '50%',
transform: 'translate(-50%,-50%)', // @todo test RTL renders transform:
translate(50%,-50%);
};
// Cut the mustard using msMaxTouchPoints to detect IE11 which does not support
CSS object-fit
var window = Utilities_1.getWindow();
var supportsObjectFit = window !== undefined &&
window.navigator.msMaxTouchPoints === undefined;
var fallbackObjectFitStyles = (isContain && isLandscape) || (isCover && !
isLandscape)
? { width: '100%', height: 'auto' }
: { width: 'auto', height: '100%' };
return {
root: [
classNames.root,
theme.fonts.medium,
{
overflow: 'hidden',
},
maximizeFrame && [
classNames.rootMaximizeFrame,
{
height: '100%',
width: '100%',
},
],
isLoaded && shouldFadeIn && !shouldStartVisible &&
(isCenter || isContain || isCover || isCenterContain || isCenterCover)
&& {
},
className,
],
image: [
classNames.image,
{
display: 'block',
opacity: 0,
},
isLoaded && [
'is-loaded',
{
opacity: 1,
},
],
isCenter && [classNames.imageCenter, ImageFitStyles],
isContain && [
classNames.imageContain,
supportsObjectFit && {
width: '100%',
height: '100%',
objectFit: 'contain',
},
!supportsObjectFit && fallbackObjectFitStyles,
!supportsObjectFit && ImageFitStyles,
],
isCover && [
classNames.imageCover,
supportsObjectFit && {
width: '100%',
height: '100%',
objectFit: 'cover',
},
!supportsObjectFit && fallbackObjectFitStyles,
!supportsObjectFit && ImageFitStyles,
],
isCenterContain && [
classNames.imageCenterContain,
isLandscape && {
maxWidth: '100%',
},
!isLandscape && {
maxHeight: '100%',
},
ImageFitStyles,
],
isCenterCover && [
classNames.imageCenterCover,
isLandscape && {
maxHeight: '100%',
},
!isLandscape && {
maxWidth: '100%',
},
ImageFitStyles,
],
isNone && [
classNames.imageNone,
{
width: 'auto',
height: 'auto',
},
],
isNotImageFit && [
!!width &&
!height && {
height: 'auto',
width: '100%',
},
!width &&
!!height && {
height: '100%',
width: 'auto',
},
!!width &&
!!height && {
height: '100%',
width: '100%',
},
],
isLandscape && classNames.imageLandscape,
!isLandscape && classNames.imagePortrait,
!isLoaded && 'is-notLoaded',
shouldFadeIn && 'is-fadeIn',
isError && 'is-error',
],
};
};
//# sourceMappingURL=Image.styles.js.map
/***/ }),
/***/ 4972:
"use strict";

exports.ImageLoadState = exports.ImageCoverStyle = exports.ImageFit = void 0;
/**
* The possible methods that can be used to fit the image.
* {@docCategory Image}
*/
var ImageFit;
(function (ImageFit) {
/**
* The image is not scaled. The image is centered and cropped within the
content box.
*/
ImageFit[ImageFit["center"] = 0] = "center";
/**
* The image is scaled to maintain its aspect ratio while being fully contained
within the frame. The image will
* be centered horizontally and vertically within the frame. The space in the
top and bottom or in the sides of
* the frame will be empty depending on the difference in aspect ratio between
the image and the frame.
*/
ImageFit[ImageFit["contain"] = 1] = "contain";
/**
* The image is scaled to maintain its aspect ratio while filling the frame.
Portions of the image will be cropped
* from the top and bottom, or the sides, depending on the difference in aspect
ratio between the image and the frame.
*/
ImageFit[ImageFit["cover"] = 2] = "cover";
/**
* Neither the image nor the frame are scaled. If their sizes do not match, the
image will either be cropped or the
* frame will have empty space.
*/
ImageFit[ImageFit["none"] = 3] = "none";
/**
* The image will be centered horizontally and vertically within the frame and
maintains its aspect ratio. It will
* behave as ImageFit.center if the image's natural height or width is less
than the Image frame's height or width,
* but if both natural height and width are larger than the frame it will
behave as ImageFit.cover.
*/
ImageFit[ImageFit["centerCover"] = 4] = "centerCover";
/**
* The image will be centered horizontally and vertically within the frame and
maintains its aspect ratio. It will
* behave as ImageFit.center if the image's natural height and width is less
than the Image frame's height and width,
* but if either natural height or width are larger than the frame it will
behave as ImageFit.contain.
*/
ImageFit[ImageFit["centerContain"] = 5] = "centerContain";
})(ImageFit = exports.ImageFit || (exports.ImageFit = {}));
/**
* The cover style to be used on the image
*/
var ImageCoverStyle;
(function (ImageCoverStyle) {
/**
* The image will be shown at 100% height of container and the width will be
scaled accordingly
*/
ImageCoverStyle[ImageCoverStyle["landscape"] = 0] = "landscape";
/**
* The image will be shown at 100% width of container and the height will be
scaled accordingly
*/
ImageCoverStyle[ImageCoverStyle["portrait"] = 1] = "portrait";
})(ImageCoverStyle = exports.ImageCoverStyle || (exports.ImageCoverStyle = {}));
/**
*/
var ImageLoadState;
(function (ImageLoadState) {
/**
* The image has not yet been loaded, and there is no error yet.
*/
ImageLoadState[ImageLoadState["notLoaded"] = 0] = "notLoaded";
/**
* The image has been loaded successfully.
*/
ImageLoadState[ImageLoadState["loaded"] = 1] = "loaded";
/**
* An error has been encountered while loading the image.
*/
ImageLoadState[ImageLoadState["error"] = 2] = "error";
/**
* @deprecated Not used. Use ònLoadingStateChange` and re-render the Image
with a different src.
*/
ImageLoadState[ImageLoadState["errorLoaded"] = 3] = "errorLoaded";
})(ImageLoadState = exports.ImageLoadState || (exports.ImageLoadState = {}));
//# sourceMappingURL=Image.types.js.map
/***/ }),
/***/ 61060:
"use strict";

/***/ }),
/***/ 29451:
"use strict";

exports.Keytip = void 0;
var KeytipUtils_1 = __webpack_require__(59409);
var KeytipContent_1 = __webpack_require__(80693);
var Keytip_styles_1 = __webpack_require__(92521);
/**
* A callout corresponding to another Fabric component to describe a key sequence
that will activate that component
*/
var Keytip = /** @class */ (function (_super) {
tslib_1.__extends(Keytip, _super);
function Keytip() {
}
Keytip.prototype.render = function () {
var _a = this.props, keySequences = _a.keySequences, offset = _a.offset,
overflowSetSequence = _a.overflowSetSequence;
var calloutProps = this.props.calloutProps;
var keytipTarget;
// Take into consideration the overflow sequence
if (overflowSetSequence) {
keytipTarget =
KeytipUtils_1.ktpTargetFromSequences(KeytipUtils_1.mergeOverflows(keySequences,
overflowSetSequence));
}
else {
keytipTarget = KeytipUtils_1.ktpTargetFromSequences(keySequences);
}
var element = Utilities_1.getFirstVisibleElementFromSelector(keytipTarget);
if (!element) {
return React.createElement(React.Fragment, null);
}
keytipTarget = element;
if (offset) {
// Set callout to top-left corner, will be further positioned in
// getCalloutOffsetStyles
calloutProps = tslib_1.__assign(tslib_1.__assign({}, calloutProps),
{ coverTarget: true, directionalHint:
ContextualMenu_1.DirectionalHint.topLeftEdge });
}
if (!calloutProps || calloutProps.directionalHint === undefined) {
// Default callout directional hint to BottomCenter
calloutProps = tslib_1.__assign(tslib_1.__assign({}, calloutProps),
{ directionalHint: ContextualMenu_1.DirectionalHint.bottomCenter });
}
return (React.createElement(Callout_1.Callout, tslib_1.__assign({},
calloutProps, { isBeakVisible: false, doNotLayer: true, minPagePadding: 0, styles:
offset ? Keytip_styles_1.getCalloutOffsetStyles(offset) :
Keytip_styles_1.getCalloutStyles, preventDismissOnScroll: true, target:
keytipTarget }),
React.createElement(KeytipContent_1.KeytipContent, tslib_1.__assign({},
this.props))));
};
return Keytip;
exports.Keytip = Keytip;
//# sourceMappingURL=Keytip.js.map
/***/ }),
/***/ 92521:
"use strict";

exports.getCalloutOffsetStyles = exports.getCalloutStyles = exports.getStyles =
void 0;
var _a;
var theme = props.theme, disabled = props.disabled, visible = props.visible;
return {
container: [
{
backgroundColor: theme.palette.neutralDark,
},
disabled && {
opacity: 0.5,
color: 'GrayText',
opacity: 1,
},
_a),
},
!visible && {
},
],
root: [
theme.fonts.medium,
{
paddingLeft: '3px',
backgroundColor: theme.palette.neutralDark,
color: theme.palette.neutralLight,
minWidth: '11px',
lineHeight: '17px',
height: '17px',
},
disabled && {
color: theme.palette.neutralTertiaryAlt,
},
],
};
};
var getCalloutStyles = function (props) {
return {
container: [],
root: [
{
border: 'none',
boxShadow: 'none',
},
],
beak: [],
beakCurtain: [],
calloutMain: [
{
},
],
};
};
exports.getCalloutStyles = getCalloutStyles;
var getCalloutOffsetStyles = function (offset) {
return function (props) {
return Styling_1.mergeStyleSets(exports.getCalloutStyles(props), {
root: [
{
marginLeft: offset.left || offset.x,
marginTop: offset.top || offset.y,
},
],
});
};
};
exports.getCalloutOffsetStyles = getCalloutOffsetStyles;
//# sourceMappingURL=Keytip.styles.js.map
/***/ }),
/***/ 16338:
"use strict";

//# sourceMappingURL=Keytip.types.js.map
/***/ }),
/***/ 6478:
"use strict";

exports.KeytipContentBase = void 0;
/**
* A component corresponding the content rendered inside the callout of the keytip
component.
* {@docCategory Keytips}
*/
var KeytipContentBase = /** @class */ (function (_super) {
tslib_1.__extends(KeytipContentBase, _super);
function KeytipContentBase() {
}
KeytipContentBase.prototype.render = function () {
var _a = this.props, content = _a.content, styles = _a.styles, theme =
_a.theme, disabled = _a.disabled, visible = _a.visible;
theme: theme,
disabled: disabled,
visible: visible,
});
return (React.createElement("div", { className: classNames.container },
React.createElement("span", { className: classNames.root }, content)));
};
return KeytipContentBase;
exports.KeytipContentBase = KeytipContentBase;
//# sourceMappingURL=KeytipContent.base.js.map
/***/ }),
/***/ 80693:
"use strict";

exports.KeytipContent = void 0;
var KeytipContent_base_1 = __webpack_require__(6478);
var Keytip_styles_1 = __webpack_require__(92521);
exports.KeytipContent = Utilities_1.styled(KeytipContent_base_1.KeytipContentBase,
Keytip_styles_1.getStyles, undefined, {
scope: 'KeytipContent',
});
//# sourceMappingURL=KeytipContent.js.map
/***/ }),
/***/ 25620:
"use strict";

/***/ }),
/***/ 11436:
"use strict";

exports.KeytipData = void 0;
var useKeytipData_1 = __webpack_require__(91440);
/**
* A small element to help the target component correctly read out its aria-
describedby for its Keytip
*/
var KeytipData = function (props) {
var _a;
var children = props.children, keytipDataProps = tslib_1.__rest(props,
["children"]);
var _b = useKeytipData_1.useKeytipData(keytipDataProps), keytipId =
_b.keytipId, ariaDescribedBy = _b.ariaDescribedBy;
return children((_a = {},
_a[index_1.DATAKTP_TARGET] = keytipId,
_a[index_1.DATAKTP_EXECUTE_TARGET] = keytipId,
_a['aria-describedby'] = ariaDescribedBy,
_a));
};
exports.KeytipData = KeytipData;
//# sourceMappingURL=KeytipData.js.map
/***/ }),
/***/ 4656:
"use strict";

//# sourceMappingURL=KeytipData.types.js.map
/***/ }),
/***/ 85525:
"use strict";

exports.useKeytipRef = void 0;
var useKeytipRef_1 = __webpack_require__(55875);
Object.defineProperty(exports, "useKeytipRef", ({ enumerable: true, get: function
() { return useKeytipRef_1.useKeytipRef; } }));
/***/ }),
/***/ 91440:
"use strict";

exports.useKeytipData = void 0;
/**
* Hook that creates attributes for components which are enabled with Keytip.
*/
function useKeytipData(options) {
var uniqueId = React.useRef();
var keytipProps = options.keytipProps
? tslib_1.__assign({ disabled: options.disabled }, options.keytipProps) :
undefined;
var keytipManager =
react_hooks_1.useConst(index_1.KeytipManager.getInstance());
var prevOptions = react_hooks_1.usePrevious(options);
// useLayoutEffect used to strictly emulate didUpdate/didMount behavior
if (uniqueId.current &&
keytipProps &&
((prevOptions === null || prevOptions === void 0 ? void 0 :
prevOptions.keytipProps) !== options.keytipProps || (prevOptions === null ||
prevOptions === void 0 ? void 0 : prevOptions.disabled) !== options.disabled)) {
keytipManager.update(keytipProps, uniqueId.current);
}
});
// Register Keytip in KeytipManager
if (keytipProps) {
uniqueId.current = keytipManager.register(keytipProps);
}
// Unregister Keytip in KeytipManager
keytipProps && keytipManager.unregister(keytipProps, uniqueId.current);
};
// this is meant to run only at mount, and updates are handled separately
}, []);
var nativeKeytipProps = {
ariaDescribedBy: undefined,
keytipId: undefined,
};
if (keytipProps) {
nativeKeytipProps = getKeytipData(keytipManager, keytipProps,
options.ariaDescribedBy);
}
return nativeKeytipProps;
}
exports.useKeytipData = useKeytipData;
/**
* Gets the aria- and data- attributes to attach to the component
* @param keytipProps - options for Keytip
* @param describedByPrepend - ariaDescribedBy value to prepend
*/
function getKeytipData(keytipManager, keytipProps, describedByPrepend) {
// Add the parent overflow sequence if necessary
var newKeytipProps = keytipManager.addParentOverflow(keytipProps);
// Construct aria-describedby and data-ktp-id attributes
var ariaDescribedBy = Utilities_1.mergeAriaAttributeValues(describedByPrepend,
index_1.getAriaDescribedBy(newKeytipProps.keySequences));
var keySequences = tslib_1.__spreadArray([], newKeytipProps.keySequences);
if (newKeytipProps.overflowSetSequence) {
keySequences = index_1.mergeOverflows(keySequences,
newKeytipProps.overflowSetSequence);
}
var keytipId = index_1.sequencesToID(keySequences);
return {
ariaDescribedBy: ariaDescribedBy,
keytipId: keytipId,
};
}
//# sourceMappingURL=useKeytipData.js.map
/***/ }),
/***/ 55875:
"use strict";

exports.setAttribute = exports.useKeytipRef = void 0;
var useKeytipData_1 = __webpack_require__(91440);
/**
* Hook that creates a ref which is used for passing to Keytip target element.
* The ref will handle setting the attributes needed for Keytip to work.
*/
function useKeytipRef(options) {
var _a = useKeytipData_1.useKeytipData(options), keytipId = _a.keytipId,
ariaDescribedBy = _a.ariaDescribedBy;
var contentRef = React.useCallback(function (contentElement) {
if (!contentElement) {
return;
}
var targetElement = findFirstElement(contentElement,
index_1.DATAKTP_TARGET) || contentElement;
var executeElement = findFirstElement(contentElement,
index_1.DATAKTP_EXECUTE_TARGET) || targetElement;
var ariaElement = findFirstElement(contentElement,
index_1.DATAKTP_ARIA_TARGET) || executeElement;
setAttribute(targetElement, index_1.DATAKTP_TARGET, keytipId);
setAttribute(executeElement, index_1.DATAKTP_EXECUTE_TARGET, keytipId);
setAttribute(ariaElement, 'aria-describedby', ariaDescribedBy, true);
}, [keytipId, ariaDescribedBy]);
return contentRef;
}
exports.useKeytipRef = useKeytipRef;
function setAttribute(element, attributeName, attributeValue, append) {
if (append === void 0) { append = false; }
if (element && attributeValue) {
var value = attributeValue;
if (append) {
var currentValue = element.getAttribute(attributeName);
if (currentValue && currentValue.indexOf(attributeValue) === -1) {
value = currentValue + " " + attributeValue;
}
}
element.setAttribute(attributeName, value);
}
}
exports.setAttribute = setAttribute;
function findFirstElement(rootElement, dataAttribute) {
return rootElement.querySelector("[" + dataAttribute + "]");
}
//# sourceMappingURL=useKeytipRef.js.map
/***/ }),
/***/ 84728:
"use strict";

exports.KeytipLayerBase = void 0;
var KeytipLayer_styles_1 = __webpack_require__(16706);
var Keytip_1 = __webpack_require__(8149);
var KeytipManager_1 = __webpack_require__(84992);
var KeytipTree_1 = __webpack_require__(26125);
var IKeytipTransitionKey_1 = __webpack_require__(23587);
var KeytipConstants_1 = __webpack_require__(42962);
// Default sequence is Alt-Windows (Alt-Meta) in Windows, Option-Control (Alt-
Control) in Mac
var defaultStartSequence = {
key: Utilities_1.isMac() ? 'Control' : 'Meta',
modifierKeys: [Utilities_1.KeyCodes.alt],
};
// Default exit sequence is the same as the start sequence
var defaultExitSequence = defaultStartSequence;
// Default return sequence is Escape
var defaultReturnSequence = {
key: 'Escape',
};
/**
* A layer that holds all keytip items
*/
var KeytipLayerBase = /** @class */ (function (_super) {
tslib_1.__extends(KeytipLayerBase, _super);
function KeytipLayerBase(props, context) {
var _this = _super.call(this, props, context) || this;
_this._keytipManager = KeytipManager_1.KeytipManager.getInstance();
_this._delayedKeytipQueue = [];
_this._keyHandled = false;
_this._onDismiss = function (ev) {
// if we are in keytip mode, then exit keytip mode
if (_this.state.inKeytipMode) {
_this._exitKeytipMode(ev);
}
};
_this._keyHandled = false;
// using key since which has been deprecated and key is now widely
suporrted.
// See:
https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/which
var key = ev.key;
switch (key) {
case 'Tab':
case 'Enter':
case 'Spacebar':
case ' ':
case 'ArrowUp':
case 'Up':
case 'ArrowDown':
case 'Down':
case 'ArrowLeft':
case 'Left':
case 'ArrowRight':
case 'Right':
if (_this.state.inKeytipMode) {
_this._keyHandled = true;
_this._exitKeytipMode(ev);
}
break;
default:
// Special cases for browser-specific keys that are not at
standard
// (according to http://www.w3.org/TR/uievents-key/#keys-
navigation)
if (key === 'Esc') {
// Edge: https://developer.microsoft.com/en-us/microsoft-
edge/platform/issues/5290772/
key = 'Escape';
}
else if (key === 'OS' || key === 'Win') {
// Firefox: https://bugzilla.mozilla.org/show_bug.cgi?
id=1232918
// Edge: https://developer.microsoft.com/en-us/microsoft-
// and https://developer.microsoft.com/en-us/microsoft-
key = 'Meta';
}
var transitionKey = { key: key };
transitionKey.modifierKeys = _this._getModifierKey(key, ev);
_this.processTransitionInput(transitionKey, ev);
break;
}
};
_this._onKeyPress = function (ev) {
if (_this.state.inKeytipMode && !_this._keyHandled) {
// Call processInput
_this.processInput(ev.key.toLocaleLowerCase(), ev);
}
};
_this._onKeytipAdded = function (eventArgs) {
var _a;
var keytipProps = eventArgs.keytip;
var uniqueID = eventArgs.uniqueID;
_this._keytipTree.addNode(keytipProps, uniqueID);
_this._setKeytips();
// Add the keytip to the queue to show later
if (_this._keytipTree.isCurrentKeytipParent(keytipProps)) {
// Ensure existing children are still shown.
_this._delayedKeytipQueue = _this._delayedKeytipQueue.concat(((_a =
_this._keytipTree.currentKeytip) === null || _a === void 0 ? void 0 : _a.children)
|| []);
_this._addKeytipToQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences));
// Ensure the child of currentKeytip is successfully added to
currentKeytip's children and update it if not.
// Note: Added this condition because KeytipTree.addNode was not
always reflecting updates made to a parent node
// in currentKeytip when that parent is the currentKeytip.
if (_this._keytipTree.currentKeytip &&
_this._keytipTree.currentKeytip.hasDynamicChildren &&
_this._keytipTree.currentKeytip.children.indexOf(keytipProps.id) < 0) {
var currNode =
_this._keytipTree.getNode(_this._keytipTree.currentKeytip.id);
if (currNode) {
_this._keytipTree.currentKeytip = currNode;
}
}
}
_this._persistedKeytipChecks(keytipProps);
};
_this._onKeytipUpdated = function (eventArgs) {
var _a;
_this._keytipTree.updateNode(keytipProps, uniqueID);
if (_this._keytipTree.isCurrentKeytipParent(keytipProps)) {
// Ensure existing children are still shown.
_this._delayedKeytipQueue = _this._delayedKeytipQueue.concat(((_a =
_this._keytipTree.currentKeytip) === null || _a === void 0 ? void 0 : _a.children)
|| []);
_this._addKeytipToQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences));
}
_this._persistedKeytipChecks(keytipProps);
};
/**
* Helper function to do checks related to persisted/overflow keytips
* Done on keytip added and keytip updated
*
* @param keytipProps - Keytip props
*/
_this._persistedKeytipChecks = function (keytipProps) {
if (_this._newCurrentKeytipSequences &&
Utilities_1.arraysEqual(keytipProps.keySequences,
_this._newCurrentKeytipSequences)) {
_this._triggerKeytipImmediately(keytipProps);
}
if (_this._isCurrentKeytipAnAlias(keytipProps)) {
var keytipSequence = keytipProps.keySequences;
if (keytipProps.overflowSetSequence) {
keytipSequence = KeytipUtils_1.mergeOverflows(keytipSequence,
keytipProps.overflowSetSequence);
}
_this._keytipTree.currentKeytip =
_this._keytipTree.getNode(KeytipUtils_1.sequencesToID(keytipSequence));
}
};
_this._onKeytipRemoved = function (eventArgs) {
// Remove keytip from the delayed queue
_this._removeKeytipFromQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences))
;
// Remove the node from the Tree
_this._keytipTree.removeNode(keytipProps, uniqueID);
};
_this._onPersistedKeytipAdded = function (eventArgs) {
_this._keytipTree.addNode(keytipProps, uniqueID, true);
};
_this._onPersistedKeytipRemoved = function (eventArgs) {
_this._keytipTree.removeNode(keytipProps, uniqueID);
};
_this._onPersistedKeytipExecute = function (eventArgs) {
_this._persistedKeytipExecute(eventArgs.overflowButtonSequences,
eventArgs.keytipSequences);
};
/**
* Sets if we are in keytip mode.
* Note, this sets both the state for the layer as well as
* the value that the manager will expose externally.
* @param inKeytipMode - Boolean so set whether we are in keytip mode or
not
*/
_this._setInKeytipMode = function (inKeytipMode) {
_this.setState({ inKeytipMode: inKeytipMode });
_this._keytipManager.inKeytipMode = inKeytipMode;
};
/**
* Emits a warning if duplicate keytips are found for the children of the
current keytip
*/
_this._warnIfDuplicateKeytips = function () {
var duplicateKeytips =
_this._getDuplicateIds(_this._keytipTree.getChildren());
if (duplicateKeytips.length) {
Utilities_1.warn('Duplicate keytips found for ' +
duplicateKeytips.join(', '));
}
};
/**
* Returns duplicates among keytip IDs.
* If the returned array is empty, no duplicates were found.
*
* @param keytipIds - Array of keytip IDs to find duplicates for
* @returns - Array of duplicates that were found. Each duplicate will only
be added once to this array.
*/
_this._getDuplicateIds = function (keytipIds) {
var seenIds = {};
return keytipIds.filter(function (keytipId) {
seenIds[keytipId] = seenIds[keytipId] ? seenIds[keytipId] + 1 : 1;
// Only add the first duplicate keytip seen
return seenIds[keytipId] === 2;
});
};
var keytips = _this._keytipManager.getKeytips();
_this.state = {
inKeytipMode: false,
keytips: keytips,
visibleKeytips: _this._getVisibleKeytips(keytips),
};
_this._buildTree();
_this._currentSequence = '';
// Add keytip listeners
_this._events.on(_this._keytipManager,
KeytipConstants_1.KeytipEvents.KEYTIP_ADDED, _this._onKeytipAdded);
KeytipConstants_1.KeytipEvents.KEYTIP_UPDATED, _this._onKeytipUpdated);
KeytipConstants_1.KeytipEvents.KEYTIP_REMOVED, _this._onKeytipRemoved);
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_ADDED,
_this._onPersistedKeytipAdded);
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_REMOVED,
_this._onPersistedKeytipRemoved);
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_EXECUTE,
_this._onPersistedKeytipExecute);
return _this;
}
KeytipLayerBase.prototype.render = function () {
var _this = this;
var _a = this.props, content = _a.content, styles = _a.styles;
var _b = this.state, keytips = _b.keytips, visibleKeytips =
_b.visibleKeytips;
this._classNames = getClassNames(styles, {});
return (React.createElement(Layer_1.Layer, { styles:
KeytipLayer_styles_1.getLayerStyles },
React.createElement("span", { id: KeytipConstants_1.KTP_LAYER_ID,
className: this._classNames.innerContent }, "" + content +
KeytipConstants_1.KTP_ARIA_SEPARATOR),
keytips &&
keytips.map(function (keytipProps, index) {
return (React.createElement("span", { key: index, id:
KeytipUtils_1.sequencesToID(keytipProps.keySequences), className:
_this._classNames.innerContent },
keytipProps.keySequences.join(KeytipConstants_1.KTP_ARIA_SEPARATOR)));
}),
visibleKeytips &&
visibleKeytips.map(function (visibleKeytipProps) {
return React.createElement(Keytip_1.Keytip,
tslib_1.__assign({ key:
KeytipUtils_1.sequencesToID(visibleKeytipProps.keySequences) },
visibleKeytipProps));
})));
};
KeytipLayerBase.prototype.componentDidMount = function () {
// Add window listeners
this._events.on(window, 'mouseup', this._onDismiss, true /* useCapture */);
this._events.on(window, 'pointerup', this._onDismiss, true /* useCapture
*/);
this._events.on(window, 'resize', this._onDismiss);
this._events.on(window, 'keydown', this._onKeyDown, true /* useCapture */);
this._events.on(window, 'keypress', this._onKeyPress, true /* useCapture
*/);
this._events.on(window, 'scroll', this._onDismiss, true /* useCapture */);
// Add keytip listeners
this._events.on(this._keytipManager,
KeytipConstants_1.KeytipEvents.ENTER_KEYTIP_MODE, this._enterKeytipMode);
this._events.on(this._keytipManager,
KeytipConstants_1.KeytipEvents.EXIT_KEYTIP_MODE, this._exitKeytipMode);
};
KeytipLayerBase.prototype.componentWillUnmount = function () {
};
// The below public functions are only public for testing purposes
// They are not intended to be used in app code by using a KeytipLayer
reference
KeytipLayerBase.prototype.getCurrentSequence = function () {
return this._currentSequence;
};
KeytipLayerBase.prototype.getKeytipTree = function () {
return this._keytipTree;
};
/**
* Processes an IKeytipTransitionKey entered by the user
*
* @param transitionKey - IKeytipTransitionKey received by the layer to process
*/
KeytipLayerBase.prototype.processTransitionInput = function (transitionKey, ev)
{
var currKtp = this._keytipTree.currentKeytip;
if
(IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipExitSequences,
transitionKey) && currKtp) {
// If key sequence is in 'exit sequences', exit keytip mode
this._keyHandled = true;
this._exitKeytipMode(ev);
}
else if
(IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipReturnSequences,
transitionKey)) {
// If key sequence is in return sequences, move currentKeytip to parent
(or if currentKeytip is the root, exit)
if (currKtp) {
if (currKtp.id === this._keytipTree.root.id) {
// We are at the root, exit keytip mode
}
else {
// If this keytip has a onReturn prop, we execute the func.
if (currKtp.onReturn) {
currKtp.onReturn(this._getKtpExecuteTarget(currKtp),
this._getKtpTarget(currKtp));
}
// Reset currentSequence
this._currentSequence = '';
// Return pointer to its parent
this._keytipTree.currentKeytip =
this._keytipTree.getNode(currKtp.parent);
// Show children keytips of the new currentKeytip
this.showKeytips(this._keytipTree.getChildren());
this._warnIfDuplicateKeytips();
}
}
}
else if
(IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipStartSequences,
transitionKey) && !currKtp) {
// If key sequence is in 'entry sequences' and currentKeytip is null,
we enter keytip mode
this._enterKeytipMode(transitionKey);
}
};
/**
* Processes inputs from the document listener and traverse the keytip tree
*
* @param key - Key pressed by the user
*/
KeytipLayerBase.prototype.processInput = function (key, ev) {
// Concat the input key with the current sequence
var currSequence = this._currentSequence + key;
// currentKeytip must be defined, otherwise we haven't entered keytip mode
yet
if (currKtp) {
var node = this._keytipTree.getExactMatchedNode(currSequence, currKtp);
if (node) {
this._keytipTree.currentKeytip = currKtp = node;
var currKtpChildren = this._keytipTree.getChildren();
// Execute this node's onExecute if defined
if (currKtp.onExecute) {
currKtp.onExecute(this._getKtpExecuteTarget(currKtp),
this._getKtpTarget(currKtp));
// Reset currKtp, this might have changed from the onExecute
currKtp = this._keytipTree.currentKeytip;
}
// To exit keytipMode after executing the keytip it must not have a
menu or have dynamic children
if (currKtpChildren.length === 0 && !(currKtp.hasDynamicChildren ||
currKtp.hasMenu)) {
}
else {
// Show all children keytips
this.showKeytips(currKtpChildren);
}
// Clear currentSequence
return;
}
var partialNodes =
this._keytipTree.getPartiallyMatchedNodes(currSequence, currKtp);
if (partialNodes.length > 0) {
// We found nodes that partially match the sequence, so we show
only those
// Omit showing persisted nodes here
var ids = partialNodes
.filter(function (partialNode) {
return !partialNode.persisted;
})
.map(function (partialNode) {
return partialNode.id;
});
this.showKeytips(ids);
// Save currentSequence
this._currentSequence = currSequence;
}
}
};
/**
* Show the given keytips and hide all others
*
* @param ids - Keytip IDs to show
*/
KeytipLayerBase.prototype.showKeytips = function (ids) {
// Update the visible prop in the manager
for (var _i = 0, _a = this._keytipManager.getKeytips(); _i < _a.length; _i+
+) {
var keytip = _a[_i];
var keytipId = KeytipUtils_1.sequencesToID(keytip.keySequences);
if (keytip.overflowSetSequence) {
// Check if the ID with the overflow is the keytip we're looking
for
keytipId =
KeytipUtils_1.sequencesToID(KeytipUtils_1.mergeOverflows(keytip.keySequences,
keytip.overflowSetSequence));
}
if (ids.indexOf(keytipId) >= 0) {
keytip.visible = true;
}
else {
keytip.visible = false;
}
}
// Apply the manager changes to the Layer state
this._setKeytips();
};
/**
* Enters keytip mode for this layer
*/
KeytipLayerBase.prototype._enterKeytipMode = function (transitionKey) {
if (this._keytipManager.shouldEnterKeytipMode) {
if (this._keytipManager.delayUpdatingKeytipChange) {
this._buildTree();
this._setKeytips();
}
this._keytipTree.currentKeytip = this._keytipTree.root;
// Show children of root
this.showKeytips(this._keytipTree.getChildren());
this._setInKeytipMode(true /* inKeytipMode */);
if (this.props.onEnterKeytipMode) {
this.props.onEnterKeytipMode(transitionKey);
}
}
};
KeytipLayerBase.prototype._buildTree = function () {
this._keytipTree = new KeytipTree_1.KeytipTree();
// Add regular and persisted keytips to the tree
for (var _i = 0, _a = Object.keys(this._keytipManager.keytips); _i <
_a.length; _i++) {
var id = _a[_i];
var uniqueKeytip = this._keytipManager.keytips[id];
this._keytipTree.addNode(uniqueKeytip.keytip, uniqueKeytip.uniqueID);
}
for (var _b = 0, _c = Object.keys(this._keytipManager.persistedKeytips); _b
< _c.length; _b++) {
var id = _c[_b];
var uniqueKeytip = this._keytipManager.persistedKeytips[id];
this._keytipTree.addNode(uniqueKeytip.keytip, uniqueKeytip.uniqueID);
}
};
/**
* Exits keytip mode for this layer
*/
KeytipLayerBase.prototype._exitKeytipMode = function (ev) {
this._keytipTree.currentKeytip = undefined;
// Hide all keytips
this.showKeytips([]);
// Reset the delayed keytips if any
this._delayedQueueTimeout &&
this._async.clearTimeout(this._delayedQueueTimeout);
this._delayedKeytipQueue = [];
this._setInKeytipMode(false /* inKeytipMode */);
if (this.props.onExitKeytipMode) {
this.props.onExitKeytipMode(ev);
}
};
/**
* Sets the keytips state property
*
* @param keytipProps - Keytips to set in this layer
*/
KeytipLayerBase.prototype._setKeytips = function (keytipProps) {
if (keytipProps === void 0) { keytipProps =
this._keytipManager.getKeytips(); }
this.setState({ keytips: keytipProps, visibleKeytips:
this._getVisibleKeytips(keytipProps) });
};
/**
* Callback function to use for persisted keytips
*
* @param overflowButtonSequences - The overflow button sequence to execute
* @param keytipSequences - The keytip that should become the 'currentKeytip'
when it is registered
*/
KeytipLayerBase.prototype._persistedKeytipExecute = function
(overflowButtonSequences, keytipSequences) {
// Save newCurrentKeytip for later
this._newCurrentKeytipSequences = keytipSequences;
// Execute the overflow button's onExecute
var overflowKeytipNode =
this._keytipTree.getNode(KeytipUtils_1.sequencesToID(overflowButtonSequences));
if (overflowKeytipNode && overflowKeytipNode.onExecute) {
overflowKeytipNode.onExecute(this._getKtpExecuteTarget(overflowKeytipNode),
this._getKtpTarget(overflowKeytipNode));
}
};
KeytipLayerBase.prototype._getVisibleKeytips = function (keytips) {
// Filter out non-visible keytips and duplicates
var seenIds = {};
return keytips.filter(function (keytip) {
var keytipId = KeytipUtils_1.sequencesToID(keytip.keySequences);
if (keytip.overflowSetSequence) {
// Account for overflow set sequences when checking for duplicates
keytipId =
KeytipUtils_1.sequencesToID(KeytipUtils_1.mergeOverflows(keytip.keySequences,
keytip.overflowSetSequence));
}
seenIds[keytipId] = seenIds[keytipId] ? seenIds[keytipId] + 1 : 1;
return keytip.visible && seenIds[keytipId] === 1;
});
};
/**
* Gets the ModifierKeyCodes based on the keyboard event
*
* @param ev - React.KeyboardEvent
* @returns List of ModifierKeyCodes that were pressed
*/
KeytipLayerBase.prototype._getModifierKey = function (key, ev) {
var modifierKeys = [];
if (ev.altKey && key !== 'Alt') {
modifierKeys.push(Utilities_1.KeyCodes.alt);
}
if (ev.ctrlKey && key !== 'Control') {
modifierKeys.push(Utilities_1.KeyCodes.ctrl);
}
if (ev.shiftKey && key !== 'Shift') {
modifierKeys.push(Utilities_1.KeyCodes.shift);
}
if (ev.metaKey && key !== 'Meta') {
modifierKeys.push(Utilities_1.KeyCodes.leftWindow);
}
return modifierKeys.length ? modifierKeys : undefined;
};
/**
* Trigger a keytip immediately and set it as the current keytip
*
* @param keytipProps - Keytip to trigger immediately
*/
KeytipLayerBase.prototype._triggerKeytipImmediately = function (keytipProps) {
// This keytip should become the currentKeytip and should execute right
away
var keytipSequence = tslib_1.__spreadArray([], keytipProps.keySequences);
keytipSequence = KeytipUtils_1.mergeOverflows(keytipSequence,
}
// Set currentKeytip
this._keytipTree.currentKeytip =
this._keytipTree.getNode(KeytipUtils_1.sequencesToID(keytipSequence));
if (this._keytipTree.currentKeytip) {
// Show all children keytips if any
var children = this._keytipTree.getChildren();
if (children.length) {
this.showKeytips(children);
}
if (this._keytipTree.currentKeytip.onExecute) {
this._keytipTree.currentKeytip.onExecute(this._getKtpExecuteTarget(this._keytipTree
.currentKeytip), this._getKtpTarget(this._keytipTree.currentKeytip));
}
}
// Unset _newCurrKtpSequences
this._newCurrentKeytipSequences = undefined;
};
KeytipLayerBase.prototype._addKeytipToQueue = function (keytipID) {
var _this = this;
// Add keytip
this._delayedKeytipQueue.push(keytipID);
// Clear timeout
// Reset timeout
this._delayedQueueTimeout = this._async.setTimeout(function () {
if (_this._delayedKeytipQueue.length) {
_this.showKeytips(_this._delayedKeytipQueue);
}
}, 300);
};
KeytipLayerBase.prototype._removeKeytipFromQueue = function (keytipID) {
var _this = this;
var index = this._delayedKeytipQueue.indexOf(keytipID);
if (index >= 0) {
// Remove keytip
this._delayedKeytipQueue.splice(index, 1);
// Clear timeout
// Reset timeout
this._delayedQueueTimeout = this._async.setTimeout(function () {
if (_this._delayedKeytipQueue.length) {
_this.showKeytips(_this._delayedKeytipQueue);
}
}, 300);
}
};
KeytipLayerBase.prototype._getKtpExecuteTarget = function (currKtp) {
return
Utilities_1.getDocument().querySelector(KeytipUtils_1.ktpTargetFromId(currKtp.id));
};
KeytipLayerBase.prototype._getKtpTarget = function (currKtp) {
return
Utilities_1.getDocument().querySelector(KeytipUtils_1.ktpTargetFromSequences(currKt
p.keySequences));
};
/**
* Returns T/F if the keytipProps keySequences match the currentKeytip, and the
currentKeytip is in an overflow well
* This will make 'keytipProps' the new currentKeytip
*
* @param keytipProps - Keytip props to check
* @returns - T/F if this keytip should become the currentKeytip
*/
KeytipLayerBase.prototype._isCurrentKeytipAnAlias = function (keytipProps) {
if (currKtp &&
(currKtp.overflowSetSequence || currKtp.persisted) &&
Utilities_1.arraysEqual(keytipProps.keySequences,
currKtp.keySequences)) {
return true;
}
return false;
};
KeytipLayerBase.defaultProps = {
keytipStartSequences: [defaultStartSequence],
keytipExitSequences: [defaultExitSequence],
keytipReturnSequences: [defaultReturnSequence],
content: '',
};
return KeytipLayerBase;
exports.KeytipLayerBase = KeytipLayerBase;
//# sourceMappingURL=KeytipLayer.base.js.map
/***/ }),
/***/ 96306:
"use strict";

exports.KeytipLayer = void 0;
var KeytipLayer_base_1 = __webpack_require__(84728);
var KeytipLayer_styles_1 = __webpack_require__(16706);
exports.KeytipLayer = Utilities_1.styled(KeytipLayer_base_1.KeytipLayerBase,
KeytipLayer_styles_1.getStyles, undefined, {
scope: 'KeytipLayer',
});
//# sourceMappingURL=KeytipLayer.js.map
/***/ }),
/***/ 16706:
"use strict";

exports.getStyles = exports.getLayerStyles = void 0;
var getLayerStyles = function (props) {
return {
root: [
{
// Prioritize the Keytips above all other Layers
zIndex: Styling_1.ZIndexes.KeytipLayer,
},
],
};
};
exports.getLayerStyles = getLayerStyles;
return {
innerContent: [
{
width: 0,
height: 0,
margin: 0,
padding: 0,
border: 0,
overflow: 'hidden',
},
],
};
};
//# sourceMappingURL=KeytipLayer.styles.js.map
/***/ }),
/***/ 38381:
"use strict";

//# sourceMappingURL=KeytipLayer.types.js.map
/***/ }),
/***/ 26125:
"use strict";

exports.KeytipTree = void 0;
/**
* This class is responsible for handling the parent/child relationships between
keytips
*/
var KeytipTree = /** @class */ (function () {
/**
* KeytipTree constructor
*/
function KeytipTree() {
this.nodeMap = {};
// Root has no keytipSequence
this.root = {
id: KeytipConstants_1.KTP_LAYER_ID,
children: [],
parent: '',
keySequences: [],
};
this.nodeMap[this.root.id] = this.root;
}
/**
* Add a keytip node to this KeytipTree
*
* @param keytipProps - Keytip to add to the Tree
* @param uniqueID - Unique ID for this keytip
* @param persisted - T/F if this keytip should be marked as persisted
*/
KeytipTree.prototype.addNode = function (keytipProps, uniqueID, persisted) {
var fullSequence = this._getFullSequence(keytipProps);
var nodeID = KeytipUtils_1.sequencesToID(fullSequence);
// Take off the last item to calculate the parent sequence
fullSequence.pop();
// Parent ID is the root if there aren't any more sequences
var parentID = this._getParentID(fullSequence);
// Create node and add to map
var node = this._createNode(nodeID, parentID, [], keytipProps, persisted);
this.nodeMap[uniqueID] = node;
// Try to add self to parents children
var parents = this.getNodes([parentID]);
parents.forEach(function (parent) { return
parent.children.push(nodeID); });
};
/**
* Updates a node in the tree
*
* @param keytipProps - Keytip props to update
* @param uniqueID - Unique ID for this keytip
*/
KeytipTree.prototype.updateNode = function (keytipProps, uniqueID) {
// Take off the last item to calculate the parent sequence
fullSequence.pop();
var parentID = this._getParentID(fullSequence);
var node = this.nodeMap[uniqueID];
var prevParent = node.parent;
if (node) {
// Fix parent nodes if needed
if (prevParent !== parentID) {
// If parent has changed, remove child from old parent
this._removeChildFromParents(prevParent, node.id);
}
if (node.id !== nodeID) {
// If the ID of the node has changed, update node's parent's array
of children with new ID
parents.forEach(function (parent) {
var index = parent.children.indexOf(node.id);
index >= 0 ? (parent.children[index] = nodeID) :
parent.children.push(nodeID);
});
}
// Update values
node.id = nodeID;
node.keySequences = keytipProps.keySequences;
node.overflowSetSequence = keytipProps.overflowSetSequence;
node.onExecute = keytipProps.onExecute;
node.onReturn = keytipProps.onReturn;
node.hasDynamicChildren = keytipProps.hasDynamicChildren;
node.hasMenu = keytipProps.hasMenu;
node.parent = parentID;
node.disabled = keytipProps.disabled;
}
};
/**
* Removes a node from the KeytipTree
*
* @param sequence - full string of the node to remove
*/
KeytipTree.prototype.removeNode = function (keytipProps, uniqueID) {
// Take off the last sequence to calculate the parent ID
fullSequence.pop();
this._removeChildFromParents(this._getParentID(fullSequence), nodeID);
if (this.nodeMap[uniqueID]) {
// Remove the node from the nodeMap
delete this.nodeMap[uniqueID];
}
};
/**
* Searches the currentKeytip's children to exactly match a sequence. Will not
match disabled nodes but
* will match persisted nodes
*
* @param keySequence - string to match
* @param currentKeytip - The keytip whose children will try to match
* @returns The node that exactly matched the keySequence, or undefined if none
matched
*/
KeytipTree.prototype.getExactMatchedNode = function (keySequence,
currentKeytip) {
var _this = this;
var possibleNodes = this.getNodes(currentKeytip.children);
var matchingNodes = possibleNodes.filter(function (node) {
return _this._getNodeSequence(node) === keySequence && !node.disabled;
});
// If we found no nodes, we are done
if (matchingNodes.length === 0) {
return undefined;
}
// Since the matching nodes all have the same key sequence,
// Grab the first one build the correct selector
var node = matchingNodes[0];
// If we have exactly one node, return it
if (matchingNodes.length === 1) {
return node;
}
// Get the potential target elements based on a selector from the sequences
var keySequences = node.keySequences;
var overflowSetSequence = node.overflowSetSequence;
var fullKeySequences = overflowSetSequence ?
KeytipUtils_1.mergeOverflows(keySequences, overflowSetSequence) : keySequences;
var keytipTargetSelector =
KeytipUtils_1.ktpTargetFromSequences(fullKeySequences);
var potentialTargetElements =
document.querySelectorAll(keytipTargetSelector);
// If we have less nodes than the potential target elements,
// we won't be able to map element to node, return the first node.
// Note, the number of nodes could be more than the number of potential
// target elements, if an OverflowSet is involved
if (matchingNodes.length < potentialTargetElements.length) {
return node;
}
// Attempt to find the node that corresponds to the first visible/non-
hidden element
var matchingIndex = Array.from(potentialTargetElements).findIndex(function
(element) {
return Utilities_1.isElementVisibleAndNotHidden(element);
});
if (matchingIndex !== -1) {
return matchingNodes[matchingIndex];
}
// We did not find any visible elements associated with any of the nodes.
// We may be dealing with a keytip that is a submenu in an OverflowSet.
// Worst case, fall back to the first node returned
var overflowNode = matchingNodes.find(function (matchingNode) { return
matchingNode.hasOverflowSubMenu; });
return overflowNode || node;
};
/**
* Searches the currentKeytip's children to find nodes that start with the
given sequence. Will not match
* disabled nodes but will match persisted nodes
*
* @param keySequence - string to partially match
* @param currentKeytip - The keytip whose children will try to partially match
* @returns List of tree nodes that partially match the given sequence
*/
KeytipTree.prototype.getPartiallyMatchedNodes = function (keySequence,
currentKeytip) {
var _this = this;
// Get children that are persisted
var possibleNodes = this.getNodes(currentKeytip.children);
return possibleNodes.filter(function (node) {
return _this._getNodeSequence(node).indexOf(keySequence) === 0 && !
node.disabled;
});
};
/**
* Get the non-persisted children of the give node
* If no node is given, will use the 'currentKeytip'
*
* @param node - Node to get the children for
* @returns List of node IDs that are the children of the node
*/
KeytipTree.prototype.getChildren = function (node) {
var _this = this;
if (!node) {
node = this.currentKeytip;
if (!node) {
return [];
}
}
var children = node.children;
return Object.keys(this.nodeMap).reduce(function (nodes, key) {
if (children.indexOf(_this.nodeMap[key].id) >= 0 && !
_this.nodeMap[key].persisted) {
nodes.push(_this.nodeMap[key].id);
}
return nodes;
}, []);
};
/**
* Gets all nodes from their IDs
*
* @param ids - List of keytip IDs
* @returns Array of nodes that match the given IDs, can be empty
*/
KeytipTree.prototype.getNodes = function (ids) {
var _this = this;
return Object.keys(this.nodeMap).reduce(function (nodes, key) {
if (ids.indexOf(_this.nodeMap[key].id) >= 0) {
nodes.push(_this.nodeMap[key]);
}
return nodes;
}, []);
};
/**
* Gets a single node from its ID
*
* @param id - ID of the node to get
* @returns Node with the given ID, if found
*/
KeytipTree.prototype.getNode = function (id) {
var nodeMapValues = Utilities_1.values(this.nodeMap);
return Utilities_1.find(nodeMapValues, function (node) {
return node.id === id;
});
};
/**
* Tests if the currentKeytip in this.keytipTree is the parent of 'keytipProps'
*
* @param keytipProps - Keytip to test the parent for
* @returns T/F if the currentKeytip is this keytipProps' parent
*/
KeytipTree.prototype.isCurrentKeytipParent = function (keytipProps) {
if (this.currentKeytip) {
var fullSequence = tslib_1.__spreadArray([], keytipProps.keySequences);
fullSequence = KeytipUtils_1.mergeOverflows(fullSequence,
}
// Take off the last sequence to calculate the parent ID
fullSequence.pop();
var parentID = fullSequence.length === 0 ? this.root.id :
KeytipUtils_1.sequencesToID(fullSequence);
var matchesCurrWithoutOverflow = false;
if (this.currentKeytip.overflowSetSequence) {
var currKeytipIdWithoutOverflow =
KeytipUtils_1.sequencesToID(this.currentKeytip.keySequences);
matchesCurrWithoutOverflow = currKeytipIdWithoutOverflow ===
parentID;
}
return matchesCurrWithoutOverflow || this.currentKeytip.id ===
parentID;
}
return false;
};
KeytipTree.prototype._getParentID = function (fullSequence) {
return fullSequence.length === 0 ? this.root.id :
KeytipUtils_1.sequencesToID(fullSequence);
};
KeytipTree.prototype._getFullSequence = function (keytipProps) {
}
return fullSequence;
};
KeytipTree.prototype._getNodeSequence = function (node) {
var fullSequence = tslib_1.__spreadArray([], node.keySequences);
if (node.overflowSetSequence) {
node.overflowSetSequence);
}
return fullSequence[fullSequence.length - 1];
};
KeytipTree.prototype._createNode = function (id, parentId, children,
keytipProps, persisted) {
var _this = this;
var keySequences = keytipProps.keySequences, hasDynamicChildren =
keytipProps.hasDynamicChildren, overflowSetSequence =
keytipProps.overflowSetSequence, hasMenu = keytipProps.hasMenu, onExecute =
keytipProps.onExecute, onReturn = keytipProps.onReturn, disabled =
keytipProps.disabled, hasOverflowSubMenu = keytipProps.hasOverflowSubMenu;
var node = {
id: id,
keySequences: keySequences,
overflowSetSequence: overflowSetSequence,
parent: parentId,
children: children,
onExecute: onExecute,
onReturn: onReturn,
hasDynamicChildren: hasDynamicChildren,
hasMenu: hasMenu,
disabled: disabled,
persisted: persisted,
hasOverflowSubMenu: hasOverflowSubMenu,
};
node.children = Object.keys(this.nodeMap).reduce(function (array,
nodeMapKey) {
if (_this.nodeMap[nodeMapKey].parent === id) {
array.push(_this.nodeMap[nodeMapKey].id);
}
return array;
}, []);
return node;
};
KeytipTree.prototype._removeChildFromParents = function (parentID, childID) {
parents.forEach(function (parent) {
var childIndex = parent.children.indexOf(childID);
if (childIndex >= 0) {
parent.children.splice(childIndex, 1);
}
});
};
return KeytipTree;
}());
exports.KeytipTree = KeytipTree;
//# sourceMappingURL=KeytipTree.js.map
/***/ }),
/***/ 42900:
"use strict";

/***/ }),
/***/ 68732:
"use strict";

exports.LabelBase = void 0;
// Label is used a lot by other components.
// It's likely to see expected cases which pass different className to the
Label.
cacheSize: 100,
});
var LabelBase = /** @class */ (function (_super) {
tslib_1.__extends(LabelBase, _super);
function LabelBase() {
}
LabelBase.prototype.render = function () {
var _a = this.props, _b = _a.as, RootType = _b === void 0 ? 'label' : _b,
children = _a.children, className = _a.className, disabled = _a.disabled, styles =
_a.styles, required = _a.required, theme = _a.theme;
disabled: disabled,
required: required,
theme: theme,
});
return (React.createElement(RootType, tslib_1.__assign({},
Utilities_1.getNativeProps(this.props, Utilities_1.divProperties), { className:
classNames.root }), children));
};
return LabelBase;
exports.LabelBase = LabelBase;
//# sourceMappingURL=Label.base.js.map
/***/ }),
/***/ 91076:
"use strict";

exports.Label = void 0;
var Label_base_1 = __webpack_require__(68732);
var Label_styles_1 = __webpack_require__(60113);
exports.Label = Utilities_1.styled(Label_base_1.LabelBase,
Label_styles_1.getStyles, undefined, {
scope: 'Label',
});
//# sourceMappingURL=Label.js.map
/***/ }),
/***/ 60113:
"use strict";

var _a;
var theme = props.theme, className = props.className, disabled =
props.disabled, required = props.required;
// Tokens
var labelFontWeight = Styling_1.FontWeights.semibold;
var labelColor = semanticColors.bodyText;
var labelDisabledColor = semanticColors.disabledBodyText;
var labelRequiredStarColor = semanticColors.errorText;
return {
root: [
'ms-Label',
theme.fonts.medium,
{
fontWeight: labelFontWeight,
color: labelColor,
boxShadow: 'none',
margin: 0,
display: 'block',
padding: '5px 0',
},
disabled && {
color: labelDisabledColor,
_a),
},
required && {
selectors: {
'::after': {
content: "' *'",
color: labelRequiredStarColor,
paddingRight: 12,
},
},
},
className,
],
};
};
//# sourceMappingURL=Label.styles.js.map
/***/ }),
/***/ 95083:
"use strict";

//# sourceMappingURL=Label.types.js.map
/***/ }),
/***/ 90013:
"use strict";

/***/ }),
/***/ 61169:
"use strict";

exports.LayerBase = void 0;
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore "react-portal-compat-context" uses v9 configs via path aliases
var react_portal_compat_context_1 = __webpack_require__(35247);
var ReactDOM = __webpack_require__(73935);
var Fabric_1 = __webpack_require__(20349);
var Layer_notification_1 = __webpack_require__(56631);
exports.LayerBase = React.forwardRef(function (props, ref) {
var registerPortalEl = react_portal_compat_context_1.usePortalCompat();
var mergedRef = react_hooks_1.useMergedRefs(rootRef, ref);
var layerRef = React.useRef();
// Tracks if the layer mount events need to be raised.
// Required to allow the DOM to render after the layer element is added.
var _a = React.useState(false), needRaiseLayerMount = _a[0],
setNeedRaiseLayerMount = _a[1];
var eventBubblingEnabled = props.eventBubblingEnabled, styles = props.styles,
theme = props.theme, className = props.className, children = props.children, hostId
= props.hostId, _b = props.onLayerDidMount, onLayerDidMount = _b === void 0 ?
function () { return undefined; } : _b,
_c = props.onLayerMounted,
onLayerMounted = _c === void 0 ? function () { return undefined; } : _c,
onLayerWillUnmount = props.onLayerWillUnmount, insertFirst = props.insertFirst;
theme: theme,
isNotHost: !hostId,
});
// Returns the user provided hostId props element, the default target selector,
// or undefined if document doesn't exist.
var getHost = function (doc) {
var _a, _b;
if (hostId) {
var layerHost = Layer_notification_1.getLayerHost(hostId);
if (layerHost) {
return (_a = layerHost.rootRef.current) !== null && _a !== void 0 ?
_a : null;
}
return (_b = doc.getElementById(hostId)) !== null && _b !== void 0 ? _b
: null;
}
else {
var defaultHostSelector = Layer_notification_1.getDefaultTarget();
// Find the host.
var host = defaultHostSelector ? doc.querySelector(defaultHostSelector)
: null;
// If no host is available, create a container for injecting layers in.
// Having a container scopes layout computation.
if (!host) {
host = Layer_notification_1.createDefaultLayerHost(doc);
}
return host;
}
};
// Removes the current layer element's parentNode and runs onLayerWillUnmount
prop if provided.
var removeLayerElement = function () {
onLayerWillUnmount === null || onLayerWillUnmount === void 0 ? void 0 :
onLayerWillUnmount();
var elem = layerRef.current;
// Clear ref before removing from the DOM
layerRef.current = undefined;
if (elem && elem.parentNode) {
elem.parentNode.removeChild(elem);
}
};
// If a doc or host exists, it will remove and update layer parentNodes.
var createLayerElement = function () {
var _a;
var doc = Utilities_1.getDocument(rootRef.current);
if (!doc) {
return;
}
var host = getHost(doc);
if (!host) {
return;
}
// Remove and re-create any previous existing layer elements.
removeLayerElement();
var el = ((_a = host.ownerDocument) !== null && _a !== void 0 ? _a :
doc).createElement('div');
el.className = classNames.root;
Utilities_1.setPortalAttribute(el);
Utilities_1.setVirtualParent(el, rootRef.current);
insertFirst ? host.insertBefore(el, host.firstChild) :
host.appendChild(el);
layerRef.current = el;
setNeedRaiseLayerMount(true);
};
createLayerElement();
// Check if the user provided a hostId prop and register the layer with the
ID.
if (hostId) {
Layer_notification_1.registerLayer(hostId, createLayerElement);
}
var unregisterPortalEl = layerRef.current ?
registerPortalEl(layerRef.current) : undefined;
if (unregisterPortalEl) {
unregisterPortalEl();
}
removeLayerElement();
if (hostId) {
Layer_notification_1.unregisterLayer(hostId, createLayerElement);
}
};
// eslint-disable-next-line react-hooks/exhaustive-deps -- should run if
the hostId updates.
}, [hostId]);
if (layerRef.current && needRaiseLayerMount) {
onLayerMounted === null || onLayerMounted === void 0 ? void 0 :
onLayerMounted();
onLayerDidMount === null || onLayerDidMount === void 0 ? void 0 :
onLayerDidMount();
setNeedRaiseLayerMount(false);
}
}, [needRaiseLayerMount, onLayerMounted, onLayerDidMount]);
return (React.createElement("span", { className: "ms-layer", ref: mergedRef },
layerRef.current &&
ReactDOM.createPortal(
React.createElement(Fabric_1.Fabric, tslib_1.__assign({}, (!
eventBubblingEnabled && getFilteredEvents()), { className: classNames.content }),
children),
layerRef.current)));
});
exports.LayerBase.displayName = 'LayerBase';
var filteredEventProps;
var onFilterEvent = function (ev) {
// We should just be able to check ev.bubble here and only stop events that are
bubbling up. However, even though
// mouseenter and mouseleave do NOT bubble up, they are showing up as bubbling.
Therefore we stop events based on
// event name rather than ev.bubble.
if (ev.eventPhase === Event.BUBBLING_PHASE &&
ev.type !== 'mouseenter' &&
ev.type !== 'mouseleave' &&
ev.type !== 'touchstart' &&
ev.type !== 'touchend') {
}
};
function getFilteredEvents() {
if (!filteredEventProps) {
filteredEventProps = {};
[
'onClick',
'onContextMenu',
'onDoubleClick',
'onDrag',
'onDragEnd',
'onDragEnter',
'onDragExit',
'onDragLeave',
'onDragOver',
'onDragStart',
'onDrop',
'onMouseDown',
'onMouseEnter',
'onMouseLeave',
'onMouseMove',
'onMouseOver',
'onMouseOut',
'onMouseUp',
'onTouchMove',
'onTouchStart',
'onTouchCancel',
'onTouchEnd',
'onKeyDown',
'onKeyPress',
'onKeyUp',
'onFocus',
'onBlur',
'onChange',
'onInput',
'onInvalid',
'onSubmit',
].forEach(function (name) { return (filteredEventProps[name] =
onFilterEvent); });
}
return filteredEventProps;
}
if (false) {}
}
//# sourceMappingURL=Layer.base.js.map
/***/ }),
/***/ 93626:
"use strict";

exports.Layer = void 0;
var Layer_base_1 = __webpack_require__(61169);
var Layer_styles_1 = __webpack_require__(76701);
exports.Layer = Utilities_1.styled(Layer_base_1.LayerBase,
Layer_styles_1.getStyles, undefined, {
scope: 'Layer',
fields: ['hostId', 'theme', 'styles'],
});
//# sourceMappingURL=Layer.js.map
/***/ }),
/***/ 56631:
"use strict";

exports.getDefaultTarget = exports.setDefaultTarget = exports.notifyHostChanged =
exports.cleanupDefaultLayerHost = exports.createDefaultLayerHost =
exports.unregisterLayerHost = exports.registerLayerHost = exports.getLayerHost =
exports.getLayerCount = exports.unregisterLayer = exports.registerLayer = void 0;
var _layersByHostId = {};
var _layerHostsById = {};
var defaultHostId = 'fluent-default-layer-host';
var _defaultHostSelector = "#" + defaultHostId;
/**
* Register a layer for a given host id
* @param hostId Id of the layer host
* @param layer Layer instance
*/
function registerLayer(hostId, callback) {
if (!_layersByHostId[hostId]) {
_layersByHostId[hostId] = [];
}
_layersByHostId[hostId].push(callback);
var layerHosts = _layerHostsById[hostId];
if (layerHosts) {
for (var _i = 0, layerHosts_1 = layerHosts; _i < layerHosts_1.length; _i++)
{
var layerHost = layerHosts_1[_i];
layerHost.notifyLayersChanged();
}
}
}
exports.registerLayer = registerLayer;
/**
* Unregister a layer for a given host id
* @param layer Layer instance
*/
function unregisterLayer(hostId, callback) {
var layers = _layersByHostId[hostId];
if (layers) {
var idx = layers.indexOf(callback);
if (idx >= 0) {
layers.splice(idx, 1);
if (layers.length === 0) {
delete _layersByHostId[hostId];
}
}
}
if (layerHosts) {
for (var _i = 0, layerHosts_2 = layerHosts; _i < layerHosts_2.length; _i++)
{
var layerHost = layerHosts_2[_i];
layerHost.notifyLayersChanged();
}
}
}
exports.unregisterLayer = unregisterLayer;
/**
* Gets the number of layers currently registered with a host id.
* @param hostId Id of the layer host.
* @returns The number of layers currently registered with the host.
*/
function getLayerCount(hostId) {
var layers = _layerHostsById[hostId];
return layers ? layers.length : 0;
}
exports.getLayerCount = getLayerCount;
/**
* Gets the Layer Host instance associated with a hostId, if applicable.
* @param hostId
* @returns A component ref for the associated layer host.
*/
function getLayerHost(hostId) {
return (layerHosts && layerHosts[0]) || undefined;
}
exports.getLayerHost = getLayerHost;
/**
* Registers a Layer Host with an associated hostId.
* @param layerHost layer host instance
*/
function registerLayerHost(hostId, layerHost) {
var layerHosts = _layerHostsById[hostId] || (_layerHostsById[hostId] = []);
// Insert this at the start of an array to avoid race conditions between mount
and unmount.
// If a LayerHost is re-mounted, and mount of the new instance may occur before
the unmount of the old one.
// Putting the new instance at the start of this array ensures that calls to
`getLayerHost` will immediately
// get the new one even if the old one is around briefly.
layerHosts.unshift(layerHost);
}
exports.registerLayerHost = registerLayerHost;
/**
* Unregisters a Layer Host from the associated hostId.
* @param layerHost layer host instance
*/
function unregisterLayerHost(hostId, layerHost) {
if (layerHosts) {
var idx = layerHosts.indexOf(layerHost);
if (idx >= 0) {
layerHosts.splice(idx, 1);
}
if (layerHosts.length === 0) {
delete _layerHostsById[hostId];
}
}
}
exports.unregisterLayerHost = unregisterLayerHost;
/**
* When no default layer host is provided, this function is executed to create the
default host.
*/
function createDefaultLayerHost(doc) {
var host = doc.createElement('div');
host.setAttribute('id', defaultHostId);
host.style.cssText = 'position:fixed;z-index:1000000';
doc === null || doc === void 0 ? void 0 : doc.body.appendChild(host);
return host;
}
exports.createDefaultLayerHost = createDefaultLayerHost;
/**
* This function can be optionally called to clean up the default layer host as
needed.
*/
function cleanupDefaultLayerHost(doc) {
var host = doc.querySelector("#" + defaultHostId);
if (host) {
doc.removeChild(host);
}
}
exports.cleanupDefaultLayerHost = cleanupDefaultLayerHost;
/**
* Used for notifying applicable Layers that a host is available/unavailable and to
re-evaluate Layers that
* care about the specific host.
*/
function notifyHostChanged(id) {
if (_layersByHostId[id]) {
_layersByHostId[id].forEach(function (callback) { return callback(); });
}
}
exports.notifyHostChanged = notifyHostChanged;
/**
* Sets the default target selector to use when determining the host in which
* Layered content will be injected into. If not provided, an element will be
* created at the end of the document body.
*
* Passing in a falsy value will clear the default target and reset back to
* using a created element at the end of document body.
*/
function setDefaultTarget(selector) {
_defaultHostSelector = selector;
}
exports.setDefaultTarget = setDefaultTarget;
/**
* Get the default target selector when determining a host
*/
function getDefaultTarget() {
return _defaultHostSelector;
}
exports.getDefaultTarget = getDefaultTarget;
//# sourceMappingURL=Layer.notification.js.map
/***/ }),
/***/ 76701:
"use strict";

root: 'ms-Layer',
rootNoHost: 'ms-Layer--fixed',
content: 'ms-Layer-content',
};
var className = props.className, isNotHost = props.isNotHost, theme =
props.theme;
return {
root: [
classNames.root,
theme.fonts.medium,
isNotHost && [
classNames.rootNoHost,
{
position: 'fixed',
zIndex: Styling_1.ZIndexes.Layer,
top: 0,
left: 0,
bottom: 0,
right: 0,
},
],
className,
],
content: [
classNames.content,
{
},
],
};
};
//# sourceMappingURL=Layer.styles.js.map
/***/ }),
/***/ 80355:
"use strict";

//# sourceMappingURL=Layer.types.js.map
/***/ }),
/***/ 67953:
"use strict";

exports.LayerHost = void 0;
var LayerHost = function (props) {
var className = props.className;
var layerHostId = React.useState(function () { return Utilities_1.getId(); })
[0];
var _a = props.id, hostId = _a === void 0 ? layerHostId : _a;
var layerHostRef = React.useRef({
hostId: hostId,
rootRef: React.useRef(null),
notifyLayersChanged: function () {
// Nothing, since the default implementation of Layer Host does not
need to react to layer changes.
},
});
React.useImperativeHandle(props.componentRef, function () { return
layerHostRef.current; });
Layer_notification_1.registerLayerHost(hostId, layerHostRef.current);
Layer_notification_1.notifyHostChanged(hostId);
on first render
}, []);
Layer_notification_1.unregisterLayerHost(hostId, layerHostRef.current);
Layer_notification_1.notifyHostChanged(hostId);
});
return React.createElement("div", tslib_1.__assign({}, props, { className:
Utilities_1.css('ms-LayerHost', className), ref: layerHostRef.current.rootRef }));
};
exports.LayerHost = LayerHost;
//# sourceMappingURL=LayerHost.js.map
/***/ }),
/***/ 99640:
"use strict";

//# sourceMappingURL=LayerHost.types.js.map
/***/ }),
/***/ 99870:
"use strict";

exports.cleanupDefaultLayerHost = exports.createDefaultLayerHost = void 0;
Object.defineProperty(exports, "createDefaultLayerHost", ({ enumerable: true, get:
function () { return Layer_notification_1.createDefaultLayerHost; } }));
Object.defineProperty(exports, "cleanupDefaultLayerHost", ({ enumerable: true, get:
function () { return Layer_notification_1.cleanupDefaultLayerHost; } }));
/***/ }),
/***/ 53277:
"use strict";

exports.LinkBase = void 0;
var useLink_1 = __webpack_require__(88277);
exports.LinkBase = React.forwardRef(function (props, ref) {
var _a = useLink_1.useLink(props, ref), slots = _a.slots, slotProps =
_a.slotProps;
return React.createElement(slots.root, tslib_1.__assign({}, slotProps.root));
});
exports.LinkBase.displayName = 'LinkBase';
//# sourceMappingURL=Link.base.js.map
/***/ }),
/***/ 16949:
"use strict";

exports.Link = void 0;
var Link_base_1 = __webpack_require__(53277);
var Link_styles_1 = __webpack_require__(5378);
exports.Link = utilities_1.styled(Link_base_1.LinkBase, Link_styles_1.getStyles,
undefined, {
scope: 'Link',
});
//# sourceMappingURL=Link.js.map
/***/ }),
/***/ 5378:
"use strict";

exports.getStyles = exports.GlobalClassNames = void 0;
exports.GlobalClassNames = {
root: 'ms-Link',
};
var _a, _b, _c, _d, _e, _f;
var className = props.className, isButton = props.isButton, isDisabled =
props.isDisabled, isUnderlined = props.isUnderlined, theme = props.theme;
// Tokens
var linkColor = semanticColors.link;
var linkInteractedColor = semanticColors.linkHovered;
var linkDisabledColor = semanticColors.disabledText;
var focusBorderColor = semanticColors.focusBorder;
var classNames =
style_utilities_1.getGlobalClassNames(exports.GlobalClassNames, theme);
return {
root: [
classNames.root,
theme.fonts.medium,
{
color: linkColor,
outline: 'none',
textDecoration: isUnderlined ? 'underline' : 'none',
selectors: (_a = {
'.ms-Fabric--isFocusVisible &:focus': {
// Can't use getFocusStyle because it doesn't support
wrapping links
//
https://github.com/microsoft/fluentui/issues/4883#issuecomment-406743543
// Using box-shadow and outline allows the focus rect
to wrap links that span multiple lines
// and helps the focus rect avoid getting clipped.
boxShadow: "0 0 0 1px " + focusBorderColor + " inset",
outline: "1px auto " + focusBorderColor,
outline: '1px solid WindowText',
},
_b),
}
},
// For IE high contrast mode
borderBottom: 'none',
},
_a),
},
isButton && {
background: 'none',
border: 'none',
cursor: 'pointer',
display: 'inline',
margin: 0,
overflow: 'inherit',
padding: 0,
textAlign: 'left',
textOverflow: 'inherit',
userSelect: 'text',
borderBottom: '1px solid transparent',
color: 'LinkText',
},
_c),
},
!isButton && {
// This is mainly for MessageBar, which sets
MsHighContrastAdjust: none by default
MsHighContrastAdjust: 'auto',
},
_d),
},
isDisabled && [
'is-disabled',
{
color: linkDisabledColor,
cursor: 'default',
},
{
selectors: {
'&:link, &:visited': {
},
},
},
],
!isDisabled && {
selectors: {
'&:active, &:hover, &:active:hover': {
color: linkInteractedColor,
textDecoration: 'underline',
_e[style_utilities_1.HighContrastSelector] = {
color: 'LinkText',
},
_e),
},
'&:focus': {
color: linkColor,
color: 'LinkText',
},
_f),
},
},
},
classNames.root,
className,
],
};
};
//# sourceMappingURL=Link.styles.js.map
/***/ }),
/***/ 15126:
"use strict";

//# sourceMappingURL=Link.types.js.map
/***/ }),
/***/ 87636:
"use strict";

/***/ }),
/***/ 88277:
"use strict";

exports.useLink = void 0;
/**
* The useLink hook processes the Link component props and returns
* state, slots and slotProps for consumption by the component.
*/
var useLink = function (props, forwardedRef) {
var as = props.as, className = props.className, disabled = props.disabled, href
= props.href, onClick = props.onClick, styles = props.styles, theme = props.theme,
underline = props.underline;
useComponentRef(props, rootRef);
utilities_1.useFocusRects(rootRef);
isButton: !href,
isDisabled: disabled,
isUnderlined: underline,
theme: theme,
});
var _onClick = function (ev) {
if (disabled) {
}
else if (onClick) {
onClick(ev);
}
};
var rootType = as ? as : href ? 'a' : 'button';
var state = {};
var slots = { root: rootType };
var slotProps = {
root: tslib_1.__assign(tslib_1.__assign({},
adjustPropsForRootType(rootType, props)), { 'aria-disabled': disabled, className:
classNames.root, onClick: _onClick, ref: mergedRootRefs }),
};
return { state: state, slots: slots, slotProps: slotProps };
};
exports.useLink = useLink;
var useComponentRef = function (props, link) {
if (link.current) {
link.current.focus();
}
},
}); }, [link]);
};
var adjustPropsForRootType = function (RootType, props) {
// Deconstruct the props so we remove props like às`, `theme` and `styles`
// as those will always be removed. We also take some props that are optional
// based on the RootType.
var as = props.as, disabled = props.disabled, target = props.target, href =
props.href, theme = props.theme, getStyles = props.getStyles, styles =
props.styles, componentRef = props.componentRef, underline = props.underline,
restProps = tslib_1.__rest(props, ["as", "disabled", "target", "href", "theme",
"getStyles", "styles", "componentRef", "underline"]);
// RootType will be a string if we're dealing with an html component
if (typeof RootType === 'string') {
// Remove the disabled prop for anchor elements
if (RootType === 'a') {
return tslib_1.__assign({ target: target, href: disabled ? undefined :
href }, restProps);
}
// Add the type='button' prop for button elements
if (RootType === 'button') {
return tslib_1.__assign({ type: 'button', disabled: disabled },
restProps);
}
// Remove the target and href props for all other non anchor elements
return tslib_1.__assign(tslib_1.__assign({}, restProps), { disabled:
disabled });
}
// Retain all props except 'as' for ReactComponents
return tslib_1.__assign({ target: target, href: href, disabled: disabled },
restProps);
};
//# sourceMappingURL=useLink.js.map
/***/ }),
/***/ 83885:
"use strict";

exports.List = void 0;
var List_types_1 = __webpack_require__(95632);
var RESIZE_DELAY = 16;
var MIN_SCROLL_UPDATE_DELAY = 100;
var MAX_SCROLL_UPDATE_DELAY = 500;
var IDLE_DEBOUNCE_DELAY = 200;
// The amount of time to wait before declaring that the list isn't scrolling
var DONE_SCROLLING_WAIT = 500;
var DEFAULT_ITEMS_PER_PAGE = 10;
var DEFAULT_PAGE_HEIGHT = 30;
var DEFAULT_RENDERED_WINDOWS_BEHIND = 2;
var DEFAULT_RENDERED_WINDOWS_AHEAD = 2;
var PAGE_KEY_PREFIX = 'page-';
var SPACER_KEY_PREFIX = 'spacer-';
var EMPTY_RECT = {
top: -1,
bottom: -1,
left: -1,
right: -1,
width: 0,
height: 0,
};
// Naming expensive measures so that they're named in profiles.
var _measurePageRect = function (element) { return element.getBoundingClientRect();
};
var _measureSurfaceRect = _measurePageRect;
var _measureScrollRect = _measurePageRect;
/**
* The List renders virtualized pages of items. Each page's item count is
determined by the getItemCountForPage callback
* if provided by the caller, or 10 as default. Each page's height is determined by
the getPageHeight callback if
* provided by the caller, or by cached measurements if available, or by a running
average, or a default fallback.
*
* The algorithm for rendering pages works like this:
*
* 1. Predict visible pages based on "current measure data" (page heights, surface
position, visible window)
* 2. If changes are necessary, apply changes (add/remove pages)
* 3. For pages that are added, measure the page heights if we need to using
getBoundingClientRect
* 4. If measurements don't match predictions, update measure data and goto step 1
asynchronously
*
* Measuring too frequently can pull performance down significantly. To compensate,
we cache measured values so that
* we can avoid re-measuring during operations that should not alter heights, like
scrolling.
*
* To optimize glass rendering performance, onShouldVirtualize can be set. When
onShouldVirtualize return false,
* List will run in fast mode (not virtualized) to render all items without any
measurements to improve page load time.
* And we start doing measurements and rendering in virtualized mode when items
grows larger than this threshold.
*
* However, certain operations can make measure data stale. For example, resizing
the list, or passing in new props,
* or forcing an update change cause pages to shrink/grow. When these operations
occur, we increment a measureVersion
* number, which we associate with cached measurements and use to determine if a
remeasure should occur.
*/
var List = /** @class */ (function (_super) {
tslib_1.__extends(List, _super);
function List(props) {
_this._surface = React.createRef();
_this._pageRefs = {};
_this._getDerivedStateFromProps = function (nextProps, previousState) {
if (nextProps.items !== _this.props.items ||
nextProps.renderCount !== _this.props.renderCount ||
nextProps.startIndex !== _this.props.startIndex ||
nextProps.version !== _this.props.version) {
// We have received new items so we want to make sure that
initially we only render a single window to
// fill the currently visible rect, and then later render
additional windows.
_this._resetRequiredWindows();
_this._requiredRect = null;
_this._measureVersion++;
_this._invalidatePageCache();
return _this._updatePages(nextProps, previousState);
}
};
_this._onRenderRoot = function (props) {
var rootRef = props.rootRef, surfaceElement = props.surfaceElement,
divProps = props.divProps;
return (React.createElement("div", tslib_1.__assign({ ref: rootRef },
divProps), surfaceElement));
};
_this._onRenderSurface = function (props) {
var surfaceRef = props.surfaceRef, pageElements = props.pageElements,
divProps = props.divProps;
return (React.createElement("div", tslib_1.__assign({ ref:
surfaceRef }, divProps), pageElements));
};
_this._onRenderPage = function (pageProps, defaultRender) {
var _a = _this.props, onRenderCell = _a.onRenderCell, role = _a.role;
var _b = pageProps.page, _c = _b.items, items = _c === void 0 ? [] :
_c, startIndex = _b.startIndex, divProps = tslib_1.__rest(pageProps, ["page"]);
// only assign list item role if no role is assigned
var cellRole = role === undefined ? 'listitem' : 'presentation';
var cells = [];
for (var i = 0; i < items.length; i++) {
var index = startIndex + i;
var item = items[i];
var itemKey = _this.props.getKey ? _this.props.getKey(item,
index) : item && item.key;
if (itemKey === null || itemKey === undefined) {
itemKey = index;
}
cells.push(React.createElement("div", { role: cellRole, className:
'ms-List-cell', key: itemKey, "data-list-index": index, "data-automationid":
"ListCell" }, onRenderCell &&
onRenderCell(item, index, !_this.props.ignoreScrollingState ?
_this.state.isScrolling : undefined)));
}
return React.createElement("div", tslib_1.__assign({}, divProps),
cells);
};
_this.state = {
pages: [],
isScrolling: false,
getDerivedStateFromProps: _this._getDerivedStateFromProps,
};
_this._estimatedPageHeight = 0;
_this._totalEstimates = 0;
_this._requiredWindowsAhead = 0;
_this._requiredWindowsBehind = 0;
// Track the measure version for everything.
_this._measureVersion = 0;
// Ensure that scrolls are lazy updated.
_this._onAsyncScroll = _this._async.debounce(_this._onAsyncScroll,
MIN_SCROLL_UPDATE_DELAY, {
leading: false,
maxWait: MAX_SCROLL_UPDATE_DELAY,
});
_this._onAsyncIdle = _this._async.debounce(_this._onAsyncIdle,
IDLE_DEBOUNCE_DELAY, {
leading: false,
});
_this._onAsyncResize = _this._async.debounce(_this._onAsyncResize,
RESIZE_DELAY, {
leading: false,
});
_this._onScrollingDone = _this._async.debounce(_this._onScrollingDone,
DONE_SCROLLING_WAIT, {
leading: false,
});
_this._cachedPageHeights = {};
_this._estimatedPageHeight = 0;
_this._focusedIndex = -1;
_this._pageCache = {};
return _this;
}
List.getDerivedStateFromProps = function (nextProps, previousState) {
return previousState.getDerivedStateFromProps(nextProps, previousState);
};
Object.defineProperty(List.prototype, "pageRefs", {
get: function () {
return this._pageRefs;
},
enumerable: false,
configurable: true
});
/**
* Scroll to the given index. By default will bring the page the specified item
is on into the view. If a callback
* to measure the height of an individual item is specified, will only scroll
to bring the specific item into view.
*
* Note: with items of variable height and no passed in `getPageHeight` method,
the list might jump after scrolling
* when windows before/ahead are being rendered, and the estimated height is
replaced using actual elements.
*
* @param index - Index of item to scroll to
* @param measureItem - Optional callback to measure the height of an
individual item
* @param scrollToMode - Optional defines where in the window the item should
be positioned to when scrolling
*/
List.prototype.scrollToIndex = function (index, measureItem, scrollToMode) {
if (scrollToMode === void 0) { scrollToMode =
List_types_1.ScrollToMode.auto; }
var startIndex = this.props.startIndex;
var renderCount = this._getRenderCount();
var endIndex = startIndex + renderCount;
var allowedRect = this._allowedRect;
var scrollTop = 0;
var itemsPerPage = 1;
for (var itemIndex = startIndex; itemIndex < endIndex; itemIndex +=
itemsPerPage) {
var pageSpecification = this._getPageSpecification(itemIndex,
allowedRect);
var pageHeight = pageSpecification.height;
itemsPerPage = pageSpecification.itemCount;
var requestedIndexIsInPage = itemIndex <= index && itemIndex +
itemsPerPage > index;
if (requestedIndexIsInPage) {
// We have found the page. If the user provided a way to measure an
individual item, we will try to scroll in
// just the given item, otherwise we'll only bring the page into
view
if (measureItem && this._scrollElement) {
var scrollRect = _measureScrollRect(this._scrollElement);
var scrollWindow = {
top: this._scrollElement.scrollTop,
bottom: this._scrollElement.scrollTop + scrollRect.height,
};
// Adjust for actual item position within page
var itemPositionWithinPage = index - itemIndex;
for (var itemIndexInPage = 0; itemIndexInPage <
itemPositionWithinPage; ++itemIndexInPage) {
scrollTop += measureItem(itemIndex + itemIndexInPage);
}
var scrollBottom = scrollTop + measureItem(index);
// If scrollToMode is set to something other than auto, we
always want to
// scroll the item into a specific position on the page.
switch (scrollToMode) {
case List_types_1.ScrollToMode.top:
this._scrollElement.scrollTop = scrollTop;
return;
case List_types_1.ScrollToMode.bottom:
this._scrollElement.scrollTop = scrollBottom -
scrollRect.height;
return;
case List_types_1.ScrollToMode.center:
this._scrollElement.scrollTop = (scrollTop +
scrollBottom - scrollRect.height) / 2;
return;
case List_types_1.ScrollToMode.auto:
default:
break;
}
var itemIsFullyVisible = scrollTop >= scrollWindow.top &&
scrollBottom <= scrollWindow.bottom;
if (itemIsFullyVisible) {
// Item is already visible, do nothing.
return;
}
var itemIsPartiallyAbove = scrollTop < scrollWindow.top;
var itemIsPartiallyBelow = scrollBottom > scrollWindow.bottom;
if (itemIsPartiallyAbove) {
// We will just scroll to 'scrollTop'
// .------. - scrollTop
// |Item |
// | .----|-. - scrollWindow.top
// '------' |
// | |
// '------'
}
else if (itemIsPartiallyBelow) {
// Adjust scrollTop position to just bring in the element
// .------. - scrollTop
// | |
// | .------.
// '-|----' | - scrollWindow.bottom
// | Item |
// '------' - scrollBottom
scrollTop = scrollBottom - scrollRect.height;
}
}
if (this._scrollElement) {
this._scrollElement.scrollTop = scrollTop;
}
return;
}
scrollTop += pageHeight;
}
};
List.prototype.getStartItemIndexInView = function (measureItem) {
var pages = this.state.pages || [];
for (var _i = 0, pages_1 = pages; _i < pages_1.length; _i++) {
var page = pages_1[_i];
var isPageVisible = !page.isSpacer && (this._scrollTop || 0) >=
page.top && (this._scrollTop || 0) <= page.top + page.height;
if (isPageVisible) {
if (!measureItem) {
var rowHeight = Math.floor(page.height / page.itemCount);
return page.startIndex + Math.floor((this._scrollTop -
page.top) / rowHeight);
}
else {
var totalRowHeight = 0;
for (var itemIndex = page.startIndex; itemIndex <
page.startIndex + page.itemCount; itemIndex++) {
var rowHeight = measureItem(itemIndex);
if (page.top + totalRowHeight <= this._scrollTop &&
this._scrollTop < page.top + totalRowHeight +
rowHeight) {
return itemIndex;
}
else {
totalRowHeight += rowHeight;
}
}
}
}
}
return 0;
};
List.prototype.componentDidMount = function () {
this.setState(this._updatePages(this.props, this.state));
this._measureVersion++;
this._scrollElement = Utilities_1.findScrollableParent(this._root.current);
this._events.on(window, 'resize', this._onAsyncResize);
this._events.on(this._root.current, 'focus', this._onFocus, true);
}
if (this._scrollElement) {
this._events.on(this._scrollElement, 'scroll', this._onScroll);
this._events.on(this._scrollElement, 'scroll', this._onAsyncScroll);
}
};
List.prototype.componentDidUpdate = function (previousProps, previousState) {
// Multiple updates may have been queued, so the callback will reflect all
of them.
// Re-fetch the current props and states to avoid using a stale props or
state captured in the closure.
var finalProps = this.props;
var finalState = this.state;
if (this.state.pagesVersion !== previousState.pagesVersion) {
// If we weren't provided with the page height, measure the pages
if (!finalProps.getPageHeight) {
// If measured version is invalid since we've updated the DOM
var heightsChanged =
this._updatePageMeasurements(finalState.pages);
// On first render, we should re-measure so that we don't get a
visual glitch.
if (heightsChanged) {
this._materializedRect = null;
if (!this._hasCompletedFirstRender) {
this._hasCompletedFirstRender = true;
this.setState(this._updatePages(finalProps, finalState));
}
else {
this._onAsyncScroll();
}
}
else {
// Enqueue an idle bump.
this._onAsyncIdle();
}
}
else {
// Enqueue an idle bump
}
// Notify the caller that rendering the new pages has completed
if (finalProps.onPagesUpdated) {
finalProps.onPagesUpdated(finalState.pages);
}
}
};
List.prototype.componentWillUnmount = function () {
delete this._scrollElement;
};
List.prototype.shouldComponentUpdate = function (newProps, newState) {
var oldPages = this.state.pages;
var newPages = newState.pages;
var shouldComponentUpdate = false;
// Update if the page stops scrolling
if (!newState.isScrolling && this.state.isScrolling) {
return true;
}
if (newProps.version !== this.props.version) {
return true;
}
if (newProps.className !== this.props.className) {
return true;
}
if (newProps.items === this.props.items && oldPages.length ===
newPages.length) {
for (var i = 0; i < oldPages.length; i++) {
var oldPage = oldPages[i];
var newPage = newPages[i];
if (oldPage.key !== newPage.key || oldPage.itemCount !==
newPage.itemCount) {
shouldComponentUpdate = true;
break;
}
}
}
else {
shouldComponentUpdate = true;
}
return shouldComponentUpdate;
};
List.prototype.forceUpdate = function () {
this._invalidatePageCache();
// Ensure that when the list is force updated we update the pages first
before render.
this._updateRenderRects(this.props, this.state, true);
};
/**
* Get the current height the list and it's pages.
*/
List.prototype.getTotalListHeight = function () {
return this._surfaceRect.height;
};
List.prototype.render = function () {
var _a = this.props, className = _a.className, _b = _a.role, role = _b ===
void 0 ? 'list' : _b, onRenderSurface = _a.onRenderSurface, onRenderRoot =
_a.onRenderRoot;
var _c = this.state.pages, pages = _c === void 0 ? [] : _c;
var pageElements = [];
for (var _i = 0, pages_2 = pages; _i < pages_2.length; _i++) {
var page = pages_2[_i];
pageElements.push(this._renderPage(page));
}
var finalOnRenderSurface = onRenderSurface
? Utilities_2.composeRenderFunction(onRenderSurface,
this._onRenderSurface)
: this._onRenderSurface;
var finalOnRenderRoot = onRenderRoot
? Utilities_2.composeRenderFunction(onRenderRoot, this._onRenderRoot)
: this._onRenderRoot;
return finalOnRenderRoot({
rootRef: this._root,
pages: pages,
surfaceElement: finalOnRenderSurface({
surfaceRef: this._surface,
pages: pages,
pageElements: pageElements,
divProps: {
role: 'presentation',
className: 'ms-List-surface',
},
}),
divProps: tslib_1.__assign(tslib_1.__assign({}, divProps), { className:
Utilities_1.css('ms-List', className), role: pageElements.length > 0 ? role :
undefined, 'aria-label': pageElements.length > 0 ? divProps['aria-label'] :
undefined }),
});
};
List.prototype._shouldVirtualize = function (props) {
if (props === void 0) { props = this.props; }
var onShouldVirtualize = props.onShouldVirtualize;
return !onShouldVirtualize || onShouldVirtualize(props);
};
/**
* when props.items change or forceUpdate called, throw away cached pages
*/
List.prototype._invalidatePageCache = function () {
this._pageCache = {};
};
List.prototype._renderPage = function (page) {
var _this = this;
var usePageCache = this.props.usePageCache;
var cachedPage;
// if usePageCache is set and cached page element can be found, just return
cached page
if (usePageCache) {
cachedPage = this._pageCache[page.key];
if (cachedPage && cachedPage.pageElement) {
return cachedPage.pageElement;
}
}
var pageStyle = this._getPageStyle(page);
var _a = this.props.onRenderPage, onRenderPage = _a === void 0 ?
this._onRenderPage : _a;
var pageElement = onRenderPage({
page: page,
className: 'ms-List-page',
key: page.key,
ref: function (newRef) {
_this._pageRefs[page.key] = newRef;
},
style: pageStyle,
role: 'presentation',
}, this._onRenderPage);
// cache the first page for now since it is re-rendered a lot times
unnecessarily.
// todo: a more aggresive caching mechanism is to cache pages constaining
the items not changed.
// now we re-render pages too frequently, for example, props.items
increased from 30 to 60, although the
// first 30 items did not change, we still re-rendered all of them in this
props.items change.
if (usePageCache && page.startIndex === 0) {
this._pageCache[page.key] = {
page: page,
pageElement: pageElement,
};
}
return pageElement;
};
/** Generate the style object for the page. */
List.prototype._getPageStyle = function (page) {
var getPageStyle = this.props.getPageStyle;
return tslib_1.__assign(tslib_1.__assign({}, (getPageStyle ?
getPageStyle(page) : {})), (!page.items
? {
height: page.height,
}
: {}));
};
/** Track the last item index focused so that we ensure we keep it rendered. */
List.prototype._onFocus = function (ev) {
while (target !== this._surface.current) {
var indexString = target.getAttribute('data-list-index');
if (indexString) {
this._focusedIndex = Number(indexString);
break;
}
target = Utilities_1.getParent(target);
}
};
/**
* Called synchronously to reset the required render range to 0 on scrolling.
After async scroll has executed,
* we will call onAsyncIdle which will reset it back to it's correct value.
*/
List.prototype._onScroll = function () {
if (!this.state.isScrolling && !this.props.ignoreScrollingState) {
this.setState({ isScrolling: true });
}
this._resetRequiredWindows();
this._onScrollingDone();
};
List.prototype._resetRequiredWindows = function () {
this._requiredWindowsAhead = 0;
this._requiredWindowsBehind = 0;
};
/**
* Debounced method to asynchronously update the visible region on a scroll
event.
*/
List.prototype._onAsyncScroll = function () {
this._updateRenderRects(this.props, this.state);
// Only update pages when the visible rect falls outside of the
materialized rect.
if (!this._materializedRect || !_isContainedWithin(this._requiredRect,
this._materializedRect)) {
}
else {
// console.log('requiredRect contained in materialized',
this._requiredRect, this._materializedRect);
}
};
/**
* This is an async debounced method that will try and increment the windows we
render. If we can increment
* either, we increase the amount we render and re-evaluate.
*/
List.prototype._onAsyncIdle = function () {
var _a = this.props, renderedWindowsAhead = _a.renderedWindowsAhead,
renderedWindowsBehind = _a.renderedWindowsBehind;
var _b = this, requiredWindowsAhead = _b._requiredWindowsAhead,
requiredWindowsBehind = _b._requiredWindowsBehind;
var windowsAhead = Math.min(renderedWindowsAhead, requiredWindowsAhead +
1);
var windowsBehind = Math.min(renderedWindowsBehind, requiredWindowsBehind +
1);
if (windowsAhead !== requiredWindowsAhead || windowsBehind !==
requiredWindowsBehind) {
// console.log('idling', windowsBehind, windowsAhead);
this._requiredWindowsAhead = windowsAhead;
this._requiredWindowsBehind = windowsBehind;
this._updateRenderRects(this.props, this.state);
}
if (renderedWindowsAhead > windowsAhead || renderedWindowsBehind >
windowsBehind) {
// Async increment on next tick.
}
};
/**
* Function to call when the list is done scrolling.
* This function is debounced.
*/
List.prototype._onScrollingDone = function () {
if (!this.props.ignoreScrollingState) {
this.setState({ isScrolling: false });
}
};
List.prototype._onAsyncResize = function () {
this.forceUpdate();
};
List.prototype._updatePages = function (nextProps, previousState) {
// console.log('updating pages');
if (!this._requiredRect) {
this._updateRenderRects(nextProps, previousState);
}
var newListState = this._buildPages(nextProps, previousState);
var oldListPages = previousState.pages;
this._notifyPageChanges(oldListPages, newListState.pages, this.props);
return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({},
previousState), newListState), { pagesVersion: {} });
};
/**
* Notify consumers that the rendered pages have changed
* @param oldPages - The old pages
* @param newPages - The new pages
* @param props - The props to use
*/
List.prototype._notifyPageChanges = function (oldPages, newPages, props) {
var onPageAdded = props.onPageAdded, onPageRemoved = props.onPageRemoved;
if (onPageAdded || onPageRemoved) {
var renderedIndexes = {};
for (var _i = 0, oldPages_1 = oldPages; _i < oldPages_1.length; _i++) {
var page = oldPages_1[_i];
if (page.items) {
renderedIndexes[page.startIndex] = page;
}
}
for (var _a = 0, newPages_1 = newPages; _a < newPages_1.length; _a++) {
var page = newPages_1[_a];
if (page.items) {
if (!renderedIndexes[page.startIndex]) {
this._onPageAdded(page);
}
else {
delete renderedIndexes[page.startIndex];
}
}
}
for (var index in renderedIndexes) {
if (renderedIndexes.hasOwnProperty(index)) {
this._onPageRemoved(renderedIndexes[index]);
}
}
}
};
List.prototype._updatePageMeasurements = function (pages) {
var heightChanged = false;
// when not in virtualize mode, we render all the items without page
measurement
if (!this._shouldVirtualize()) {
return heightChanged;
}
for (var i = 0; i < pages.length; i++) {
var page = pages[i];
if (page.items) {
heightChanged = this._measurePage(page) || heightChanged;
}
}
return heightChanged;
};
/**
* Given a page, measure its dimensions, update cache.
* @returns True if the height has changed.
*/
List.prototype._measurePage = function (page) {
var hasChangedHeight = false;
var pageElement = this._pageRefs[page.key];
var cachedHeight = this._cachedPageHeights[page.startIndex];
// console.log(' * measure attempt', page.startIndex, cachedHeight);
if (pageElement &&
this._shouldVirtualize() &&
(!cachedHeight || cachedHeight.measureVersion !==
this._measureVersion)) {
var newClientRect = {
width: pageElement.clientWidth,
height: pageElement.clientHeight,
};
if (newClientRect.height || newClientRect.width) {
hasChangedHeight = page.height !== newClientRect.height;
// console.warn(' *** expensive page measure', page.startIndex,
page.height, newClientRect.height);
page.height = newClientRect.height;
this._cachedPageHeights[page.startIndex] = {
height: newClientRect.height,
measureVersion: this._measureVersion,
};
this._estimatedPageHeight = Math.round((this._estimatedPageHeight *
this._totalEstimates + newClientRect.height) / (this._totalEstimates + 1));
this._totalEstimates++;
}
}
return hasChangedHeight;
};
/** Called when a page has been added to the DOM. */
List.prototype._onPageAdded = function (page) {
var onPageAdded = this.props.onPageAdded;
// console.log('page added', page.startIndex, this.state.pages.map(page =>
page.key).join(', '));
if (onPageAdded) {
onPageAdded(page);
}
};
/** Called when a page has been removed from the DOM. */
List.prototype._onPageRemoved = function (page) {
var onPageRemoved = this.props.onPageRemoved;
// console.log(' --- page removed', page.startIndex,
this.state.pages.map(page => page.key).join(', '));
if (onPageRemoved) {
onPageRemoved(page);
}
};
/** Build up the pages that should be rendered. */
List.prototype._buildPages = function (props, state) {
var renderCount = props.renderCount;
var items = props.items, startIndex = props.startIndex, getPageHeight =
props.getPageHeight;
renderCount = this._getRenderCount(props);
var materializedRect = tslib_1.__assign({}, EMPTY_RECT);
var pages = [];
var itemsPerPage = 1;
var pageTop = 0;
var currentSpacer = null;
var focusedIndex = this._focusedIndex;
var endIndex = startIndex + renderCount;
var shouldVirtualize = this._shouldVirtualize(props);
// First render is very important to track; when we render cells, we have
no idea of estimated page height.
// So we should default to rendering only the first page so that we can get
information.
// However if the user provides a measure function, let's just assume they
know the right heights.
var isFirstRender = this._estimatedPageHeight === 0 && !getPageHeight;
var allowedRect = this._allowedRect;
var _loop_1 = function (itemIndex) {
var pageSpecification = this_1._getPageSpecification(itemIndex,
allowedRect);
var pageHeight = pageSpecification.height;
var pageData = pageSpecification.data;
var key = pageSpecification.key;
itemsPerPage = pageSpecification.itemCount;
var pageBottom = pageTop + pageHeight - 1;
var isPageRendered = Utilities_1.findIndex(state.pages, function (page)
{ return !!page.items && page.startIndex === itemIndex; }) > -1;
var isPageInAllowedRange = !allowedRect || (pageBottom >=
allowedRect.top && pageTop <= allowedRect.bottom);
var isPageInRequiredRange = !this_1._requiredRect || (pageBottom >=
this_1._requiredRect.top && pageTop <= this_1._requiredRect.bottom);
var isPageVisible = (!isFirstRender && (isPageInRequiredRange ||
(isPageInAllowedRange && isPageRendered))) || !shouldVirtualize;
var isPageFocused = focusedIndex >= itemIndex && focusedIndex <
itemIndex + itemsPerPage;
var isFirstPage = itemIndex === startIndex;
// console.log('building page', itemIndex, 'pageTop: ' + pageTop,
'inAllowed: ' +
// isPageInAllowedRange, 'inRequired: ' + isPageInRequiredRange);
// Only render whats visible, focused, or first page,
// or when running in fast rendering mode (not in virtualized mode), we
render all current items in pages
if (isPageVisible || isPageFocused || isFirstPage) {
if (currentSpacer) {
pages.push(currentSpacer);
currentSpacer = null;
}
var itemsInPage = Math.min(itemsPerPage, endIndex - itemIndex);
var newPage = this_1._createPage(key, items.slice(itemIndex,
itemIndex + itemsInPage), itemIndex, undefined, undefined, pageData);
newPage.top = pageTop;
newPage.height = pageHeight;
if (this_1._visibleRect && this_1._visibleRect.bottom) {
newPage.isVisible = pageBottom >= this_1._visibleRect.top &&
pageTop <= this_1._visibleRect.bottom;
}
pages.push(newPage);
if (isPageInRequiredRange && this_1._allowedRect) {
_mergeRect(materializedRect, {
top: pageTop,
bottom: pageBottom,
height: pageHeight,
left: allowedRect.left,
right: allowedRect.right,
width: allowedRect.width,
});
}
}
else {
if (!currentSpacer) {
currentSpacer = this_1._createPage(SPACER_KEY_PREFIX +
itemIndex, undefined, itemIndex, 0, undefined, pageData, true /*isSpacer*/);
}
currentSpacer.height = (currentSpacer.height || 0) + (pageBottom -
pageTop) + 1;
currentSpacer.itemCount += itemsPerPage;
}
pageTop += pageBottom - pageTop + 1;
// in virtualized mode, we render need to render first page then break
and measure,
// otherwise, we render all items without measurement to make rendering
fast
if (isFirstRender && shouldVirtualize) {
return "break";
}
};
var this_1 = this;
for (var itemIndex = startIndex; itemIndex < endIndex; itemIndex +=
itemsPerPage) {
var state_1 = _loop_1(itemIndex);
if (state_1 === "break")
break;
}
if (currentSpacer) {
currentSpacer.key = SPACER_KEY_PREFIX + 'end';
pages.push(currentSpacer);
}
this._materializedRect = materializedRect;
// console.log('materialized: ', materializedRect);
return tslib_1.__assign(tslib_1.__assign({}, state), { pages: pages,
measureVersion: this._measureVersion });
};
List.prototype._getPageSpecification = function (itemIndex, visibleRect) {
var getPageSpecification = this.props.getPageSpecification;
if (getPageSpecification) {
var pageData = getPageSpecification(itemIndex, visibleRect);
var _a = pageData.itemCount, itemCount = _a === void 0 ?
this._getItemCountForPage(itemIndex, visibleRect) : _a;
var _b = pageData.height, height = _b === void 0 ?
this._getPageHeight(itemIndex, visibleRect, itemCount) : _b;
return {
itemCount: itemCount,
height: height,
data: pageData.data,
key: pageData.key,
};
}
else {
var itemCount = this._getItemCountForPage(itemIndex, visibleRect);
return {
itemCount: itemCount,
height: this._getPageHeight(itemIndex, visibleRect, itemCount),
};
}
};
/**
* Get the pixel height of a give page. Will use the props getPageHeight first,
and if not provided, fallback to
* cached height, or estimated page height, or default page height.
*/
List.prototype._getPageHeight = function (itemIndex, visibleRect, itemsPerPage)
{
if (this.props.getPageHeight) {
return this.props.getPageHeight(itemIndex, visibleRect, itemsPerPage);
}
else {
var cachedHeight = this._cachedPageHeights[itemIndex];
return cachedHeight ? cachedHeight.height : this._estimatedPageHeight
|| DEFAULT_PAGE_HEIGHT;
}
};
List.prototype._getItemCountForPage = function (itemIndex, visibileRect) {
var itemsPerPage = this.props.getItemCountForPage
? this.props.getItemCountForPage(itemIndex, visibileRect)
: DEFAULT_ITEMS_PER_PAGE;
return itemsPerPage ? itemsPerPage : DEFAULT_ITEMS_PER_PAGE;
};
List.prototype._createPage = function (pageKey, items, startIndex, count,
style, data, isSpacer) {
if (startIndex === void 0) { startIndex = -1; }
if (count === void 0) { count = items ? items.length : 0; }
if (style === void 0) { style = {}; }
pageKey = pageKey || PAGE_KEY_PREFIX + startIndex;
var cachedPage = this._pageCache[pageKey];
if (cachedPage && cachedPage.page) {
return cachedPage.page;
}
return {
key: pageKey,
startIndex: startIndex,
itemCount: count,
items: items,
style: style,
top: 0,
height: 0,
data: data,
isSpacer: isSpacer || false,
};
};
List.prototype._getRenderCount = function (props) {
var _a = props || this.props, items = _a.items, startIndex = _a.startIndex,
renderCount = _a.renderCount;
return renderCount === undefined ? (items ? items.length - startIndex :
0) : renderCount;
};
/** Calculate the visible rect within the list where top: 0 and left: 0 is the
top/left of the list. */
List.prototype._updateRenderRects = function (props, state, forceUpdate) {
var renderedWindowsAhead = props.renderedWindowsAhead,
renderedWindowsBehind = props.renderedWindowsBehind;
var pages = state.pages;
// when not in virtualize mode, we render all items without measurement to
optimize page rendering perf
if (!this._shouldVirtualize(props)) {
return;
}
var surfaceRect = this._surfaceRect || tslib_1.__assign({}, EMPTY_RECT);
var scrollHeight = this._scrollElement && this._scrollElement.scrollHeight;
var scrollTop = this._scrollElement ? this._scrollElement.scrollTop : 0;
// WARNING: EXPENSIVE CALL! We need to know the surface top relative to the
window.
// This needs to be called to recalculate when new pages should be loaded.
// We check to see how far we've scrolled and if it's further than a third
of a page we run it again.
if (this._surface.current &&
(forceUpdate ||
!pages ||
!this._surfaceRect ||
!scrollHeight ||
scrollHeight !== this._scrollHeight ||
Math.abs(this._scrollTop - scrollTop) > this._estimatedPageHeight /
3)) {
surfaceRect = this._surfaceRect =
_measureSurfaceRect(this._surface.current);
this._scrollTop = scrollTop;
}
// If the scroll height has changed, something in the container likely
resized and
// we should redo the page heights incase their content resized.
if (forceUpdate || !scrollHeight || scrollHeight !== this._scrollHeight) {
}
this._scrollHeight = scrollHeight || 0;
// If the surface is above the container top or below the container bottom,
or if this is not the first
// render return empty rect.
// The first time the list gets rendered we need to calculate the
rectangle. The width of the list is
// used to calculate the width of the list items.
var visibleTop = Math.max(0, -surfaceRect.top);
var win = Utilities_1.getWindow(this._root.current);
var visibleRect = {
top: visibleTop,
left: surfaceRect.left,
bottom: visibleTop + win.innerHeight,
right: surfaceRect.right,
width: surfaceRect.width,
height: win.innerHeight,
};
// The required/allowed rects are adjusted versions of the visible rect.
this._requiredRect = _expandRect(visibleRect, this._requiredWindowsBehind,
this._requiredWindowsAhead);
this._allowedRect = _expandRect(visibleRect, renderedWindowsBehind,
renderedWindowsAhead);
// store the visible rect for later use.
this._visibleRect = visibleRect;
};
List.defaultProps = {
startIndex: 0,
onRenderCell: function (item, index, containsFocus) { return
React.createElement(React.Fragment, null, (item && item.name) || ''); },
renderedWindowsAhead: DEFAULT_RENDERED_WINDOWS_AHEAD,
renderedWindowsBehind: DEFAULT_RENDERED_WINDOWS_BEHIND,
};
return List;
exports.List = List;
function _expandRect(rect, pagesBefore, pagesAfter) {
var top = rect.top - pagesBefore * rect.height;
var height = rect.height + (pagesBefore + pagesAfter) * rect.height;
return {
top: top,
bottom: top + height,
height: height,
left: rect.left,
right: rect.right,
width: rect.width,
};
}
function _isContainedWithin(innerRect, outerRect) {
return (innerRect.top >= outerRect.top &&
innerRect.left >= outerRect.left &&
innerRect.bottom <= outerRect.bottom &&
innerRect.right <= outerRect.right);
}
function _mergeRect(targetRect, newRect) {
targetRect.top = newRect.top < targetRect.top || targetRect.top === -1 ?
newRect.top : targetRect.top;
targetRect.left = newRect.left < targetRect.left || targetRect.left === -1 ?
newRect.left : targetRect.left;
targetRect.bottom =
newRect.bottom > targetRect.bottom || targetRect.bottom === -1 ?
newRect.bottom : targetRect.bottom;
targetRect.right = newRect.right > targetRect.right || targetRect.right === -
1 ? newRect.right : targetRect.right;
targetRect.width = targetRect.right - targetRect.left + 1;
targetRect.height = targetRect.bottom - targetRect.top + 1;
return targetRect;
}
//# sourceMappingURL=List.js.map
/***/ }),
/***/ 95632:
"use strict";
exports.ScrollToMode = void 0;
/**
* {@docCategory List}
*/
exports.ScrollToMode = {
/**
* Does not make any consideration to where in the viewport the item should
align to.
*/
auto: 0,
/**
* Attempts to scroll the list so the top of the desired item is aligned with
the top of the viewport.
*/
top: 1,
/**
* Attempts to scroll the list so the bottom of the desired item is aligned
with the bottom of the viewport.
*/
bottom: 2,
/**
* Attempts to scroll the list so the desired item is in the exact center of
the viewport.
*/
center: 3,
};
//# sourceMappingURL=List.types.js.map
/***/ }),
/***/ 17278:
"use strict";

/***/ }),
/***/ 42337:
"use strict";

exports.MarqueeSelectionBase = void 0;
// We want to make the marquee selection start when the user drags a minimum
distance. Otherwise we'd start
// the drag even if they just click an item without moving.
var MIN_DRAG_DISTANCE = 5;
/**
* MarqueeSelection component abstracts managing a draggable rectangle which sets
items selected/not selected.
* Elements which have data-selectable-index attributes are queried and measured
once to determine if they
* fall within the bounds of the rectangle. The measure is memoized during the drag
as a performance optimization
* so if the items change sizes while dragging, that could cause incorrect results.
*/
var MarqueeSelectionBase = /** @class */ (function (_super) {
tslib_1.__extends(MarqueeSelectionBase, _super);
function MarqueeSelectionBase(props) {
var _a = _this.props, isEnabled = _a.isEnabled, onShouldStartSelection
= _a.onShouldStartSelection;
// Ensure the mousedown is within the boundaries of the target. If not,
it may have been a click on a scrollbar.
if (_this._isMouseEventOnScrollbar(ev)) {
return;
}
if (_this._isInSelectionToggle(ev)) {
return;
}
if (!_this._isTouch &&
isEnabled &&
!_this._isDragStartInSelection(ev) &&
(!onShouldStartSelection || onShouldStartSelection(ev))) {
if (_this._scrollableSurface && ev.button === 0 &&
_this._root.current) {
_this._selectedIndicies = {};
_this._preservedIndicies = undefined;
_this._events.on(window, 'mousemove', _this._onAsyncMouseMove,
true);
_this._events.on(_this._scrollableParent, 'scroll',
_this._onAsyncMouseMove);
_this._events.on(window, 'click', _this._onMouseUp, true);
_this._autoScroll = new
Utilities_1.AutoScroll(_this._root.current);
_this._scrollTop = _this._scrollableSurface.scrollTop;
_this._scrollLeft = _this._scrollableSurface.scrollLeft;
_this._rootRect = _this._root.current.getBoundingClientRect();
}
}
};
_this._isTouch = true;
_this._isTouch = false;
}, 0);
};
_this._isTouch = true;
}, 0);
}
};
_this.state = {
dragRect: undefined,
};
return _this;
}
MarqueeSelectionBase.prototype.componentDidMount = function () {
this._scrollableParent =
Utilities_1.findScrollableParent(this._root.current);
this._scrollableSurface = this._scrollableParent === window ? document.body
: this._scrollableParent;
// When scroll events come from window, we need to read scrollTop values
from the body.
var hitTarget = this.props.isDraggingConstrainedToRoot ? this._root.current
: this._scrollableSurface;
this._events.on(hitTarget, 'mousedown', this._onMouseDown);
this._events.on(hitTarget, 'touchstart', this._onTouchStart, true);
this._events.on(hitTarget, 'pointerdown', this._onPointerDown, true);
};
MarqueeSelectionBase.prototype.componentWillUnmount = function () {
if (this._autoScroll) {
this._autoScroll.dispose();
}
delete this._scrollableParent;
delete this._scrollableSurface;
};
MarqueeSelectionBase.prototype.render = function () {
var _a = this.props, rootProps = _a.rootProps, children = _a.children,
theme = _a.theme, className = _a.className, styles = _a.styles;
var dragRect = this.state.dragRect;
theme: theme,
});
return (React.createElement("div", tslib_1.__assign({}, rootProps,
{ className: classNames.root, ref: this._root }),
children,
dragRect && React.createElement("div", { className: classNames.dragMask
}),
dragRect && (React.createElement("div", { className: classNames.box,
style: dragRect },
React.createElement("div", { className: classNames.boxFill })))));
};
/** Determine if the mouse event occured on a scrollbar of the target element.
*/
MarqueeSelectionBase.prototype._isMouseEventOnScrollbar = function (ev) {
var targetElement = ev.target;
var targetScrollbarWidth = targetElement.offsetWidth -
targetElement.clientWidth;
var targetScrollbarHeight = targetElement.offsetHeight -
targetElement.clientHeight;
if (targetScrollbarWidth || targetScrollbarHeight) {
var targetRect = targetElement.getBoundingClientRect();
// Check vertical scroll
if (Utilities_1.getRTL(this.props.theme)) {
if (ev.clientX < targetRect.left + targetScrollbarWidth) {
return true;
}
}
else {
if (ev.clientX > targetRect.left + targetElement.clientWidth) {
return true;
}
}
// Check horizontal scroll
if (ev.clientY > targetRect.top + targetElement.clientHeight) {
return true;
}
}
return false;
};
MarqueeSelectionBase.prototype._getRootRect = function () {
return {
left: this._rootRect.left +
(this._scrollableSurface ? this._scrollLeft -
this._scrollableSurface.scrollLeft : this._scrollLeft),
top: this._rootRect.top +
(this._scrollableSurface ? this._scrollTop -
this._scrollableSurface.scrollTop : this._scrollTop),
width: this._rootRect.width,
height: this._rootRect.height,
};
};
MarqueeSelectionBase.prototype._onAsyncMouseMove = function (ev) {
var _this = this;
this._async.requestAnimationFrame(function () {
});
};
MarqueeSelectionBase.prototype._onMouseMove = function (ev) {
if (!this._autoScroll) {
return;
}
if (ev.clientX !== undefined) {
this._lastMouseEvent = ev;
}
var rootRect = this._getRootRect();
var currentPoint = { left: ev.clientX - rootRect.left, top: ev.clientY -
rootRect.top };
if (!this._dragOrigin) {
this._dragOrigin = currentPoint;
}
if (ev.buttons !== undefined && ev.buttons === 0) {
this._onMouseUp(ev);
}
else {
if (this.state.dragRect ||
Utilities_1.getDistanceBetweenPoints(this._dragOrigin, currentPoint) >
MIN_DRAG_DISTANCE) {
if (!this.state.dragRect) {
if (!ev.shiftKey) {
selection.setAllSelected(false);
}
this._preservedIndicies = selection &&
selection.getSelectedIndices && selection.getSelectedIndices();
}
// We need to constrain the current point to the rootRect
boundaries.
var constrainedPoint = this.props.isDraggingConstrainedToRoot
? {
left: Math.max(0, Math.min(rootRect.width,
this._lastMouseEvent.clientX - rootRect.left)),
top: Math.max(0, Math.min(rootRect.height,
this._lastMouseEvent.clientY - rootRect.top)),
}
: {
left: this._lastMouseEvent.clientX - rootRect.left,
top: this._lastMouseEvent.clientY - rootRect.top,
};
var dragRect = {
left: Math.min(this._dragOrigin.left || 0,
constrainedPoint.left),
top: Math.min(this._dragOrigin.top || 0, constrainedPoint.top),
width: Math.abs(constrainedPoint.left - (this._dragOrigin.left
|| 0)),
height: Math.abs(constrainedPoint.top - (this._dragOrigin.top
|| 0)),
};
this._evaluateSelection(dragRect, rootRect);
this.setState({ dragRect: dragRect });
}
}
return false;
};
MarqueeSelectionBase.prototype._onMouseUp = function (ev) {
this._events.off(window);
this._events.off(this._scrollableParent, 'scroll');
if (this._autoScroll) {
this._autoScroll.dispose();
}
this._autoScroll = this._dragOrigin = this._lastMouseEvent = undefined;
this._selectedIndicies = this._itemRectCache = undefined;
if (this.state.dragRect) {
this.setState({
dragRect: undefined,
});
}
};
MarqueeSelectionBase.prototype._isPointInRectangle = function (rectangle,
point) {
return (!!point.top &&
rectangle.top < point.top &&
rectangle.bottom > point.top &&
!!point.left &&
rectangle.left < point.left &&
rectangle.right > point.left);
};
/**
* We do not want to start the marquee if we're trying to marquee
* from within an existing marquee selection.
*/
MarqueeSelectionBase.prototype._isDragStartInSelection = function (ev) {
if (!this._root.current || (selection && selection.getSelectedCount() ===
0)) {
return false;
}
var allElements = this._root.current.querySelectorAll('[data-selection-
index]');
for (var i = 0; i < allElements.length; i++) {
var element = allElements[i];
var index = Number(element.getAttribute('data-selection-index'));
if (selection.isIndexSelected(index)) {
var itemRect = element.getBoundingClientRect();
if (this._isPointInRectangle(itemRect, { left: ev.clientX, top:
ev.clientY })) {
return true;
}
}
}
return false;
};
MarqueeSelectionBase.prototype._isInSelectionToggle = function (ev) {
var element = ev.target;
while (element && element !== this._root.current) {
if (element.getAttribute('data-selection-toggle') === 'true') {
return true;
}
element = element.parentElement;
}
return false;
};
MarqueeSelectionBase.prototype._evaluateSelection = function (dragRect,
rootRect) {
// Break early if we don't need to evaluate.
if (!dragRect || !this._root.current) {
return;
}
var allElements = this._root.current.querySelectorAll('[data-selection-
index]');
if (!this._itemRectCache) {
this._itemRectCache = {};
}
for (var i = 0; i < allElements.length; i++) {
var element = allElements[i];
var index = element.getAttribute('data-selection-index');
// Pull the memoized rectangle for the item, or the get the rect and
memoize.
var itemRect = this._itemRectCache[index];
if (!itemRect) {
itemRect = element.getBoundingClientRect();
// Normalize the item rect to the dragRect coordinates.
itemRect = {
left: itemRect.left - rootRect.left,
top: itemRect.top - rootRect.top,
width: itemRect.width,
height: itemRect.height,
right: itemRect.left - rootRect.left + itemRect.width,
bottom: itemRect.top - rootRect.top + itemRect.height,
};
if (itemRect.width > 0 && itemRect.height > 0) {
this._itemRectCache[index] = itemRect;
}
}
if (itemRect.top < dragRect.top + dragRect.height &&
itemRect.bottom > dragRect.top &&
itemRect.left < dragRect.left + dragRect.width &&
itemRect.right > dragRect.left) {
this._selectedIndicies[index] = true;
}
else {
delete this._selectedIndicies[index];
}
}
// set previousSelectedIndices to be all of the selected indices from last
time
var previousSelectedIndices = this._allSelectedIndices || {};
this._allSelectedIndices = {};
// set all indices that are supposed to be selected in _allSelectedIndices
for (var index in this._selectedIndicies) {
if (this._selectedIndicies.hasOwnProperty(index)) {
this._allSelectedIndices[index] = true;
}
}
if (this._preservedIndicies) {
for (var _i = 0, _a = this._preservedIndicies; _i < _a.length; _i++) {
var index = _a[_i];
this._allSelectedIndices[index] = true;
}
}
// check if needs to update selection, only when current
_allSelectedIndices
// is different than previousSelectedIndices
var needToUpdate = false;
for (var index in this._allSelectedIndices) {
if (this._allSelectedIndices[index] !== previousSelectedIndices[index])
{
needToUpdate = true;
break;
}
}
if (!needToUpdate) {
for (var index in previousSelectedIndices) {
if (this._allSelectedIndices[index] !==
previousSelectedIndices[index]) {
needToUpdate = true;
break;
}
}
}
// only update selection when needed
if (needToUpdate) {
// Stop change events, clear selection to re-populate.
selection.setChangeEvents(false);
for (var _b = 0, _c = Object.keys(this._allSelectedIndices); _b <
_c.length; _b++) {
var index = _c[_b];
selection.setIndexSelected(Number(index), true, false);
}
selection.setChangeEvents(true);
}
};
MarqueeSelectionBase.defaultProps = {
rootTagName: 'div',
rootProps: {},
isEnabled: true,
};
return MarqueeSelectionBase;
exports.MarqueeSelectionBase = MarqueeSelectionBase;
//# sourceMappingURL=MarqueeSelection.base.js.map
/***/ }),
/***/ 94161:
"use strict";

exports.MarqueeSelection = void 0;
var MarqueeSelection_base_1 = __webpack_require__(42337);
var MarqueeSelection_styles_1 = __webpack_require__(97604);
exports.MarqueeSelection =
// TODO: MarqueeSelectionBase defaultProps are not lining up with
IMarqueeSelectionProps, so we have to be explicit
// with styled here. defaultProps.rootTagName doesn't appear to be used anywhere
and defaultProps.rootProps is not
// in IMarqueeSelectionProps.
Utilities_1.styled(MarqueeSelection_base_1.MarqueeSelectionBase,
MarqueeSelection_styles_1.getStyles, undefined, {
scope: 'MarqueeSelection',
});
//# sourceMappingURL=MarqueeSelection.js.map
/***/ }),
/***/ 97604:
"use strict";

var _a, _b, _c;
return {
root: [
className,
{
cursor: 'default',
},
],
dragMask: [
{
background: 'rgba(255, 0, 0, 0)',
left: 0,
top: 0,
right: 0,
bottom: 0,
background: 'none',
},
_a),
},
],
box: [
{
border: "1px solid " + palette.themePrimary,
zIndex: 10,
},
_b),
},
],
boxFill: [
{
opacity: 0.1,
left: 0,
top: 0,
right: 0,
bottom: 0,
background: 'none',
},
_c),
},
],
};
};
//# sourceMappingURL=MarqueeSelection.styles.js.map
/***/ }),
/***/ 2845:
"use strict";

//# sourceMappingURL=MarqueeSelection.types.js.map
/***/ }),
/***/ 85659:
"use strict";
var _a;
exports.MessageBarBase = void 0;
var MessageBar_types_1 = __webpack_require__(30653);
var ICON_MAP = (_a = {},
_a[MessageBar_types_1.MessageBarType.info] = 'Info',
_a[MessageBar_types_1.MessageBarType.warning] = 'Info',
_a[MessageBar_types_1.MessageBarType.error] = 'ErrorBadge',
_a[MessageBar_types_1.MessageBarType.blocked] = 'Blocked2',
_a[MessageBar_types_1.MessageBarType.severeWarning] = 'Warning',
_a[MessageBar_types_1.MessageBarType.success] = 'Completed',
_a);
var COMPONENT_NAME = 'MessageBar';
var getAnnouncementPriority = function (messageBarType) {
switch (messageBarType) {
case MessageBar_types_1.MessageBarType.blocked:
case MessageBar_types_1.MessageBarType.error:
case MessageBar_types_1.MessageBarType.severeWarning:
return 'assertive';
}
return 'polite';
};
var getRole = function (messageBarType) {
switch (messageBarType) {
case MessageBar_types_1.MessageBarType.blocked:
case MessageBar_types_1.MessageBarType.error:
case MessageBar_types_1.MessageBarType.severeWarning:
return 'alert';
}
return 'status';
};
exports.MessageBarBase = React.forwardRef(function (props, ref) {
var _a = react_hooks_1.useBoolean(false), expandSingleLine = _a[0],
toggleExpandSingleLine = _a[1].toggle;
var labelId = react_hooks_1.useId('MessageBar');
var actions = props.actions, className = props.className, children =
props.children,
overflowButtonAriaLabel = props.overflowButtonAriaLabel, dismissIconProps =
props.dismissIconProps, styles = props.styles, theme = props.theme, _b =
props.messageBarType, messageBarType = _b === void 0 ?
MessageBar_types_1.MessageBarType.info : _b, _c = props.onDismiss, onDismiss = _c
=== void 0 ? undefined : _c, _d = props.isMultiline, isMultiline = _d === void 0 ?
true : _d, truncated = props.truncated, dismissButtonAriaLabel =
props.dismissButtonAriaLabel, messageBarIconProps = props.messageBarIconProps, role
= props.role, _e = props.delayedRender, delayedRender = _e === void 0 ? true : _e,
expandButtonProps = props.expandButtonProps;
'className',
'role',
]);
theme: theme,
messageBarType: messageBarType || MessageBar_types_1.MessageBarType.info,
onDismiss: onDismiss !== undefined,
actions: actions !== undefined,
truncated: truncated,
isMultiline: isMultiline,
expandSingleLine: expandSingleLine,
});
var expandIconProps = { iconName: expandSingleLine ? 'DoubleChevronUp' :
'DoubleChevronDown' };
var regionProps = actions || onDismiss ? { 'aria-describedby': labelId, role:
'region' } : {};
var actionsDiv = actions ? React.createElement("div", { className:
classNames.actions }, actions) : null;
var dismissButton = onDismiss ? (React.createElement(Button_1.IconButton,
{ disabled: false, className: classNames.dismissal, onClick: onDismiss, iconProps:
dismissIconProps ? dismissIconProps : { iconName: 'Clear' }, title:
dismissButtonAriaLabel, ariaLabel: dismissButtonAriaLabel })) : null;
return (React.createElement("div", tslib_1.__assign({ ref: ref, className:
classNames.root }, regionProps),
React.createElement("div", { className: classNames.content },
React.createElement("div", { className: classNames.iconContainer,
"aria-hidden": true }, messageBarIconProps ? (React.createElement(Icon_1.Icon,
tslib_1.__assign({}, messageBarIconProps, { className:
Utilities_1.css(classNames.icon, messageBarIconProps.className) }))) :
(React.createElement(Icon_1.Icon, { iconName: ICON_MAP[messageBarType], className:
classNames.icon }))),
React.createElement("div", { className: classNames.text, id: labelId,
role: role || getRole(messageBarType), "aria-live":
getAnnouncementPriority(messageBarType) },
React.createElement("span", tslib_1.__assign({ className:
classNames.innerText }, nativeProps), delayedRender ?
(React.createElement(Utilities_1.DelayedRender, null,
React.createElement("span", null, children))) : (
// this span is probably not necessary, but preserving it for now
in case anyone
// has styling that expects it to be present
React.createElement("span", null, children)))),
/* singleline expand/collapse button */ !isMultiline && !actionsDiv &&
truncated && (React.createElement("div", { className:
classNames.expandSingleLine },
tslib_1.__assign({ disabled: false, className: classNames.expand, onClick:
toggleExpandSingleLine, iconProps: expandIconProps, ariaLabel:
overflowButtonAriaLabel, "aria-expanded": expandSingleLine },
expandButtonProps)))),
!isMultiline && actionsDiv,
/* singleline dismiss */ !isMultiline && dismissButton &&
(React.createElement("div", { className: classNames.dismissSingleLine },
dismissButton)),
isMultiline && dismissButton),
isMultiline && actionsDiv));
});
exports.MessageBarBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=MessageBar.base.js.map
/***/ }),
/***/ 75254:
"use strict";

exports.MessageBar = void 0;
var MessageBar_base_1 = __webpack_require__(85659);
var MessageBar_styles_1 = __webpack_require__(94437);
exports.MessageBar = Utilities_1.styled(MessageBar_base_1.MessageBarBase,
MessageBar_styles_1.getStyles, undefined, {
scope: 'MessageBar',
});
//# sourceMappingURL=MessageBar.js.map
/***/ }),
/***/ 94437:
"use strict";
var _a, _b, _c;

var MessageBar_types_1 = __webpack_require__(30653);
root: 'ms-MessageBar',
error: 'ms-MessageBar--error',
blocked: 'ms-MessageBar--blocked',
severeWarning: 'ms-MessageBar--severeWarning',
success: 'ms-MessageBar--success',
warning: 'ms-MessageBar--warning',
multiline: 'ms-MessageBar-multiline',
singleline: 'ms-MessageBar-singleline',
dismissalSingleLine: 'ms-MessageBar-dismissalSingleLine',
expandingSingleLine: 'ms-MessageBar-expandingSingleLine',
content: 'ms-MessageBar-content',
iconContainer: 'ms-MessageBar-icon',
text: 'ms-MessageBar-text',
innerText: 'ms-MessageBar-innerText',
dismissSingleLine: 'ms-MessageBar-dismissSingleLine',
expandSingleLine: 'ms-MessageBar-expandSingleLine',
dismissal: 'ms-MessageBar-dismissal',
expand: 'ms-MessageBar-expand',
actions: 'ms-MessageBar-actions',
actionsSingleline: 'ms-MessageBar-actionsSingleLine',
};
var backgroundColor = (_a = {},
_a[MessageBar_types_1.MessageBarType.error] = 'errorBackground',
_a[MessageBar_types_1.MessageBarType.blocked] = 'errorBackground',
_a[MessageBar_types_1.MessageBarType.success] = 'successBackground',
_a[MessageBar_types_1.MessageBarType.warning] = 'warningBackground',
_a[MessageBar_types_1.MessageBarType.severeWarning] =
'severeWarningBackground',
_a[MessageBar_types_1.MessageBarType.info] = 'infoBackground',
_a);
var highContrastBackgroundColor = (_b = {},
_b[MessageBar_types_1.MessageBarType.error] = 'rgba(255, 0, 0, 0.3)',
_b[MessageBar_types_1.MessageBarType.blocked] = 'rgba(255, 0, 0, 0.3)',
_b[MessageBar_types_1.MessageBarType.success] = 'rgba(48, 241, 73, 0.3)',
_b[MessageBar_types_1.MessageBarType.warning] = 'rgba(255, 254, 57, 0.3)',
_b[MessageBar_types_1.MessageBarType.severeWarning] = 'rgba(255, 0, 0, 0.3)',
_b[MessageBar_types_1.MessageBarType.info] = 'Window',
_b);
var iconColor = (_c = {},
_c[MessageBar_types_1.MessageBarType.error] = 'errorIcon',
_c[MessageBar_types_1.MessageBarType.blocked] = 'errorIcon',
_c[MessageBar_types_1.MessageBarType.success] = 'successIcon',
_c[MessageBar_types_1.MessageBarType.warning] = 'warningIcon',
_c[MessageBar_types_1.MessageBarType.severeWarning] = 'severeWarningIcon',
_c[MessageBar_types_1.MessageBarType.info] = 'infoIcon',
_c);
var _a, _b, _c, _d, _e;
var theme = props.theme, className = props.className, onDismiss =
props.onDismiss, truncated = props.truncated, isMultiline = props.isMultiline,
expandSingleLine = props.expandSingleLine, _f = props.messageBarType,
messageBarType = _f === void 0 ? MessageBar_types_1.MessageBarType.info : _f;
var SmallScreenSelector = Styling_1.getScreenSelector(0,
Styling_1.ScreenWidthMaxSmall);
var dismissalAndExpandIconStyle = {
fontSize: Styling_1.IconFontSizes.xSmall,
height: 10,
lineHeight: '10px',
color: semanticColors.messageText,
tslib_1.__assign(tslib_1.__assign({}, Styling_1.getHighContrastNoAdjustStyle()),
{ color: 'WindowText' }),
_a),
};
var dismissalAndExpandStyle = [
inset: 1,
},
}),
{
flexShrink: 0,
width: 32,
height: 32,
selectors: {
'& .ms-Button-icon': dismissalAndExpandIconStyle,
':hover': {
},
':active': {
},
},
},
];
return {
root: [
classNames.root,
fonts.medium,
messageBarType === MessageBar_types_1.MessageBarType.error &&
classNames.error,
messageBarType === MessageBar_types_1.MessageBarType.blocked &&
classNames.blocked,
messageBarType === MessageBar_types_1.MessageBarType.severeWarning &&
classNames.severeWarning,
messageBarType === MessageBar_types_1.MessageBarType.success &&
classNames.success,
messageBarType === MessageBar_types_1.MessageBarType.warning &&
classNames.warning,
isMultiline ? classNames.multiline : classNames.singleline,
!isMultiline && onDismiss && classNames.dismissalSingleLine,
!isMultiline && truncated && classNames.expandingSingleLine,
{
background: semanticColors[backgroundColor[messageBarType]],
color: semanticColors.messageText,
minHeight: 32,
width: '100%',
display: 'flex',
selectors: (_b = {
'.ms-Link': {
color: semanticColors.messageLink,
selectors: {
':hover': {
color: semanticColors.messageLinkHovered,
},
},
}
},
{ background: highContrastBackgroundColor[messageBarType], border: '1px solid
WindowText', color: 'WindowText' }),
_b),
},
isMultiline && {
},
className,
],
content: [
classNames.content,
{
display: 'flex',
width: '100%',
},
],
iconContainer: [
{
minWidth: 16,
minHeight: 16,
display: 'flex',
flexShrink: 0,
margin: '8px 0 8px 12px',
},
],
icon: {
color: semanticColors[iconColor[messageBarType]],
{ color: 'WindowText' }),
_c),
},
text: [
classNames.text,
tslib_1.__assign(tslib_1.__assign({ minWidth: 0, display: 'flex',
flexGrow: 1, margin: 8 }, fonts.small), { selectors: (_d = {},
_d[Styling_1.HighContrastSelector] = tslib_1.__assign({},
_d) }),
!onDismiss && {
marginRight: 12,
},
],
innerText: [
classNames.innerText,
{
lineHeight: 16,
selectors: {
'& span a:last-child': {
paddingLeft: 4,
},
},
},
truncated && {
},
!isMultiline && {
// In high contrast this causes the top and bottom of links' focus
outline to be clipped
// (not sure of a good way around that while still maintaining text
clipping)
overflow: 'hidden',
},
!isMultiline &&
!truncated && {
_e[SmallScreenSelector] = {
},
_e),
},
expandSingleLine && {
},
],
dismissSingleLine: classNames.dismissSingleLine,
expandSingleLine: classNames.expandSingleLine,
dismissal: [classNames.dismissal, dismissalAndExpandStyle],
expand: [classNames.expand, dismissalAndExpandStyle],
actions: [
isMultiline ? classNames.actions : classNames.actionsSingleline,
{
display: 'flex',
flexGrow: 0,
flexShrink: 0,
flexBasis: 'auto',
margin: '0 12px 0 8px',
selectors: {
'& button:nth-child(n+2)': {
marginLeft: 8,
},
},
},
isMultiline && {
marginBottom: 8,
},
onDismiss &&
!isMultiline && {
marginRight: 0,
},
],
};
};
//# sourceMappingURL=MessageBar.styles.js.map
/***/ }),
/***/ 30653:
"use strict";

exports.MessageBarType = void 0;
/**
* {@docCategory MessageBar}
*/
var MessageBarType;
(function (MessageBarType) {
/** Info styled MessageBar */
MessageBarType[MessageBarType["info"] = 0] = "info";
/** Error styled MessageBar */
MessageBarType[MessageBarType["error"] = 1] = "error";
/** Blocked styled MessageBar */
MessageBarType[MessageBarType["blocked"] = 2] = "blocked";
/** SevereWarning styled MessageBar */
MessageBarType[MessageBarType["severeWarning"] = 3] = "severeWarning";
/** Success styled MessageBar */
MessageBarType[MessageBarType["success"] = 4] = "success";
/** Warning styled MessageBar */
MessageBarType[MessageBarType["warning"] = 5] = "warning";
})(MessageBarType = exports.MessageBarType || (exports.MessageBarType = {}));
//# sourceMappingURL=MessageBar.types.js.map
/***/ }),
/***/ 4573:
"use strict";

/***/ }),
/***/ 19875:
"use strict";

exports.ModalBase = void 0;
var Modal_styles_1 = __webpack_require__(78650);
var Overlay_1 = __webpack_require__(18494);
var ZERO = { x: 0, y: 0 };
isOpen: false,
isDarkOverlay: true,
className: '',
containerClassName: '',
enableAriaHiddenSiblings: true,
};
var getMoveDelta = function (ev) {
var delta = 10;
if (ev.shiftKey) {
if (!ev.ctrlKey) {
delta = 50;
}
}
else if (ev.ctrlKey) {
delta = 1;
}
return delta;
};
var useComponentRef = function (props, focusTrapZone) {
if (focusTrapZone.current) {
focusTrapZone.current.focus();
}
},
}); }, [focusTrapZone]);
};
exports.ModalBase = React.forwardRef(function (propsWithoutDefaults, ref) {
var _a, _b, _c, _d, _e;
var allowTouchBodyScroll = props.allowTouchBodyScroll, className =
props.className, children = props.children, containerClassName =
props.containerClassName, scrollableContentClassName =
props.scrollableContentClassName, elementToFocusOnDismiss =
props.elementToFocusOnDismiss, firstFocusableSelector =
props.firstFocusableSelector, focusTrapZoneProps = props.focusTrapZoneProps,
forceFocusInsideTrap = props.forceFocusInsideTrap,
_f = props.disableRestoreFocus,
disableRestoreFocus = _f === void 0 ? props.ignoreExternalFocusing : _f,
isBlocking = props.isBlocking, isAlert = props.isAlert, isClickableOutsideFocusTrap
= props.isClickableOutsideFocusTrap, isDarkOverlay = props.isDarkOverlay, onDismiss
= props.onDismiss, layerProps = props.layerProps, overlay = props.overlay, isOpen =
props.isOpen, titleAriaId = props.titleAriaId, styles = props.styles,
subtitleAriaId = props.subtitleAriaId, theme = props.theme, topOffsetFixed =
props.topOffsetFixed, responsiveMode = props.responsiveMode,
onLayerDidMount = props.onLayerDidMount, isModeless = props.isModeless,
dragOptions = props.dragOptions, onDismissed = props.onDismissed,
enableAriaHiddenSiblings = props.enableAriaHiddenSiblings;
var focusTrapZone = React.useRef(null);
var focusTrapZoneRef = react_hooks_1.useMergedRefs(focusTrapZone,
focusTrapZoneProps === null || focusTrapZoneProps === void 0 ? void 0 :
focusTrapZoneProps.componentRef);
var focusTrapZoneElm = React.useRef(null);
var mergedRef = react_hooks_1.useMergedRefs(rootRef, ref);
var modalResponsiveMode = ResponsiveMode_1.useResponsiveMode(mergedRef);
var focusTrapZoneId = react_hooks_1.useId('ModalFocusTrapZone',
focusTrapZoneProps.id);
var win = react_window_provider_1.useWindow();
var _g = react_hooks_1.useSetTimeout(), setTimeout = _g.setTimeout,
clearTimeout = _g.clearTimeout;
var _h = React.useState(isOpen), isModalOpen = _h[0], setIsModalOpen = _h[1];
var _j = React.useState(isOpen), isVisible = _j[0], setIsVisible = _j[1];
var _k = React.useState(ZERO), coordinates = _k[0], setCoordinates = _k[1];
var _l = React.useState(), modalRectangleTop = _l[0], setModalRectangleTop =
_l[1];
var _m = react_hooks_1.useBoolean(false), isModalMenuOpen = _m[0], _o = _m[1],
toggleModalMenuOpen = _o.toggle, setModalMenuClose = _o.setFalse;
var internalState = react_hooks_1.useConst(function () { return ({
onModalCloseTimer: 0,
allowTouchBodyScroll: allowTouchBodyScroll,
scrollableContent: null,
lastSetCoordinates: ZERO,
events: new Utilities_1.EventGroup({}),
}); });
var keepInBounds = (dragOptions || {}).keepInBounds;
var isAlertRole = isAlert !== null && isAlert !== void 0 ? isAlert :
(isBlocking && !isModeless);
var layerClassName = layerProps === undefined ? '' : layerProps.className;
theme: theme,
containerClassName: containerClassName,
scrollableContentClassName: scrollableContentClassName,
isOpen: isOpen,
isVisible: isVisible,
hasBeenOpened: internalState.hasBeenOpened,
modalRectangleTop: modalRectangleTop,
topOffsetFixed: topOffsetFixed,
isModeless: isModeless,
layerClassName: layerClassName,
windowInnerHeight: win === null || win === void 0 ? void 0 :
win.innerHeight,
isDefaultDragHandle: dragOptions && !dragOptions.dragHandleSelector,
});
var mergedLayerProps =
tslib_1.__assign(tslib_1.__assign({ eventBubblingEnabled: false }, layerProps),
{ onLayerDidMount: layerProps && layerProps.onLayerDidMount ?
layerProps.onLayerDidMount : onLayerDidMount, insertFirst: isModeless, className:
classNames.layer });
// Allow the user to scroll within the modal but not on the body
var allowScrollOnModal = React.useCallback(function (elt) {
if (elt) {
if (internalState.allowTouchBodyScroll) {
Utilities_1.allowOverscrollOnElement(elt, internalState.events);
}
else {
Utilities_1.allowScrollOnElement(elt, internalState.events);
}
}
else {
internalState.events.off(internalState.scrollableContent);
}
internalState.scrollableContent = elt;
}, [internalState]);
var registerInitialModalPosition = function () {
var dialogMain = focusTrapZoneElm.current;
var modalRectangle = dialogMain === null || dialogMain === void 0 ? void
0 : dialogMain.getBoundingClientRect();
if (modalRectangle) {
if (topOffsetFixed) {
setModalRectangleTop(modalRectangle.top);
}
if (keepInBounds) {
// x/y are unavailable in IE, so use the equivalent left/top
internalState.minPosition = { x: -modalRectangle.left, y: -
modalRectangle.top };
internalState.maxPosition = { x: modalRectangle.left, y:
modalRectangle.top };
}
}
};
/**
* Clamps an axis to a specified min and max position.
*
* @param axis A string that represents the axis (x/y).
* @param position The position on the axis.
*/
var getClampedAxis = React.useCallback(function (axis, position) {
var minPosition = internalState.minPosition, maxPosition =
internalState.maxPosition;
if (keepInBounds && minPosition && maxPosition) {
position = Math.max(minPosition[axis], position);
position = Math.min(maxPosition[axis], position);
}
return position;
}, [keepInBounds, internalState]);
var handleModalClose = function () {
var _a;
internalState.lastSetCoordinates = ZERO;
setModalMenuClose();
internalState.isInKeyboardMoveMode = false;
setIsModalOpen(false);
setCoordinates(ZERO);
(_a = internalState.disposeOnKeyUp) === null || _a === void 0 ? void 0 :
_a.call(internalState);
onDismissed === null || onDismissed === void 0 ? void 0 : onDismissed();
};
var handleDragStart = React.useCallback(function () {
}, [internalState, setModalMenuClose]);
var handleDrag = React.useCallback(function (ev, dragData) {
setCoordinates(function (prevValue) { return ({
x: getClampedAxis('x', prevValue.x + dragData.delta.x),
y: getClampedAxis('y', prevValue.y + dragData.delta.y),
}); });
}, [getClampedAxis]);
var handleDragStop = React.useCallback(function () {
if (focusTrapZone.current) {
focusTrapZone.current.focus();
}
}, []);
var handleEnterKeyboardMoveMode = function () {
// We need a global handleKeyDown event when we are in the move mode so
that we can
// handle the key presses and the components inside the modal do not get
the events
var handleKeyDown = function (ev) {
if (ev.altKey && ev.ctrlKey && ev.keyCode ===
// CTRL + ALT + SPACE is handled during keyUp
return;
}
var newLocal = ev.altKey || ev.keyCode === Utilities_1.KeyCodes.escape;
if (isModalMenuOpen && newLocal) {
}
if (internalState.isInKeyboardMoveMode && (ev.keyCode ===
Utilities_1.KeyCodes.escape || ev.keyCode === Utilities_1.KeyCodes.enter)) {
}
if (internalState.isInKeyboardMoveMode) {
var handledEvent = true;
var delta_1 = getMoveDelta(ev);
switch (ev.keyCode) {
/* eslint-disable no-fallthrough */
setCoordinates(internalState.lastSetCoordinates);
case Utilities_1.KeyCodes.enter: {
// TODO: determine if fallthrough was intentional
/* eslint-enable no-fallthrough */
// setIsInKeyboardMoveMode(false);
break;
}
case Utilities_1.KeyCodes.up: {
setCoordinates(function (prevValue) { return ({ x:
prevValue.x, y: getClampedAxis('y', prevValue.y - delta_1) }); });
break;
}
case Utilities_1.KeyCodes.down: {
prevValue.x, y: getClampedAxis('y', prevValue.y + delta_1) }); });
break;
}
getClampedAxis('x', prevValue.x - delta_1), y: prevValue.y }); });
break;
}
getClampedAxis('x', prevValue.x + delta_1), y: prevValue.y }); });
break;
}
default: {
handledEvent = false;
}
}
if (handledEvent) {
}
}
};
internalState.lastSetCoordinates = coordinates;
internalState.isInKeyboardMoveMode = true;
internalState.events.on(win, 'keydown', handleKeyDown, true /* useCapture
*/);
internalState.disposeOnKeyDown = function () {
internalState.events.off(win, 'keydown', handleKeyDown, true /*
useCapture */);
internalState.disposeOnKeyDown = undefined;
};
};
var handleExitKeyboardMoveMode = function (ev) {
var _a, _b;
(_a = focusTrapZoneProps === null || focusTrapZoneProps === void 0 ? void 0
: focusTrapZoneProps.onBlur) === null || _a === void 0 ? void 0 :
_a.call(focusTrapZoneProps, ev);
(_b = internalState.disposeOnKeyDown) === null || _b === void 0 ? void 0 :
_b.call(internalState);
};
var registerForKeyUp = function () {
var handleKeyUp = function (ev) {
// Needs to handle the CTRL + ALT + SPACE key during keyup due to
FireFox bug:
// https://bugzilla.mozilla.org/show_bug.cgi?id=1220143
if (ev.altKey && ev.ctrlKey && ev.keyCode ===
if (Utilities_1.elementContains(internalState.scrollableContent,
ev.target)) {
toggleModalMenuOpen();
}
}
};
if (!internalState.disposeOnKeyUp) {
internalState.events.on(win, 'keyup', handleKeyUp, true /* useCapture
*/);
internalState.disposeOnKeyUp = function () {
internalState.events.off(win, 'keyup', handleKeyUp, true /*
useCapture */);
internalState.disposeOnKeyUp = undefined;
};
}
};
clearTimeout(internalState.onModalCloseTimer);
// Opening the dialog
if (isOpen) {
// This must be done after the modal content has rendered
requestAnimationFrame(function () { return
setTimeout(registerInitialModalPosition, 0); });
setIsModalOpen(true);
// Add a keyUp handler for all key up events once the dialog is open.
if (dragOptions) {
registerForKeyUp();
}
internalState.hasBeenOpened = true;
setIsVisible(true);
}
// Closing the dialog
if (!isOpen && isModalOpen) {
internalState.onModalCloseTimer = setTimeout(handleModalClose,
parseFloat(Modal_styles_1.animationDuration) * 1000);
setIsVisible(false);
}
if isModalOpen or isOpen mutates.
}, [isModalOpen, isOpen]);
internalState.events.dispose();
});
useComponentRef(props, focusTrapZone);
var modalContent = (React.createElement(FocusTrapZone_1.FocusTrapZone,
tslib_1.__assign({}, focusTrapZoneProps, { id: focusTrapZoneId, ref:
focusTrapZoneElm, componentRef: focusTrapZoneRef, className:
Utilities_1.css(classNames.main, focusTrapZoneProps === null || focusTrapZoneProps
=== void 0 ? void 0 : focusTrapZoneProps.className), elementToFocusOnDismiss: (_a =
focusTrapZoneProps.elementToFocusOnDismiss) !== null && _a !== void 0 ? _a :
elementToFocusOnDismiss, isClickableOutsideFocusTrap: (_b = focusTrapZoneProps ===
null || focusTrapZoneProps === void 0 ? void 0 :
focusTrapZoneProps.isClickableOutsideFocusTrap) !== null && _b !== void 0 ? _b :
(isModeless || isClickableOutsideFocusTrap || !isBlocking), disableRestoreFocus:
(_c = focusTrapZoneProps === null || focusTrapZoneProps === void 0 ? void 0 :
focusTrapZoneProps.disableRestoreFocus) !== null && _c !== void 0 ? _c :
disableRestoreFocus, forceFocusInsideTrap: ((_d = focusTrapZoneProps === null ||
focusTrapZoneProps === void 0 ? void 0 : focusTrapZoneProps.forceFocusInsideTrap) !
== null && _d !== void 0 ? _d : forceFocusInsideTrap) && !isModeless,
firstFocusableSelector: (focusTrapZoneProps === null || focusTrapZoneProps
=== void 0 ? void 0 : focusTrapZoneProps.firstFocusableSelector) ||
firstFocusableSelector, focusPreviouslyFocusedInnerElement: (_e =
focusTrapZoneProps.focusPreviouslyFocusedInnerElement) !== null && _e !== void 0 ?
_e : true, onBlur: internalState.isInKeyboardMoveMode ?
handleExitKeyboardMoveMode : undefined }),
dragOptions && internalState.isInKeyboardMoveMode &&
(React.createElement("div", { className: classNames.keyboardMoveIconContainer },
dragOptions.keyboardMoveIconProps ? (React.createElement(Icon_1.Icon,
tslib_1.__assign({}, dragOptions.keyboardMoveIconProps))) :
(React.createElement(Icon_1.Icon, { iconName: "move", className:
classNames.keyboardMoveIcon })))),
React.createElement("div", { ref: allowScrollOnModal, className:
classNames.scrollableContent, "data-is-scrollable": true },
dragOptions && isModalMenuOpen &&
(React.createElement(dragOptions.menu, { items: [
{ key: 'move', text: dragOptions.moveMenuItemText, onClick:
handleEnterKeyboardMoveMode },
{ key: 'close', text: dragOptions.closeMenuItemText, onClick:
handleModalClose },
], onDismiss: setModalMenuClose, alignTargetEdge: true,
coverTarget: true, directionalHint: DirectionalHint_1.DirectionalHint.topLeftEdge,
directionalHintFixed: true, shouldFocusOnMount: true, target:
internalState.scrollableContent })),
children)));
return ((isModalOpen && modalResponsiveMode >= (responsiveMode ||
ResponsiveMode_1.ResponsiveMode.small) && (React.createElement(Layer_1.Layer,
tslib_1.__assign({ ref: mergedRef }, mergedLayerProps),
React.createElement(Popup_1.Popup, { role: isAlertRole ? 'alertdialog' :
'dialog', ariaLabelledBy: titleAriaId, ariaDescribedBy: subtitleAriaId, onDismiss:
onDismiss, shouldRestoreFocus: !disableRestoreFocus,
// Modeless modals shouldn't hide siblings.
// Popup will automatically handle this based on the aria-modal
setting.
enableAriaHiddenSiblings: enableAriaHiddenSiblings, "aria-modal": !
isModeless },
React.createElement("div", { className: classNames.root, role: !
isModeless ? 'document' : undefined },
!isModeless && (React.createElement(Overlay_1.Overlay,
tslib_1.__assign({ "aria-hidden": true, isDarkThemed: isDarkOverlay, onClick:
isBlocking ? undefined : onDismiss, allowTouchBodyScroll: allowTouchBodyScroll },
overlay))),
dragOptions ? (React.createElement(index_1.DraggableZone,
{ handleSelector: dragOptions.dragHandleSelector || "#" + focusTrapZoneId,
preventDragSelector: "button", onStart: handleDragStart, onDragChange: handleDrag,
onStop: handleDragStop, position: coordinates }, modalContent)) :
(modalContent)))))) ||
null);
});
exports.ModalBase.displayName = 'Modal';
if (false) {}
}
//# sourceMappingURL=Modal.base.js.map
/***/ }),
/***/ 21193:
"use strict";

exports.Modal = void 0;
var Modal_base_1 = __webpack_require__(19875);
var Modal_styles_1 = __webpack_require__(78650);
exports.Modal = Utilities_1.styled(Modal_base_1.ModalBase,
Modal_styles_1.getStyles, undefined, {
scope: 'Modal',
fields: ['theme', 'styles', 'enableAriaHiddenSiblings'],
});
exports.Modal.displayName = 'Modal';
//# sourceMappingURL=Modal.js.map
/***/ }),
/***/ 78650:
"use strict";

exports.getStyles = exports.animationDuration = void 0;
exports.animationDuration = Styling_1.AnimationVariables.durationValue2;
var globalClassNames = {
root: 'ms-Modal',
main: 'ms-Dialog-main',
scrollableContent: 'ms-Modal-scrollableContent',
isOpen: 'is-open',
layer: 'ms-Modal-Layer',
};
var _a;
var className = props.className, containerClassName = props.containerClassName,
scrollableContentClassName = props.scrollableContentClassName, isOpen =
props.isOpen, isVisible = props.isVisible, hasBeenOpened = props.hasBeenOpened,
modalRectangleTop = props.modalRectangleTop, theme = props.theme, topOffsetFixed =
props.topOffsetFixed, isModeless = props.isModeless, layerClassName =
props.layerClassName, isDefaultDragHandle = props.isDefaultDragHandle,
windowInnerHeight = props.windowInnerHeight;
var palette = theme.palette, effects = theme.effects, fonts = theme.fonts;
var classNames = Styling_1.getGlobalClassNames(globalClassNames, theme);
return {
root: [
classNames.root,
fonts.medium,
{
position: isModeless ? 'absolute' : 'fixed',
height: '100%',
width: '100%',
display: 'flex',
opacity: 0,
transition: "opacity " + exports.animationDuration,
},
topOffsetFixed &&
typeof modalRectangleTop === 'number' &&
hasBeenOpened && {
},
isOpen && classNames.isOpen,
isVisible && {
opacity: 1,
},
className,
],
main: [
classNames.main,
{
textAlign: 'left',
maxHeight: 'calc(100% - 32px)',
maxWidth: 'calc(100% - 32px)',
minHeight: '176px',
minWidth: '288px',
overflowY: 'auto',
zIndex: isModeless ? Styling_1.ZIndexes.Layer : undefined,
},
topOffsetFixed &&
typeof modalRectangleTop === 'number' &&
hasBeenOpened && {
top: modalRectangleTop,
},
isDefaultDragHandle && {
cursor: 'move',
},
containerClassName,
],
scrollableContent: [
classNames.scrollableContent,
{
overflowY: 'auto',
flexGrow: 1,
maxHeight: '100vh',
_a['@supports (-webkit-overflow-scrolling: touch)'] = {
maxHeight: windowInnerHeight,
},
_a),
},
scrollableContentClassName,
],
layer: isModeless && [
layerClassName,
classNames.layer,
{
position: 'static',
width: 'unset',
height: 'unset',
},
],
keyboardMoveIconContainer: {
display: 'flex',
width: '100%',
padding: '3px 0px',
},
keyboardMoveIcon: {
fontSize: fonts.xLargePlus.fontSize,
width: '24px',
},
};
};
//# sourceMappingURL=Modal.styles.js.map
/***/ }),
/***/ 71103:
"use strict";

//# sourceMappingURL=Modal.types.js.map
/***/ }),
/***/ 80452:
"use strict";

/***/ }),
/***/ 35145:
"use strict";

exports.NavBase = exports.isRelativeUrl = void 0;
var Nav_styles_1 = __webpack_require__(90925);
// The number pixels per indentation level for Nav links.
var _indentationSize = 14;
// The number of pixels of left margin
var _baseIndent = 3;
// global var used in _isLinkSelectedKey
var _urlResolver;
function isRelativeUrl(url) {
// A URL is relative if it has no protocol.
return !!url && !/^[a-z0-9+-.]+:\/\//i.test(url);
}
exports.isRelativeUrl = isRelativeUrl;
var NavBase = /** @class */ (function (_super) {
tslib_1.__extends(NavBase, _super);
function NavBase(props) {
_this._onRenderLink = function (link) {
var _a = _this.props, styles = _a.styles, groups = _a.groups, theme =
_a.theme;
var classNames = getClassNames(styles, { theme: theme, groups:
groups });
return React.createElement("div", { className: classNames.linkText },
link.name);
};
_this._renderGroup = function (group, groupIndex) {
_a.theme, _b = _a.onRenderGroupHeader, onRenderGroupHeader = _b === void 0 ?
_this._renderGroupHeader : _b;
var isExpanded = _this._isGroupExpanded(group);
theme: theme,
isGroup: true,
isExpanded: isExpanded,
groups: groups,
});
var finalOnHeaderClick = function (ev, isCollapsing) {
_this._onGroupHeaderClicked(group, ev);
};
var groupProps = tslib_1.__assign(tslib_1.__assign({}, group),
{ isExpanded: isExpanded, onHeaderClick: finalOnHeaderClick });
return (React.createElement("div", { key: groupIndex, className:
classNames.group },
groupProps.name ? onRenderGroupHeader(groupProps,
_this._renderGroupHeader) : null,
React.createElement("div", { className: classNames.groupContent },
_this._renderLinks(groupProps.links, 0 /* nestingLevel */))));
};
_this._renderGroupHeader = function (group) {
_a.theme, expandButtonAriaLabel = _a.expandButtonAriaLabel;
var isExpanded = group.isExpanded;
theme: theme,
isGroup: true,
isExpanded: isExpanded,
groups: groups,
});
var label = (isExpanded ? group.collapseAriaLabel :
group.expandAriaLabel) || expandButtonAriaLabel;
var onHeaderClick = group.onHeaderClick;
var onClick = onHeaderClick
? function (ev) {
onHeaderClick(ev, isExpanded);
}
: undefined;
classNames.chevronButton, onClick: onClick, "aria-label": label, "aria-expanded":
isExpanded },
classNames.chevronIcon, iconName: "ChevronDown" }),
group.name));
};
_this.state = {
isGroupCollapsed: {},
// TODO: consider removing
// eslint-disable-next-line react/no-unused-state
isLinkExpandStateChanged: false,
selectedKey: props.initialSelectedKey || props.selectedKey,
};
return _this;
}
NavBase.prototype.render = function () {
var _a = this.props, styles = _a.styles, groups = _a.groups, className =
_a.className, isOnTop = _a.isOnTop, theme = _a.theme;
if (!groups) {
return null;
}
var groupElements = groups.map(this._renderGroup);
var classNames = getClassNames(styles, { theme: theme, className:
className, isOnTop: isOnTop, groups: groups });
return (React.createElement(FocusZone_1.FocusZone, { direction:
FocusZone_1.FocusZoneDirection.vertical, componentRef: this._focusZone },
React.createElement("nav", { role: "navigation", className:
classNames.root, "aria-label": this.props.ariaLabel }, groupElements)));
};
Object.defineProperty(NavBase.prototype, "selectedKey", {
get: function () {
return this.state.selectedKey;
},
enumerable: false,
configurable: true
});
/**
* Sets focus to the first tabbable item in the zone.
* @param forceIntoFirstElement - If true, focus will be forced into the first
element, even
* if focus is already in the focus zone.
*/
NavBase.prototype.focus = function (forceIntoFirstElement) {
if (this._focusZone && this._focusZone.current) {
return this._focusZone.current.focus(forceIntoFirstElement);
}
return false;
};
NavBase.prototype._renderNavLink = function (link, linkIndex, nestingLevel) {
var _a = this.props, styles = _a.styles, groups = _a.groups, theme =
_a.theme;
var isLinkWithIcon = link.icon || link.iconProps;
var isSelectedLink = this._isLinkSelected(link);
var _b = link.ariaCurrent, ariaCurrent = _b === void 0 ? 'page' : _b;
theme: theme,
isSelected: isSelectedLink,
isDisabled: link.disabled,
isButtonEntry: link.onClick && !link.forceAnchor,
leftPadding: _indentationSize * nestingLevel + _baseIndent +
(isLinkWithIcon ? 0 : 24),
groups: groups,
});
// Prevent hijacking of the parent window if link.target is defined
var rel = link.url && link.target && !isRelativeUrl(link.url) ? 'noopener
noreferrer' : undefined;
var LinkAs = this.props.linkAs ?
utilities_1.composeComponentAs(this.props.linkAs, Button_1.ActionButton) :
Button_1.ActionButton;
var onRenderLink = this.props.onRenderLink
? utilities_1.composeRenderFunction(this.props.onRenderLink,
this._onRenderLink)
: this._onRenderLink;
return (React.createElement(LinkAs, { className: classNames.link, styles:
Nav_styles_1.buttonStyles, href: link.url || (link.forceAnchor ? '#' : undefined),
iconProps: link.iconProps || { iconName: link.icon },
onClick: link.onClick ? this._onNavButtonLinkClicked.bind(this, link) :
this._onNavAnchorLinkClicked.bind(this, link), title: link.title !== undefined ?
link.title : link.name, target: link.target, rel: rel, disabled: link.disabled,
"aria-current": isSelectedLink ? ariaCurrent : undefined, "aria-label":
link.ariaLabel ? link.ariaLabel : undefined, link: link }, onRenderLink(link)));
};
NavBase.prototype._renderCompositeLink = function (link, linkIndex,
nestingLevel) {
var divProps = tslib_1.__assign({}, Utilities_1.getNativeProps(link,
Utilities_1.divProperties, ['onClick']));
var _a = this.props, expandButtonAriaLabel = _a.expandButtonAriaLabel,
styles = _a.styles, groups = _a.groups, theme = _a.theme;
theme: theme,
isExpanded: !!link.isExpanded,
isSelected: this._isLinkSelected(link),
isLink: true,
isDisabled: link.disabled,
position: _indentationSize * nestingLevel + 1,
groups: groups,
});
var finalExpandBtnAriaLabel = '';
if (link.links && link.links.length > 0) {
if (link.collapseAriaLabel || link.expandAriaLabel) {
finalExpandBtnAriaLabel = link.isExpanded ?
link.collapseAriaLabel : link.expandAriaLabel;
}
else {
// TODO remove when èxpandButtonAriaLabel` is removed. This is not
an ideal concatenation for localization.
finalExpandBtnAriaLabel = expandButtonAriaLabel ? link.name + " " +
expandButtonAriaLabel : link.name;
}
}
return (React.createElement("div", tslib_1.__assign({}, divProps, { key:
link.key || linkIndex, className: classNames.compositeLink }),
link.links && link.links.length > 0 ? (React.createElement("button",
{ className: classNames.chevronButton, onClick:
this._onLinkExpandClicked.bind(this, link), "aria-label": finalExpandBtnAriaLabel,
"aria-expanded": link.isExpanded ? 'true' : 'false' },
classNames.chevronIcon, iconName: "ChevronDown" }))) : null,
this._renderNavLink(link, linkIndex, nestingLevel)));
};
NavBase.prototype._renderLink = function (link, linkIndex, nestingLevel) {
_a.theme;
var classNames = getClassNames(styles, { theme: theme, groups: groups });
return (React.createElement("li", { key: link.key || linkIndex, role:
"listitem", className: classNames.navItem },
this._renderCompositeLink(link, linkIndex, nestingLevel),
link.isExpanded ? this._renderLinks(link.links, ++nestingLevel) :
null));
};
NavBase.prototype._renderLinks = function (links, nestingLevel) {
var _this = this;
if (!links || !links.length) {
return null;
}
var linkElements = links.map(function (link, linkIndex) {
return _this._renderLink(link, linkIndex, nestingLevel);
});
_a.theme;
var classNames = getClassNames(styles, { theme: theme, groups: groups });
return (React.createElement("ul", { role: "list", className:
classNames.navItems }, linkElements));
};
NavBase.prototype._onGroupHeaderClicked = function (group, ev) {
if (group.onHeaderClick) {
group.onHeaderClick(ev, this._isGroupExpanded(group));
}
if (group.isExpanded === undefined) {
this._toggleCollapsed(group);
}
if (ev) {
}
};
NavBase.prototype._onLinkExpandClicked = function (link, ev) {
var onLinkExpandClick = this.props.onLinkExpandClick;
if (onLinkExpandClick) {
onLinkExpandClick(ev, link);
}
link.isExpanded = !link.isExpanded;
this.setState({ isLinkExpandStateChanged: true });
}
};
NavBase.prototype._preventBounce = function (link, ev) {
if (!link.url && link.forceAnchor) {
}
};
NavBase.prototype._onNavAnchorLinkClicked = function (link, ev) {
// If the href is "#" we should call preventDefault to prevent scrolling to
the top of the page
this._preventBounce(link, ev);
if (this.props.onLinkClick) {
this.props.onLinkClick(ev, link);
}
if (!link.url && link.links && link.links.length > 0) {
this._onLinkExpandClicked(link, ev);
}
this.setState({ selectedKey: link.key });
};
NavBase.prototype._onNavButtonLinkClicked = function (link, ev) {
// If the href is "#" we should call preventDefault to prevent scrolling to
the top of the page
this._preventBounce(link, ev);
if (link.onClick) {
link.onClick(ev, link);
}
if (!link.url && link.links && link.links.length > 0) {
this._onLinkExpandClicked(link, ev);
}
this.setState({ selectedKey: link.key });
};
NavBase.prototype._isLinkSelected = function (link) {
// if caller passes in selectedKey, use it as first choice or
// if current state.selectedKey (from addressbar) is match to the link or
// check if URL is matching location.href (if link.url exists)
if (this.props.selectedKey !== undefined) {
return link.key === this.props.selectedKey;
}
else if (this.state.selectedKey !== undefined) {
return link.key === this.state.selectedKey;
}
else if (typeof Utilities_1.getWindow() === 'undefined' || !link.url) {
// resolve is not supported for ssr
return false;
}
else {
// If selectedKey is undefined in props and state, then check URL
_urlResolver = _urlResolver || document.createElement('a');
_urlResolver.href = link.url || '';
var target = _urlResolver.href;
if (location.href === target) {
return true;
}
// If selectedKey is not defined in state, then check URL to determine
link selected status
if (location.protocol + '//' + location.host + location.pathname ===
target) {
return true;
}
if (location.hash) {
// Match the hash to the url.
if (location.hash === link.url) {
return true;
}
// Match a rebased url. (e.g. #foo becomes http://hostname/foo)
_urlResolver.href = location.hash.substring(1);
return _urlResolver.href === target;
}
}
return false;
};
NavBase.prototype._isGroupExpanded = function (group) {
if (group.isExpanded !== undefined) {
return group.isExpanded;
}
if (group.name && this.state.isGroupCollapsed.hasOwnProperty(group.name)) {
return !this.state.isGroupCollapsed[group.name];
}
if (group.collapseByDefault !== undefined) {
return !group.collapseByDefault;
}
return true;
};
NavBase.prototype._toggleCollapsed = function (group) {
var _a;
if (group.name) {
var newGroupCollapsed = tslib_1.__assign(tslib_1.__assign({},
this.state.isGroupCollapsed), (_a = {}, _a[group.name] =
this._isGroupExpanded(group), _a));
this.setState({ isGroupCollapsed: newGroupCollapsed });
}
};
NavBase.defaultProps = {
groups: null,
};
return NavBase;
exports.NavBase = NavBase;
//# sourceMappingURL=Nav.base.js.map
/***/ }),
/***/ 47236:
"use strict";

exports.Nav = void 0;
var Nav_base_1 = __webpack_require__(35145);
var Nav_styles_1 = __webpack_require__(90925);
exports.Nav = Utilities_1.styled(Nav_base_1.NavBase, Nav_styles_1.getStyles,
undefined, {
scope: 'Nav',
});
//# sourceMappingURL=Nav.js.map
/***/ }),
/***/ 90925:
"use strict";

exports.getStyles = exports.buttonStyles = void 0;
root: 'ms-Nav',
linkText: 'ms-Nav-linkText',
compositeLink: 'ms-Nav-compositeLink',
link: 'ms-Nav-link',
chevronButton: 'ms-Nav-chevronButton',
chevronIcon: 'ms-Nav-chevron',
navItem: 'ms-Nav-navItem',
navItems: 'ms-Nav-navItems',
group: 'ms-Nav-group',
groupContent: 'ms-Nav-groupContent',
};
exports.buttonStyles = {
textContainer: {
overflow: 'hidden',
},
label: {
overflow: 'hidden',
},
};
var _a;
var className = props.className, theme = props.theme, isOnTop = props.isOnTop,
isExpanded = props.isExpanded, isGroup = props.isGroup, isLink = props.isLink,
isSelected = props.isSelected, isDisabled = props.isDisabled, isButtonEntry =
props.isButtonEntry, _b = props.navHeight, navHeight = _b === void 0 ? 44 : _b,
position = props.position, _c = props.leftPadding, leftPadding = _c === void 0 ? 20
: _c, _d = props.leftPaddingExpanded, leftPaddingExpanded = _d === void 0 ? 28 :
_d, _e = props.rightPadding, rightPadding = _e === void 0 ? 20 : _e;
theme.fonts;
return {
root: [
classNames.root,
className,
fonts.medium,
{
overflowY: 'auto',
userSelect: 'none',
},
isOnTop && [
{
},
],
],
linkText: [
classNames.linkText,
{
margin: '0 4px',
overflow: 'hidden',
textAlign: 'left',
},
],
compositeLink: [
classNames.compositeLink,
{
display: 'block',
},
isExpanded && 'is-expanded',
isSelected && 'is-selected',
isDisabled && 'is-disabled',
isDisabled && {
},
],
link: [
classNames.link,
{
display: 'block',
height: navHeight,
width: '100%',
lineHeight: navHeight + "px",
cursor: 'pointer',
overflow: 'hidden',
paddingLeft: leftPadding,
paddingRight: rightPadding,
border: 0,
selectors: {
':focus': {
},
},
},
_a),
},
!isDisabled && {
selectors: {
'.ms-Nav-compositeLink:hover &': {
backgroundColor: semanticColors.bodyBackgroundHovered,
},
},
},
isSelected && {
color: semanticColors.bodyTextChecked,
backgroundColor: semanticColors.bodyBackgroundChecked,
selectors: {
'&:after': {
borderLeft: "2px solid " + palette.themePrimary,
content: '""',
top: 0,
right: 0,
bottom: 0,
left: 0,
},
},
},
isDisabled && {
},
isButtonEntry && {
},
],
chevronButton: [
classNames.chevronButton,
fonts.small,
{
display: 'block',
textAlign: 'left',
margin: '5px 0',
padding: "0px, " + rightPadding + "px, 0px, " + leftPaddingExpanded
+ "px",
border: 'none',
overflow: 'hidden',
cursor: 'pointer',
selectors: {
'&:visited': {
},
},
},
isGroup && {
fontSize: fonts.large.fontSize,
width: '100%',
height: navHeight,
borderBottom: "1px solid " + semanticColors.bodyDivider,
},
isLink && {
display: 'block',
width: leftPaddingExpanded - 2,
height: navHeight - 2,
top: '1px',
left: position + "px",
zIndex: Styling_1.ZIndexes.Nav,
padding: 0,
margin: 0,
},
],
chevronIcon: [
classNames.chevronIcon,
{
left: '8px',
height: navHeight,
// inline-flex prevents the chevron from shifting with custom line
height styles
},
isExpanded && {
},
isLink && {
top: 0,
},
],
navItem: [
classNames.navItem,
{
padding: 0,
},
],
navItems: [
classNames.navItems,
{
padding: 0,
margin: 0, // remove default <UL> styles
},
],
group: [classNames.group, isExpanded && 'is-expanded'],
groupContent: [
classNames.groupContent,
{
display: 'none',
},
isExpanded && {
display: 'block',
},
],
};
};
//# sourceMappingURL=Nav.styles.js.map
/***/ }),
/***/ 45797:
"use strict";

//# sourceMappingURL=Nav.types.js.map
/***/ }),
/***/ 34894:
"use strict";

/***/ }),
/***/ 84462:
"use strict";

exports.OverflowButton = void 0;
var KeytipManager_1 = __webpack_require__(84992);
var registerPersistedKeytips = function (keytipsToRegister, keytipManager,
registeredPersistedKeytips) {
for (var _i = 0, keytipsToRegister_1 = keytipsToRegister; _i <
keytipsToRegister_1.length; _i++) {
var keytip = keytipsToRegister_1[_i];
var uniqueID = keytipManager.register(keytip, true);
// Update map
registeredPersistedKeytips[uniqueID] = keytip;
}
};
var unregisterPersistedKeytips = function (keytipManager,
registeredPersistedKeytips) {
for (var _i = 0, _a = Object.keys(registeredPersistedKeytips); _i < _a.length;
_i++) {
var uniqueID = _a[_i];
keytipManager.unregister(registeredPersistedKeytips[uniqueID], uniqueID,
true);
delete registeredPersistedKeytips[uniqueID];
}
};
var useKeytipRegistrations = function (registeredPersistedKeytips,
keytipsToRegister, keytipManager) {
var prevPersistedKeytips =
react_hooks_1.usePrevious(registeredPersistedKeytips);
// Update
if (prevPersistedKeytips) {
// Unregister old keytips
unregisterPersistedKeytips(keytipManager, prevPersistedKeytips);
// Register new keytips
registerPersistedKeytips(keytipsToRegister, keytipManager,
registeredPersistedKeytips);
}
});
// Mount/Unmount
// Register on mount
registerPersistedKeytips(keytipsToRegister, keytipManager,
registeredPersistedKeytips);
// Unregister on unmount
unregisterPersistedKeytips(keytipManager, registeredPersistedKeytips);
};
}, []);
};
var OverflowButton = function (props) {
var keytipManager = KeytipManager_1.KeytipManager.getInstance();
var className = props.className, overflowItems = props.overflowItems,
keytipSequences = props.keytipSequences, itemSubMenuProvider =
props.itemSubMenuProvider, onRenderOverflowButton = props.onRenderOverflowButton;
var persistedKeytips = react_hooks_1.useConst({});
// Gets the subMenu for an overflow item
var getSubMenuForItem = React.useCallback(function (item) {
// Checks if itemSubMenuProvider has been defined, if not defaults to
subMenuProps
if (itemSubMenuProvider) {
return itemSubMenuProvider(item);
}
if (item.subMenuProps) {
return item.subMenuProps.items;
}
return undefined;
}, [itemSubMenuProvider]);
var _a = React.useMemo(function () {
var newKeytipsToRegister = [];
var newOverflowItems = [];
if (keytipSequences) {
overflowItems === null || overflowItems === void 0 ? void 0 :
overflowItems.forEach(function (overflowItem) {
var _a;
var keytip = overflowItem.keytipProps;
if (keytip) {
// Create persisted keytip
var persistedKeytip = {
content: keytip.content,
keySequences: keytip.keySequences,
disabled: keytip.disabled || !!(overflowItem.disabled ||
overflowItem.isDisabled),
hasDynamicChildren: keytip.hasDynamicChildren,
hasMenu: keytip.hasMenu,
};
if (keytip.hasDynamicChildren ||
getSubMenuForItem(overflowItem)) {
// If the keytip has a submenu or children nodes, change
onExecute to persistedKeytipExecute
persistedKeytip.onExecute =
keytipManager.menuExecute.bind(keytipManager, keytipSequences, (_a = overflowItem
=== null || overflowItem === void 0 ? void 0 : overflowItem.keytipProps) === null
|| _a === void 0 ? void 0 : _a.keySequences);
persistedKeytip.hasOverflowSubMenu = true;
}
else {
// If the keytip doesn't have a submenu, just execute the
original function
persistedKeytip.onExecute = keytip.onExecute;
}
newKeytipsToRegister.push(persistedKeytip);
// Add the overflow sequence to this item
var newOverflowItem = tslib_1.__assign(tslib_1.__assign({},
overflowItem), { keytipProps: tslib_1.__assign(tslib_1.__assign({}, keytip),
{ overflowSetSequence: keytipSequences }) });
newOverflowItems === null || newOverflowItems === void 0 ? void
0 : newOverflowItems.push(newOverflowItem);
}
else {
// Nothing to change, add overflowItem to list
newOverflowItems === null || newOverflowItems === void 0 ? void
0 : newOverflowItems.push(overflowItem);
}
});
}
else {
newOverflowItems = overflowItems;
}
return { modifiedOverflowItems: newOverflowItems, keytipsToRegister:
newKeytipsToRegister };
}, [overflowItems, getSubMenuForItem, keytipManager, keytipSequences]),
modifiedOverflowItems = _a.modifiedOverflowItems, keytipsToRegister =
_a.keytipsToRegister;
useKeytipRegistrations(persistedKeytips, keytipsToRegister, keytipManager);
return React.createElement("div", { className: className },
onRenderOverflowButton(modifiedOverflowItems));
};
exports.OverflowButton = OverflowButton;
//# sourceMappingURL=OverflowButton.js.map
/***/ }),
/***/ 88985:
"use strict";

exports.OverflowSetBase = void 0;
var OverflowButton_1 = __webpack_require__(84462);
var COMPONENT_NAME = 'OverflowSet';
var useComponentRef = function (props, divContainer) {
var focusSucceeded = false;
if (divContainer.current) {
focusSucceeded = Utilities_1.focusFirstChild(divContainer.current);
}
return focusSucceeded;
},
focusElement: function (childElement) {
var focusSucceeded = false;
if (!childElement) {
return false;
}
if (divContainer.current &&
Utilities_1.elementContains(divContainer.current, childElement)) {
childElement.focus();
focusSucceeded = document.activeElement === childElement;
}
return focusSucceeded;
},
}); }, [divContainer]);
};
exports.OverflowSetBase = React.forwardRef(function (props, forwardedRef) {
var divContainer = React.useRef(null);
var mergedRef = react_hooks_1.useMergedRefs(divContainer, forwardedRef);
useComponentRef(props, divContainer);
var items = props.items, overflowItems = props.overflowItems, className =
props.className, styles = props.styles, vertical = props.vertical, role =
props.role, _a = props.overflowSide, overflowSide = _a === void 0 ? 'end' : _a,
onRenderItem = props.onRenderItem;
var classNames = getClassNames(styles, { className: className, vertical:
vertical });
var showOverflow = !!overflowItems && overflowItems.length > 0;
Utilities_1.getNativeProps(props, Utilities_1.divProperties), { role: role ||
'group', "aria-orientation": role === 'menubar' ? (vertical === true ? 'vertical' :
'horizontal') : undefined, className: classNames.root, ref: mergedRef }),
overflowSide === 'start' && showOverflow &&
React.createElement(OverflowButton_1.OverflowButton, tslib_1.__assign({}, props,
{ className: classNames.overflowButton })),
items &&
items.map(function (item, i) { return (React.createElement("div",
{ className: classNames.item, key: item.key, role: "none" },
onRenderItem(item))); }),
overflowSide === 'end' && showOverflow &&
React.createElement(OverflowButton_1.OverflowButton, tslib_1.__assign({}, props,
{ className: classNames.overflowButton }))));
});
exports.OverflowSetBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=OverflowSet.base.js.map
/***/ }),
/***/ 13687:
"use strict";

exports.OverflowSet = void 0;
var OverflowSet_base_1 = __webpack_require__(88985);
var OverflowSet_styles_1 = __webpack_require__(3255);
exports.OverflowSet = Utilities_1.styled(OverflowSet_base_1.OverflowSetBase,
OverflowSet_styles_1.getStyles, undefined, {
scope: 'OverflowSet',
});
//# sourceMappingURL=OverflowSet.js.map
/***/ }),
/***/ 3255:
"use strict";

var overflowItemStyle = {
flexShrink: 0,
display: 'inherit',
};
var className = props.className, vertical = props.vertical;
return {
root: [
'ms-OverflowSet',
{
display: 'flex',
flexWrap: 'nowrap',
},
vertical && { flexDirection: 'column' },
className,
],
item: ['ms-OverflowSet-item', overflowItemStyle],
overflowButton: ['ms-OverflowSet-overflowButton', overflowItemStyle],
};
};
//# sourceMappingURL=OverflowSet.styles.js.map
/***/ }),
/***/ 82525:
"use strict";

//# sourceMappingURL=OverflowSet.types.js.map
/***/ }),
/***/ 66428:
"use strict";

/***/ }),
/***/ 38570:
"use strict";

exports.OverlayBase = void 0;
var OverlayBase = /** @class */ (function (_super) {
tslib_1.__extends(OverlayBase, _super);
function OverlayBase(props) {
var _a = _this.props.allowTouchBodyScroll, allowTouchBodyScroll = _a ===
void 0 ? false : _a;
_this._allowTouchBodyScroll = allowTouchBodyScroll;
return _this;
}
OverlayBase.prototype.componentDidMount = function () {
!this._allowTouchBodyScroll && Utilities_1.disableBodyScroll();
};
OverlayBase.prototype.componentWillUnmount = function () {
!this._allowTouchBodyScroll && Utilities_1.enableBodyScroll();
};
OverlayBase.prototype.render = function () {
var _a = this.props, isDark = _a.isDarkThemed, className = _a.className,
theme = _a.theme, styles = _a.styles;
theme: theme,
isDark: isDark,
});
return React.createElement("div", tslib_1.__assign({}, divProps,
{ className: classNames.root }));
};
return OverlayBase;
exports.OverlayBase = OverlayBase;
//# sourceMappingURL=Overlay.base.js.map
/***/ }),
/***/ 68258:
"use strict";

exports.Overlay = void 0;
var Overlay_base_1 = __webpack_require__(38570);
var Overlay_styles_1 = __webpack_require__(96914);
exports.Overlay = Utilities_1.styled(Overlay_base_1.OverlayBase,
Overlay_styles_1.getStyles, undefined, {
scope: 'Overlay',
});
//# sourceMappingURL=Overlay.js.map
/***/ }),
/***/ 96914:
"use strict";

root: 'ms-Overlay',
rootDark: 'ms-Overlay--dark',
};
var _a;
var className = props.className, theme = props.theme, isNone = props.isNone,
isDark = props.isDark;
return {
root: [
classNames.root,
theme.fonts.medium,
{
backgroundColor: palette.whiteTranslucent40,
top: 0,
right: 0,
bottom: 0,
left: 0,
opacity: 0,
},
_a),
},
isNone && {
},
isDark && [
classNames.rootDark,
{
backgroundColor: palette.blackTranslucent40,
},
],
className,
],
};
};
//# sourceMappingURL=Overlay.styles.js.map
/***/ }),
/***/ 69061:
"use strict";

//# sourceMappingURL=Overlay.types.js.map
/***/ }),
/***/ 12595:
"use strict";

/***/ }),
/***/ 85409:
"use strict";

exports.PanelBase = void 0;
var Overlay_1 = __webpack_require__(18494);
var Panel_types_1 = __webpack_require__(13575);
var COMPONENT_NAME = 'Panel';
var PanelVisibilityState;
(function (PanelVisibilityState) {
PanelVisibilityState[PanelVisibilityState["closed"] = 0] = "closed";
PanelVisibilityState[PanelVisibilityState["animatingOpen"] = 1] =
"animatingOpen";
PanelVisibilityState[PanelVisibilityState["open"] = 2] = "open";
PanelVisibilityState[PanelVisibilityState["animatingClosed"] = 3] =
"animatingClosed";
})(PanelVisibilityState || (PanelVisibilityState = {}));
var PanelBase = /** @class */ (function (_super) {
tslib_1.__extends(PanelBase, _super);
function PanelBase(props) {
_this._panel = React.createRef();
_this._animationCallback = null;
_this._hasCustomNavigation = !!(_this.props.onRenderNavigation ||
_this.props.onRenderNavigationContent);
_this.dismiss = function (ev) {
if (_this.props.onDismiss && _this.isActive) {
_this.props.onDismiss(ev);
}
if (!ev || (ev && !ev.defaultPrevented)) {
_this.close();
}
};
// Allow the user to scroll within the panel but not on the body
_this._allowScrollOnPanel = function (elt) {
if (elt) {
if (_this._allowTouchBodyScroll) {
Utilities_1.allowOverscrollOnElement(elt, _this._events);
}
else {
Utilities_1.allowScrollOnElement(elt, _this._events);
}
}
else {
_this._events.off(_this._scrollableContent);
}
_this._scrollableContent = elt;
};
_this._onRenderNavigation = function (props) {
if (!_this.props.onRenderNavigationContent && !
_this.props.onRenderNavigation && !_this.props.hasCloseButton) {
return null;
}
var _a = _this.props.onRenderNavigationContent,
onRenderNavigationContent = _a === void 0 ? _this._onRenderNavigationContent : _a;
_this._classNames.navigation }, onRenderNavigationContent(props,
_this._onRenderNavigationContent)));
};
_this._onRenderNavigationContent = function (props) {
var _a;
var closeButtonAriaLabel = props.closeButtonAriaLabel, hasCloseButton =
props.hasCloseButton, _b = props.onRenderHeader, onRenderHeader = _b === void 0 ?
_this._onRenderHeader : _b;
if (hasCloseButton) {
var iconButtonStyles = (_a = _this._classNames.subComponentStyles)
=== null || _a === void 0 ? void 0 : _a.closeButton();
!_this._hasCustomNavigation && onRenderHeader(_this.props,
_this._onRenderHeader, _this._headerTextId),
React.createElement(Button_1.IconButton, { styles:
iconButtonStyles, className: _this._classNames.closeButton, onClick:
_this._onPanelClick, ariaLabel: closeButtonAriaLabel, title: closeButtonAriaLabel,
"data-is-visible": true, iconProps: { iconName: 'Cancel' } })));
}
return null;
};
_this._onRenderHeader = function (props, defaultRender, headerTextId) {
var headerText = props.headerText, _a = props.headerTextProps,
headerTextProps = _a === void 0 ? {} : _a;
if (headerText) {
_this._classNames.header },
React.createElement("div", tslib_1.__assign({ id: headerTextId,
role: "heading", "aria-level": 1 }, headerTextProps, { className:
Utilities_1.css(_this._classNames.headerText, headerTextProps.className) }),
headerText)));
}
return null;
};
_this._onRenderBody = function (props) {
_this._classNames.content }, props.children);
};
_this._onRenderFooter = function (props) {
var _a = _this.props.onRenderFooterContent, onRenderFooterContent = _a
=== void 0 ? null : _a;
if (onRenderFooterContent) {
_this._classNames.footer },
_this._classNames.footerInner }, onRenderFooterContent())));
}
return null;
};
_this._animateTo = function (newVisibilityState) {
if (newVisibilityState === PanelVisibilityState.open &&
_this.props.onOpen) {
_this.props.onOpen();
}
_this._animationCallback = _this._async.setTimeout(function () {
_this.setState({ visibility: newVisibilityState });
_this._onTransitionComplete();
}, 200);
};
_this._clearExistingAnimationTimer = function () {
if (_this._animationCallback !== null) {
_this._async.clearTimeout(_this._animationCallback);
}
};
_this._onPanelClick = function (ev) {
_this.dismiss(ev);
};
_this._onTransitionComplete = function () {
_this._updateFooterPosition();
if (_this.state.visibility === PanelVisibilityState.open &&
_this.props.onOpened) {
_this.props.onOpened();
}
if (_this.state.visibility === PanelVisibilityState.closed &&
_this.props.onDismissed) {
_this.props.onDismissed();
}
};
var _a = _this.props.allowTouchBodyScroll, allowTouchBodyScroll = _a ===
void 0 ? false : _a;
_this._allowTouchBodyScroll = allowTouchBodyScroll;
ignoreExternalFocusing: 'focusTrapZoneProps',
forceFocusInsideTrap: 'focusTrapZoneProps',
firstFocusableSelector: 'focusTrapZoneProps',
});
_this.state = {
isFooterSticky: false,
// intentionally ignore props so animation takes place during
componentDidMount
visibility: PanelVisibilityState.closed,
id: Utilities_1.getId('Panel'),
};
return _this;
}
PanelBase.getDerivedStateFromProps = function (nextProps, prevState) {
if (nextProps.isOpen === undefined) {
return null; // no state update
}
if (nextProps.isOpen &&
(prevState.visibility === PanelVisibilityState.closed ||
prevState.visibility === PanelVisibilityState.animatingClosed)) {
return { visibility: PanelVisibilityState.animatingOpen };
}
if (!nextProps.isOpen &&
(prevState.visibility === PanelVisibilityState.open ||
prevState.visibility === PanelVisibilityState.animatingOpen)) {
return { visibility: PanelVisibilityState.animatingClosed };
}
return null;
};
PanelBase.prototype.componentDidMount = function () {
this._events.on(window, 'resize', this._updateFooterPosition);
if (this._shouldListenForOuterClick(this.props)) {
this._events.on(document.body, 'mousedown', this._dismissOnOuterClick,
true);
}
if (this.props.isOpen) {
this.setState({ visibility: PanelVisibilityState.animatingOpen });
}
};
PanelBase.prototype.componentDidUpdate = function (previousProps,
previousState) {
var shouldListenOnOuterClick = this._shouldListenForOuterClick(this.props);
var previousShouldListenOnOuterClick =
this._shouldListenForOuterClick(previousProps);
if (this.state.visibility !== previousState.visibility) {
this._clearExistingAnimationTimer();
if (this.state.visibility === PanelVisibilityState.animatingOpen) {
this._animateTo(PanelVisibilityState.open);
}
else if (this.state.visibility ===
PanelVisibilityState.animatingClosed) {
this._animateTo(PanelVisibilityState.closed);
}
}
if (shouldListenOnOuterClick && !previousShouldListenOnOuterClick) {
this._events.on(document.body, 'mousedown', this._dismissOnOuterClick,
true);
}
else if (!shouldListenOnOuterClick && previousShouldListenOnOuterClick) {
this._events.off(document.body, 'mousedown', this._dismissOnOuterClick,
true);
}
};
PanelBase.prototype.componentWillUnmount = function () {
};
PanelBase.prototype.render = function () {
var _a = this.props, _b = _a.className, className = _b === void 0 ? '' :
_b, elementToFocusOnDismiss = _a.elementToFocusOnDismiss,
firstFocusableSelector = _a.firstFocusableSelector, focusTrapZoneProps =
_a.focusTrapZoneProps, forceFocusInsideTrap = _a.forceFocusInsideTrap,
hasCloseButton = _a.hasCloseButton, headerText = _a.headerText, _c =
_a.headerClassName, headerClassName = _c === void 0 ? '' : _c,
ignoreExternalFocusing = _a.ignoreExternalFocusing, isBlocking = _a.isBlocking,
isFooterAtBottom = _a.isFooterAtBottom, isLightDismiss = _a.isLightDismiss,
isHiddenOnDismiss = _a.isHiddenOnDismiss, layerProps = _a.layerProps, overlayProps
= _a.overlayProps, popupProps = _a.popupProps, type = _a.type, styles = _a.styles,
theme = _a.theme, customWidth = _a.customWidth, _d = _a.onLightDismissClick,
onLightDismissClick = _d === void 0 ? this._onPanelClick : _d, _e =
_a.onRenderNavigation, onRenderNavigation = _e === void 0 ?
this._onRenderNavigation : _e, _f = _a.onRenderHeader, onRenderHeader = _f === void
0 ? this._onRenderHeader : _f, _g = _a.onRenderBody, onRenderBody = _g === void 0 ?
this._onRenderBody : _g, _h = _a.onRenderFooter, onRenderFooter = _h === void 0 ?
this._onRenderFooter : _h;
var _j = this.state, isFooterSticky = _j.isFooterSticky, visibility =
_j.visibility, id = _j.id;
var isLeft = type === Panel_types_1.PanelType.smallFixedNear || type ===
Panel_types_1.PanelType.customNear ? true : false;
var isOnRightSide = isRTL ? isLeft : !isLeft;
var customWidthStyles = type === Panel_types_1.PanelType.custom || type ===
Panel_types_1.PanelType.customNear ? { width: customWidth } : {};
var isOpen = this.isActive;
var isAnimating = visibility === PanelVisibilityState.animatingClosed ||
visibility === PanelVisibilityState.animatingOpen;
this._headerTextId = headerText && id + '-headerText';
if (!isOpen && !isAnimating && !isHiddenOnDismiss) {
return null;
}
theme: theme,
focusTrapZoneClassName: focusTrapZoneProps ?
focusTrapZoneProps.className : undefined,
hasCloseButton: hasCloseButton,
headerClassName: headerClassName,
isAnimating: isAnimating,
isFooterSticky: isFooterSticky,
isFooterAtBottom: isFooterAtBottom,
isOnRightSide: isOnRightSide,
isOpen: isOpen,
isHiddenOnDismiss: isHiddenOnDismiss,
type: type,
hasCustomNavigation: this._hasCustomNavigation,
});
var _k = this, _classNames = _k._classNames, _allowTouchBodyScroll =
_k._allowTouchBodyScroll;
var overlay;
if (isBlocking && isOpen) {
overlay = (React.createElement(Overlay_1.Overlay,
tslib_1.__assign({ className: _classNames.overlay, isDarkThemed: false, onClick:
isLightDismiss ? onLightDismissClick : undefined, allowTouchBodyScroll:
_allowTouchBodyScroll }, overlayProps)));
}
return (React.createElement(Layer_1.Layer, tslib_1.__assign({},
layerProps),
React.createElement(Popup_1.Popup, tslib_1.__assign({ role: "dialog",
"aria-modal": isBlocking ? 'true' : undefined, ariaLabelledBy: this._headerTextId ?
this._headerTextId : undefined, onDismiss: this.dismiss, className:
_classNames.hiddenPanel, enableAriaHiddenSiblings: isOpen ? true : undefined },
popupProps),
React.createElement("div", tslib_1.__assign({ "aria-hidden": !
isOpen && isAnimating }, nativeProps, { ref: this._panel, className:
_classNames.root }),
overlay,
React.createElement(index_1.FocusTrapZone,
tslib_1.__assign({ ignoreExternalFocusing: ignoreExternalFocusing,
forceFocusInsideTrap: !isBlocking || (isHiddenOnDismiss && !isOpen) ? false :
forceFocusInsideTrap, firstFocusableSelector: firstFocusableSelector,
isClickableOutsideFocusTrap: true }, focusTrapZoneProps, { className:
_classNames.main, style: customWidthStyles, elementToFocusOnDismiss:
elementToFocusOnDismiss }),
_classNames.contentInner },
React.createElement("div", { ref:
this._allowScrollOnPanel, className: _classNames.scrollableContent, "data-is-
scrollable": true },
_classNames.commands, "data-is-visible": true }, onRenderNavigation(this.props,
this._onRenderNavigation)),
(this._hasCustomNavigation || !hasCloseButton) &&
onRenderHeader(this.props,
this._onRenderHeader, this._headerTextId),
onRenderBody(this.props, this._onRenderBody),
onRenderFooter(this.props,
this._onRenderFooter))))))));
};
PanelBase.prototype.open = function () {
if (this.props.isOpen !== undefined) {
return;
}
if (this.isActive) {
return;
}
this.setState({ visibility: PanelVisibilityState.animatingOpen });
};
PanelBase.prototype.close = function () {
if (this.props.isOpen !== undefined) {
return;
}
if (!this.isActive) {
return;
}
this.setState({ visibility: PanelVisibilityState.animatingClosed });
};
Object.defineProperty(PanelBase.prototype, "isActive", {
/** isActive is true when panel is open or opening. */
get: function () {
return (this.state.visibility === PanelVisibilityState.open ||
this.state.visibility === PanelVisibilityState.animatingOpen);
},
enumerable: false,
configurable: true
});
PanelBase.prototype._shouldListenForOuterClick = function (props) {
return !!props.isBlocking && !!props.isOpen;
};
PanelBase.prototype._updateFooterPosition = function () {
var scrollableContent = this._scrollableContent;
if (scrollableContent) {
var height = scrollableContent.clientHeight;
var innerHeight_1 = scrollableContent.scrollHeight;
this.setState({
isFooterSticky: height < innerHeight_1 ? true : false,
});
}
};
PanelBase.prototype._dismissOnOuterClick = function (ev) {
var panel = this._panel.current;
if (this.isActive && panel && !ev.defaultPrevented) {
if (!Utilities_1.elementContains(panel, ev.target)) {
if (this.props.onOuterClick) {
this.props.onOuterClick(ev);
}
else {
this.dismiss(ev);
}
}
}
};
PanelBase.defaultProps = {
isHiddenOnDismiss: false,
isOpen: undefined,
isBlocking: true,
hasCloseButton: true,
type: Panel_types_1.PanelType.smallFixedFar,
};
return PanelBase;
exports.PanelBase = PanelBase;
//# sourceMappingURL=Panel.base.js.map
/***/ }),
/***/ 55974:
"use strict";

exports.Panel = void 0;
var Panel_base_1 = __webpack_require__(85409);
var Panel_styles_1 = __webpack_require__(57208);
/**
* Panel description
*/
exports.Panel = Utilities_1.styled(Panel_base_1.PanelBase,
Panel_styles_1.getStyles, undefined, {
scope: 'Panel',
});
//# sourceMappingURL=Panel.js.map
/***/ }),
/***/ 57208:
"use strict";
var _a, _b, _c, _d, _e;

var Panel_types_1 = __webpack_require__(13575);
root: 'ms-Panel',
main: 'ms-Panel-main',
commands: 'ms-Panel-commands',
contentInner: 'ms-Panel-contentInner',
scrollableContent: 'ms-Panel-scrollableContent',
navigation: 'ms-Panel-navigation',
closeButton: 'ms-Panel-closeButton ms-PanelAction-close',
header: 'ms-Panel-header',
headerText: 'ms-Panel-headerText',
content: 'ms-Panel-content',
footer: 'ms-Panel-footer',
footerInner: 'ms-Panel-footerInner',
isOpen: 'is-open',
hasCloseButton: 'ms-Panel--hasCloseButton',
smallFluid: 'ms-Panel--smFluid',
smallFixedNear: 'ms-Panel--smLeft',
smallFixedFar: 'ms-Panel--sm',
medium: 'ms-Panel--md',
large: 'ms-Panel--lg',
largeFixed: 'ms-Panel--fixed',
extraLarge: 'ms-Panel--xl',
custom: 'ms-Panel--custom',
customNear: 'ms-Panel--customLeft',
};
var panelWidth = {
full: '100%',
auto: 'auto',
xs: 272,
sm: 340,
md1: 592,
md2: 644,
lg: 940,
};
var panelMargin = {
auto: 'auto',
none: 0,
md: 48,
lg: 428,
xl: 176,
};
// Following consts are used below in `getPanelBreakpoints()` function to provide
// necessary fallbacks for different types of Panel in different breakpoints.
var smallPanelSelectors = (_a = {},
_a["@media (min-width: " + Styling_1.ScreenWidthMinMedium + "px)"] = {
width: panelWidth.sm,
},
_a);
var mediumPanelSelectors = (_b = {},
_b["@media (min-width: " + Styling_1.ScreenWidthMinLarge + "px)"] = {
width: panelWidth.md1,
},
_b["@media (min-width: " + Styling_1.ScreenWidthMinXLarge + "px)"] = {
width: panelWidth.md2,
},
_b);
var largePanelSelectors = (_c = {},
_c["@media (min-width: " + Styling_1.ScreenWidthMinUhfMobile + "px)"] = {
left: panelMargin.md,
width: panelWidth.auto,
},
_c["@media (min-width: " + Styling_1.ScreenWidthMinXXLarge + "px)"] = {
left: panelMargin.lg,
},
_c);
var largeFixedPanelSelectors = (_d = {},
_d["@media (min-width: " + Styling_1.ScreenWidthMinXXLarge + "px)"] = {
left: panelMargin.auto,
width: panelWidth.lg,
},
_d);
var extraLargePanelSelectors = (_e = {},
_e["@media (min-width: " + Styling_1.ScreenWidthMinXXLarge + "px)"] = {
left: panelMargin.xl,
},
_e);
// Make sure Panels have fallbacks to different breakpoints by reusing same
selectors.
// This is done in the effort to follow design redlines.
var getPanelBreakpoints = function (type) {
var selectors;
// Panel types `smallFluid`, `smallFixedNear`, `custom` and `customNear`
// are not checked in here because they render the same in all the breakpoints
// and have the checks done separately in the `getStyles` function below.
switch (type) {
case Panel_types_1.PanelType.smallFixedFar:
selectors = tslib_1.__assign({}, smallPanelSelectors);
break;
case Panel_types_1.PanelType.medium:
selectors = tslib_1.__assign(tslib_1.__assign({}, smallPanelSelectors),
mediumPanelSelectors);
break;
case Panel_types_1.PanelType.large:
selectors = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({},
smallPanelSelectors), mediumPanelSelectors), largePanelSelectors);
break;
case Panel_types_1.PanelType.largeFixed:
selectors =
smallPanelSelectors), mediumPanelSelectors), largePanelSelectors),
largeFixedPanelSelectors);
break;
case Panel_types_1.PanelType.extraLarge:
selectors =
smallPanelSelectors), mediumPanelSelectors), largePanelSelectors),
extraLargePanelSelectors);
break;
default:
break;
}
return selectors;
};
var commandBarHeight = '44px';
var sharedPaddingStyles = {
};
var _a, _b, _c, _d;
var className = props.className, focusTrapZoneClassName =
props.focusTrapZoneClassName, hasCloseButton = props.hasCloseButton,
headerClassName = props.headerClassName, isAnimating = props.isAnimating,
isFooterSticky = props.isFooterSticky, isFooterAtBottom = props.isFooterAtBottom,
isOnRightSide = props.isOnRightSide, isOpen = props.isOpen, isHiddenOnDismiss =
props.isHiddenOnDismiss, hasCustomNavigation = props.hasCustomNavigation, theme =
props.theme, _e = props.type, type = _e === void 0 ?
Panel_types_1.PanelType.smallFixedFar : _e;
var effects = theme.effects, fonts = theme.fonts, semanticColors =
theme.semanticColors;
var isCustomPanel = type === Panel_types_1.PanelType.custom || type ===
Panel_types_1.PanelType.customNear;
return {
root: [
classNames.root,
theme.fonts.medium,
isOpen && classNames.isOpen,
hasCloseButton && classNames.hasCloseButton,
{
top: 0,
left: 0,
right: 0,
bottom: 0,
},
isCustomPanel && isOnRightSide && classNames.custom,
isCustomPanel && !isOnRightSide && classNames.customNear,
className,
],
overlay: [
{
cursor: 'pointer',
},
isOpen && isAnimating && Styling_1.AnimationClassNames.fadeIn100,
!isOpen && isAnimating && Styling_1.AnimationClassNames.fadeOut100,
],
hiddenPanel: [
!isOpen &&
!isAnimating &&
isHiddenOnDismiss && {
},
],
main: [
classNames.main,
{
display: 'flex',
overflowY: 'auto',
bottom: 0,
top: 0,
// left, right, width are overridden depending on the type of the
Panel and the screen breakpoint.
left: panelMargin.auto,
right: panelMargin.none,
width: panelWidth.full,
selectors: tslib_1.__assign((_a = {},
borderLeft: "3px solid " + semanticColors.variantBorder,
borderRight: "3px solid " + semanticColors.variantBorder,
}, _a), getPanelBreakpoints(type)),
},
type === Panel_types_1.PanelType.smallFluid && {
left: panelMargin.none,
},
type === Panel_types_1.PanelType.smallFixedNear && {
left: panelMargin.none,
right: panelMargin.auto,
width: panelWidth.xs,
},
type === Panel_types_1.PanelType.customNear && {
right: 'auto',
left: 0,
},
isCustomPanel && {
maxWidth: '100vw',
},
isOpen && isAnimating && !isOnRightSide &&
isOpen && isAnimating && isOnRightSide &&
Styling_1.AnimationClassNames.slideLeftIn40,
!isOpen && isAnimating && !isOnRightSide &&
Styling_1.AnimationClassNames.slideLeftOut40,
!isOpen && isAnimating && isOnRightSide &&
Styling_1.AnimationClassNames.slideRightOut40,
focusTrapZoneClassName,
],
commands: [
classNames.commands,
{
paddingTop: 18,
_b["@media (min-height: " + Styling_1.ScreenWidthMinMedium +
"px)"] = {
position: 'sticky',
top: 0,
zIndex: 1,
},
_b),
},
hasCustomNavigation && {
paddingTop: 'inherit',
},
// - Ensures that the sticky header always has a background to prevent
overlaps on scroll.
// - Adds consistent behavior with how Footer is being handled
isFooterSticky && {
},
],
navigation: [
classNames.navigation,
{
display: 'flex',
},
height: commandBarHeight,
},
],
contentInner: [
classNames.contentInner,
{
display: 'flex',
flexGrow: 1,
},
],
header: [
classNames.header,
sharedPaddingStyles,
{
alignSelf: 'flex-start',
},
hasCloseButton &&
!hasCustomNavigation && {
flexGrow: 1,
},
// Ensure that title doesn't shrink if screen is too small
flexShrink: 0,
},
],
headerText: [
classNames.headerText,
fonts.xLarge,
{
lineHeight: '27px',
hyphens: 'auto',
},
headerClassName,
],
scrollableContent: [
classNames.scrollableContent,
{
overflowY: 'auto',
},
isFooterAtBottom && {
flexGrow: 1,
display: 'inherit',
flexDirection: 'inherit',
},
],
content: [
classNames.content,
{
paddingBottom: 20,
},
isFooterAtBottom && {
_c["@media (min-height: " + Styling_1.ScreenWidthMinMedium +
"px)"] = {
flexGrow: 1,
},
_c),
},
],
footer: [
classNames.footer,
{
// Ensure that footer doesn't shrink if screen is too small
flexShrink: 0,
borderTop: '1px solid transparent',
transition: "opacity " +
Styling_1.AnimationVariables.durationValue3 + " " +
Styling_1.AnimationVariables.easeFunction2,
_d["@media (min-height: " + Styling_1.ScreenWidthMinMedium +
"px)"] = {
position: 'sticky',
bottom: 0,
},
_d),
},
isFooterSticky && {
borderTopColor: semanticColors.variantBorder,
},
],
footerInner: [
classNames.footerInner,
{
paddingBottom: 16,
paddingTop: 16,
},
],
closeButton: {
root: [
classNames.closeButton,
{
marginRight: 14,
},
marginRight: 0,
height: 'auto',
width: '44px',
},
],
rootHovered: {
},
},
},
};
};
//# sourceMappingURL=Panel.styles.js.map
/***/ }),
/***/ 13575:
"use strict";

exports.PanelType = void 0;
/**
* {@docCategory Panel}
*/
var PanelType;
(function (PanelType) {
/**
* Renders the Panel with a `fluid` (full screen) width.
* Recommended for use on small screen breakpoints.
* - Small (320-479): full screen width, 16px left/right padding
* - Medium (480-639): full screen width, 16px left/right padding
* - Large (640-1023): full screen width, 32px left/right padding
* - XLarge (1024-1365): full screen width, 32px left/right padding
* - XXLarge (1366-up): full screen width, 40px left/right padding
*/
PanelType[PanelType["smallFluid"] = 0] = "smallFluid";
/**
* Renders the Panel in fixed-width `small` size, anchored to the far side
(right in LTR mode).
* - Small (320-479): adapts to `PanelType.smallFluid` at this breakpoint
* - Medium (480-639): 340px width, 16px left/right padding
* - Large (640-1023): 340px width, 32px left/right padding
* - XLarge (1024-1365): 340px width, 32px left/right padding
* - XXLarge (1366-up): 340px width, 40px left/right padding
*/
PanelType[PanelType["smallFixedFar"] = 1] = "smallFixedFar";
/**
* Renders the Panel in fixed-width `small` size, anchored to the near side
(left in LTR mode).
* - Small (320-479): 272px width, 16px left/right padding
* - Medium (480-639): 272px width, 16px left/right padding
*/
PanelType[PanelType["smallFixedNear"] = 2] = "smallFixedNear";
/**
* Renders the Panel in `medium` size, anchored to the far side (right in LTR
mode).
* - Medium (480-639): adapts to `PanelType.smallFixedFar` at this breakpoint
*/
PanelType[PanelType["medium"] = 3] = "medium";
/**
* Renders the Panel in `large` size, anchored to the far side (right in LTR
mode).
* - Large (640-1023): adapts to `PanelType.medium` at this breakpoint
* - XLarge (1024-1365): 48px fixed left margin, fluid width, 32px left/right
padding
* - XXLarge (1366-up): 428px fixed left margin, fluid width, 40px left/right
padding
*/
PanelType[PanelType["large"] = 4] = "large";
/**
* Renders the Panel in `large` size, anchored to the far side (right in LTR
mode), with a fixed width at
* XX-Large breakpoint.
* - XLarge (1024-1365): 48px fixed left margin, fluid width, 32px left/right
padding
*/
PanelType[PanelType["largeFixed"] = 5] = "largeFixed";
/**
* Renders the Panel in èxtra large` size, anchored to the far side (right in
LTR mode).
* - XLarge (1024-1365): adapts to `PanelType.large` at this breakpoint
* - XXLarge (1366-1919): 176px fixed left margin, fluid width, 40px left/right
padding
* - XXXLarge (1920-up): 176px fixed left margin, fluid width, 40px left/right
padding
*/
PanelType[PanelType["extraLarge"] = 6] = "extraLarge";
/**
* Renders the Panel in `custom` size using `customWidth`, anchored to the far
side (right in LTR mode).
* - Has a fixed width provided by the `customWidth` prop
* - When screen width reaches the `customWidth` value it will behave like a
fluid width Panel
* taking up 100% of the viewport width
*/
PanelType[PanelType["custom"] = 7] = "custom";
/**
* Renders the Panel in `custom` size using `customWidth`, anchored to the near
side (left in LTR mode).
* - Has a fixed width provided by the `customWidth` prop
* - When screen width reaches the `customWidth` value it will behave like a
fluid width Panel
* taking up 100% of the viewport width
*/
PanelType[PanelType["customNear"] = 8] = "customNear";
})(PanelType = exports.PanelType || (exports.PanelType = {}));
//# sourceMappingURL=Panel.types.js.map
/***/ }),
/***/ 12591:
"use strict";

/***/ }),
/***/ 25069:
"use strict";

exports.PersonaBase = void 0;
var Persona_types_1 = __webpack_require__(14964);
size: Persona_types_1.PersonaSize.size48,
presence: Persona_types_1.PersonaPresence.none,
imageAlt: '',
showOverflowTooltip: true,
};
if (false) {}
}
/**
* Persona with no default styles.
styles.](https://github.com/microsoft/fluentui/wiki/Styling)
*/
exports.PersonaBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
/**
* Deprecation helper for getting text.
*/
var getText = function () {
return props.text || props.primaryText || '';
};
/**
* Renders various types of Text (primaryText, secondaryText, etc)
* based on the classNames passed
* @param elementClassNames - element className
* @param renderFunction - render function
* @param defaultRenderFunction - default render function
*/
var renderElement = function (elementClassNames, renderFunction,
defaultRenderFunction) {
var content = renderFunction && renderFunction(props,
defaultRenderFunction);
return content ? (React.createElement("div", { dir: "auto", className:
elementClassNames }, content)) : undefined;
};
/**
* using closure to wrap the default render behavior
* to make it independent of the type of text passed
* @param text - text to render
*/
var onRenderText = function (text, tooltip) {
if (tooltip === void 0) { tooltip = true; }
// return default render behavior for valid text or undefined
return text
? tooltip
? function () {
// default onRender behavior
return (React.createElement(Tooltip_1.TooltipHost, { content:
text, overflowMode: Tooltip_1.TooltipOverflowMode.Parent, directionalHint:
DirectionalHint_1.DirectionalHint.topLeftEdge }, text));
}
: function () { return React.createElement(React.Fragment, null,
text); }
: undefined;
};
var onInternalRenderPersonaCoin = function (providedCoinProps) {
return React.createElement(PersonaCoin_1.PersonaCoin, tslib_1.__assign({},
providedCoinProps));
};
// wrapping default render behavior based on various props properties
var onInternalRenderPrimaryText = onRenderText(getText(),
props.showOverflowTooltip);
var onInternalRenderSecondaryText = onRenderText(props.secondaryText,
var onInternalRenderTertiaryText = onRenderText(props.tertiaryText,
var onInternalRenderOptionalText = onRenderText(props.optionalText,
var hidePersonaDetails = props.hidePersonaDetails, _a =
props.onRenderOptionalText, onRenderOptionalText = _a === void 0 ?
onInternalRenderOptionalText : _a, _b = props.onRenderPrimaryText,
onRenderPrimaryText = _b === void 0 ? onInternalRenderPrimaryText : _b, _c =
props.onRenderSecondaryText, onRenderSecondaryText = _c === void 0 ?
onInternalRenderSecondaryText : _c, _d = props.onRenderTertiaryText,
onRenderTertiaryText = _d === void 0 ? onInternalRenderTertiaryText : _d, _e =
props.onRenderPersonaCoin, onRenderPersonaCoin = _e === void 0 ?
onInternalRenderPersonaCoin : _e;
var size = props.size;
// These properties are to be explicitly passed into PersonaCoin because they
are the only props directly used
var allowPhoneInitials = props.allowPhoneInitials, className = props.className,
coinProps = props.coinProps, showUnknownPersonaCoin = props.showUnknownPersonaCoin,
coinSize = props.coinSize, styles = props.styles, imageAlt = props.imageAlt,
imageInitials = props.imageInitials, imageShouldFadeIn = props.imageShouldFadeIn,
imageShouldStartVisible = props.imageShouldStartVisible, imageUrl = props.imageUrl,
initialsColor = props.initialsColor, initialsTextColor = props.initialsTextColor,
isOutOfOffice = props.isOutOfOffice, onPhotoLoadingStateChange =
props.onPhotoLoadingStateChange,
onRenderCoin = props.onRenderCoin, onRenderInitials = props.onRenderInitials,
presence = props.presence, presenceTitle = props.presenceTitle, presenceColors =
props.presenceColors, showInitialsUntilImageLoads =
props.showInitialsUntilImageLoads, showSecondaryText = props.showSecondaryText,
theme = props.theme;
var personaCoinProps = tslib_1.__assign({ allowPhoneInitials:
allowPhoneInitials, showUnknownPersonaCoin: showUnknownPersonaCoin, coinSize:
coinSize, imageAlt: imageAlt, imageInitials: imageInitials, imageShouldFadeIn:
imageShouldFadeIn, imageShouldStartVisible: imageShouldStartVisible, imageUrl:
imageUrl, initialsColor: initialsColor, initialsTextColor: initialsTextColor,
onPhotoLoadingStateChange: onPhotoLoadingStateChange, onRenderCoin: onRenderCoin,
onRenderInitials: onRenderInitials, presence: presence, presenceTitle:
presenceTitle, showInitialsUntilImageLoads: showInitialsUntilImageLoads, size:
size, text: getText(), isOutOfOffice: isOutOfOffice, presenceColors: presenceColors
}, coinProps);
theme: theme,
showSecondaryText: showSecondaryText,
presence: presence,
size: size,
});
var divProps = Utilities_1.getNativeProps(props, Utilities_1.divProperties);
var personaDetails = (React.createElement("div", { className:
classNames.details },
renderElement(classNames.primaryText, onRenderPrimaryText,
onInternalRenderPrimaryText),
renderElement(classNames.secondaryText, onRenderSecondaryText,
onInternalRenderSecondaryText),
renderElement(classNames.tertiaryText, onRenderTertiaryText,
onInternalRenderTertiaryText),
renderElement(classNames.optionalText, onRenderOptionalText,
onInternalRenderOptionalText),
props.children));
return (React.createElement("div", tslib_1.__assign({}, divProps, { ref:
mergedRootRef, className: classNames.root, style: coinSize ? { height: coinSize,
minWidth: coinSize } : undefined }),
onRenderPersonaCoin(personaCoinProps, onRenderPersonaCoin),
(!hidePersonaDetails ||
size === Persona_types_1.PersonaSize.size8 ||
size === Persona_types_1.PersonaSize.size10 ||
size === Persona_types_1.PersonaSize.tiny) &&
personaDetails
));
});
exports.PersonaBase.displayName = 'PersonaBase';
//# sourceMappingURL=Persona.base.js.map
/***/ }),
/***/ 20257:
"use strict";

exports.Persona = void 0;
var Persona_base_1 = __webpack_require__(25069);
var Persona_styles_1 = __webpack_require__(70964);
/**
* Personas are used for rendering an individual's avatar, presence and details.
* They are used within the PeoplePicker components.
*/
exports.Persona = Utilities_1.styled(Persona_base_1.PersonaBase,
Persona_styles_1.getStyles, undefined, {
scope: 'Persona',
});
//# sourceMappingURL=Persona.js.map
/***/ }),
/***/ 70964:
"use strict";

var PersonaConsts_1 = __webpack_require__(81266);
root: 'ms-Persona',
size8: 'ms-Persona--size8',
available: 'ms-Persona--online',
away: 'ms-Persona--away',
blocked: 'ms-Persona--blocked',
busy: 'ms-Persona--busy',
doNotDisturb: 'ms-Persona--donotdisturb',
offline: 'ms-Persona--offline',
details: 'ms-Persona-details',
primaryText: 'ms-Persona-primaryText',
secondaryText: 'ms-Persona-secondaryText',
tertiaryText: 'ms-Persona-tertiaryText',
optionalText: 'ms-Persona-optionalText',
textContent: 'ms-Persona-textContent',
};
var className = props.className, showSecondaryText = props.showSecondaryText,
theme = props.theme;
var size = PersonaConsts_1.sizeBoolean(props.size);
var presence = PersonaConsts_1.presenceBoolean(props.presence);
var showSecondaryTextDefaultHeight = '16px';
var sharedTextStyles = {
};
return {
root: [
classNames.root,
theme.fonts.medium,
{
height: PersonaConsts_1.personaSize.size48,
minWidth: PersonaConsts_1.personaSize.size48,
display: 'flex',
selectors: {
'.contextualHost': {
display: 'none',
},
},
},
size.isSize8 && [
classNames.size8,
{
},
],
// TODO: Deprecated size and needs to be removed in a future major
release.
size.isSize10 && [
classNames.size10,
{
},
],
release.
size.isSize16 && [
classNames.size16,
{
},
],
size.isSize24 && [
classNames.size24,
{
},
],
size.isSize24 &&
showSecondaryText && {
height: '36px',
},
release.
size.isSize28 && [
classNames.size28,
{
},
],
size.isSize28 &&
height: '32px',
},
size.isSize32 && [
classNames.size32,
{
},
],
size.isSize40 && [
classNames.size40,
{
},
],
size.isSize48 && classNames.size48,
size.isSize56 && [
classNames.size56,
{
},
],
size.isSize72 && [
classNames.size72,
{
},
],
size.isSize100 && [
classNames.size100,
{
},
],
size.isSize120 && [
classNames.size120,
{
},
],
/**
* Modifiers: presence
*/
presence.isAvailable && classNames.available,
presence.isAway && classNames.away,
presence.isBlocked && classNames.blocked,
presence.isBusy && classNames.busy,
presence.isDoNotDisturb && classNames.doNotDisturb,
presence.isOffline && classNames.offline,
className,
],
details: [
classNames.details,
{
minWidth: 0,
width: '100%',
textAlign: 'left',
display: 'flex',
justifyContent: 'space-around',
},
(size.isSize8 || size.isSize10) && {
paddingLeft: 17, // increased padding because we don't render a
coin at this size
},
(size.isSize24 || size.isSize28 || size.isSize32) && {
padding: '0 8px',
},
padding: '0 12px',
},
],
primaryText: [
classNames.primaryText,
Styling_1.noWrap,
{
selectors: {
':hover': {
},
},
},
height: showSecondaryTextDefaultHeight,
lineHeight: showSecondaryTextDefaultHeight,
},
lineHeight: PersonaConsts_1.personaSize.size8,
},
size.isSize16 && {
lineHeight: PersonaConsts_1.personaSize.size28,
},
(size.isSize24 || size.isSize28 || size.isSize32 || size.isSize40 ||
size.isSize48) &&
height: 18,
},
(size.isSize56 || size.isSize72 || size.isSize100 || size.isSize120) &&
{
fontSize: fonts.xLarge.fontSize,
},
height: 22,
},
],
secondaryText: [
classNames.secondaryText,
Styling_1.noWrap,
sharedTextStyles,
size.isSize28 || size.isSize32) && {
display: 'none',
},
display: 'block',
height: showSecondaryTextDefaultHeight,
lineHeight: showSecondaryTextDefaultHeight,
},
size.isSize24 &&
height: 18,
},
{
},
height: 18,
},
],
tertiaryText: [
classNames.tertiaryText,
Styling_1.noWrap,
sharedTextStyles,
{
display: 'none',
},
(size.isSize72 || size.isSize100 || size.isSize120) && {
display: 'block',
},
],
optionalText: [
classNames.optionalText,
Styling_1.noWrap,
sharedTextStyles,
{
display: 'none',
},
display: 'block',
},
],
textContent: [classNames.textContent, Styling_1.noWrap],
};
};
//# sourceMappingURL=Persona.styles.js.map
/***/ }),
/***/ 14964:
"use strict";

exports.PersonaInitialsColor = exports.PersonaPresence = exports.PersonaSize = void
0;
/**
* {@docCategory Persona}
*/
var PersonaSize;
(function (PersonaSize) {
/**
* Deprecated in favor of standardized numeric sizing.
* @deprecated Use `size8` instead.
*/
PersonaSize[PersonaSize["tiny"] = 0] = "tiny";
/**
*/
PersonaSize[PersonaSize["extraExtraSmall"] = 1] = "extraExtraSmall";
/**
*/
PersonaSize[PersonaSize["extraSmall"] = 2] = "extraSmall";
/**
*/
PersonaSize[PersonaSize["small"] = 3] = "small";
/**
*/
PersonaSize[PersonaSize["regular"] = 4] = "regular";
/**
*/
PersonaSize[PersonaSize["large"] = 5] = "large";
/**
*/
PersonaSize[PersonaSize["extraLarge"] = 6] = "extraLarge";
/**
* No `PersonaCoin` is rendered.
*/
PersonaSize[PersonaSize["size8"] = 17] = "size8";
/**
* No `PersonaCoin` is rendered. Deprecated to align with design
specifications.
*/
/**
* Renders a 16px `PersonaCoin`.
* @deprecated Deprecated due to not being in the design specification.
*/
/**
*/
/**
* @deprecated Deprecated due to not being in the design specification.
*/
/**
*/
/**
*/
/**
*/
/**
*/
/**
*/
/**
*/
/**
*/
})(PersonaSize = exports.PersonaSize || (exports.PersonaSize = {}));
/**
*/
var PersonaPresence;
(function (PersonaPresence) {
PersonaPresence[PersonaPresence["none"] = 0] = "none";
PersonaPresence[PersonaPresence["offline"] = 1] = "offline";
PersonaPresence[PersonaPresence["online"] = 2] = "online";
PersonaPresence[PersonaPresence["away"] = 3] = "away";
PersonaPresence[PersonaPresence["dnd"] = 4] = "dnd";
PersonaPresence[PersonaPresence["blocked"] = 5] = "blocked";
PersonaPresence[PersonaPresence["busy"] = 6] = "busy";
})(PersonaPresence = exports.PersonaPresence || (exports.PersonaPresence = {}));
/**
*/
var PersonaInitialsColor;
(function (PersonaInitialsColor) {
PersonaInitialsColor[PersonaInitialsColor["lightBlue"] = 0] = "lightBlue";
PersonaInitialsColor[PersonaInitialsColor["blue"] = 1] = "blue";
PersonaInitialsColor[PersonaInitialsColor["darkBlue"] = 2] = "darkBlue";
PersonaInitialsColor[PersonaInitialsColor["teal"] = 3] = "teal";
PersonaInitialsColor[PersonaInitialsColor["lightGreen"] = 4] = "lightGreen";
PersonaInitialsColor[PersonaInitialsColor["green"] = 5] = "green";
PersonaInitialsColor[PersonaInitialsColor["darkGreen"] = 6] = "darkGreen";
PersonaInitialsColor[PersonaInitialsColor["lightPink"] = 7] = "lightPink";
PersonaInitialsColor[PersonaInitialsColor["pink"] = 8] = "pink";
PersonaInitialsColor[PersonaInitialsColor["magenta"] = 9] = "magenta";
PersonaInitialsColor[PersonaInitialsColor["purple"] = 10] = "purple";
/**
* @deprecated `black` is a color that can result in offensive persona coins
with some initials combinations,
* so it can only be set with overrides. Will be removed in a future major
release.
*/
PersonaInitialsColor[PersonaInitialsColor["black"] = 11] = "black";
PersonaInitialsColor[PersonaInitialsColor["orange"] = 12] = "orange";
/**
* @deprecated `red` is a color that often has a special meaning, so it is
considered a reserved color and
* can only be set with overrides. Will be removed in a future major release.
*/
PersonaInitialsColor[PersonaInitialsColor["red"] = 13] = "red";
PersonaInitialsColor[PersonaInitialsColor["darkRed"] = 14] = "darkRed";
/**
* Transparent is not intended to be used with typical initials due to
accessibility issues.
* Its primary use is for overflow buttons, so it is considered a reserved
color and can only be set with overrides.
*/
PersonaInitialsColor[PersonaInitialsColor["transparent"] = 15] = "transparent";
PersonaInitialsColor[PersonaInitialsColor["violet"] = 16] = "violet";
PersonaInitialsColor[PersonaInitialsColor["lightRed"] = 17] = "lightRed";
PersonaInitialsColor[PersonaInitialsColor["gold"] = 18] = "gold";
PersonaInitialsColor[PersonaInitialsColor["burgundy"] = 19] = "burgundy";
PersonaInitialsColor[PersonaInitialsColor["warmGray"] = 20] = "warmGray";
PersonaInitialsColor[PersonaInitialsColor["coolGray"] = 21] = "coolGray";
/**
* `gray` is a color that can result in offensive persona coins with some
initials combinations,
* so it can only be set with overrides.
*/
PersonaInitialsColor[PersonaInitialsColor["gray"] = 22] = "gray";
PersonaInitialsColor[PersonaInitialsColor["cyan"] = 23] = "cyan";
PersonaInitialsColor[PersonaInitialsColor["rust"] = 24] = "rust";
})(PersonaInitialsColor = exports.PersonaInitialsColor ||
(exports.PersonaInitialsColor = {}));
//# sourceMappingURL=Persona.types.js.map
/***/ }),
/***/ 52598:
"use strict";

exports.PersonaCoinBase = void 0;
var PersonaInitialsColor_1 = __webpack_require__(26274);
// There can be many PersonaCoin rendered with different sizes.
cacheSize: 100,
});
var getInitialsStyles = Utilities_1.memoizeFunction(function (className,
initialsColor, initialsTextColor, text, primaryText, showUnknownPersonaCoin) {
return Styling_1.mergeStyles(className, !showUnknownPersonaCoin && {
backgroundColor: PersonaInitialsColor_1.getPersonaInitialsColor({ text:
text, initialsColor: initialsColor, primaryText: primaryText }),
color: initialsTextColor,
});
});
size: Persona_types_1.PersonaSize.size48,
presence: Persona_types_1.PersonaPresence.none,
imageAlt: '',
};
if (false) {}
}
function useImageLoadState(_a) {
var onPhotoLoadingStateChange = _a.onPhotoLoadingStateChange, imageUrl =
_a.imageUrl;
var _b = React.useState(Image_1.ImageLoadState.notLoaded), imageLoadState =
_b[0], setImageLoadstate = _b[1];
setImageLoadstate(Image_1.ImageLoadState.notLoaded);
}, [imageUrl]);
var onLoadingStateChange = function (loadState) {
setImageLoadstate(loadState);
onPhotoLoadingStateChange === null || onPhotoLoadingStateChange === void
0 ? void 0 : onPhotoLoadingStateChange(loadState);
};
return [imageLoadState, onLoadingStateChange];
}
/**
* PersonaCoin with no default styles.
* [Use the `getStyles` API to add your own
*/
exports.PersonaCoinBase = React.forwardRef(function (propsWithoutDefaults,
forwardedRef) {
var _a = useImageLoadState(props), imageLoadState = _a[0], onLoadingStateChange
= _a[1];
var renderCoin = getCoinRenderer(onLoadingStateChange);
var className = props.className, coinProps = props.coinProps,
showUnknownPersonaCoin = props.showUnknownPersonaCoin, coinSize = props.coinSize,
styles = props.styles, imageUrl = props.imageUrl, initialsColor =
props.initialsColor, initialsTextColor = props.initialsTextColor, isOutOfOffice =
props.isOutOfOffice,
_b = props.onRenderCoin,
onRenderCoin = _b === void 0 ? renderCoin : _b,
_c = props.onRenderPersonaCoin,
onRenderPersonaCoin = _c === void 0 ? onRenderCoin : _c, _d =
props.onRenderInitials, onRenderInitials = _d === void 0 ?
renderPersonaCoinInitials : _d, presence = props.presence, presenceTitle =
props.presenceTitle, presenceColors = props.presenceColors,
primaryText = props.primaryText, showInitialsUntilImageLoads =
props.showInitialsUntilImageLoads, text = props.text, theme = props.theme, size =
props.size;
var divCoinProps = Utilities_1.getNativeProps(coinProps || {},
var coinSizeStyle = coinSize ? { width: coinSize, height: coinSize } :
undefined;
var hideImage = showUnknownPersonaCoin;
var personaPresenceProps = {
coinSize: coinSize,
isOutOfOffice: isOutOfOffice,
presence: presence,
presenceTitle: presenceTitle,
presenceColors: presenceColors,
size: size,
theme: theme,
};
// Use getStyles from props, or fall back to getStyles from styles file.
theme: theme,
className: coinProps && coinProps.className ? coinProps.className :
className,
size: size,
coinSize: coinSize,
showUnknownPersonaCoin: showUnknownPersonaCoin,
});
var shouldRenderInitials = Boolean(imageLoadState !==
Image_1.ImageLoadState.loaded &&
((showInitialsUntilImageLoads && imageUrl) || !imageUrl || imageLoadState
=== Image_1.ImageLoadState.error || hideImage));
return (React.createElement("div", tslib_1.__assign({ role: "presentation" },
divProps, { className: classNames.coin, ref: forwardedRef }),
// Render PersonaCoin if size is not size8. size10 and tiny need to removed
after a deprecation cleanup.
size !== Persona_types_1.PersonaSize.size8 && size !==
Persona_types_1.PersonaSize.size10 && size !== Persona_types_1.PersonaSize.tiny ?
(React.createElement("div", tslib_1.__assign({ role: "presentation" },
divCoinProps, { className: classNames.imageArea, style: coinSizeStyle }),
shouldRenderInitials && (React.createElement("div", { className:
getInitialsStyles(classNames.initials, initialsColor, initialsTextColor, text,
primaryText, showUnknownPersonaCoin), style: coinSizeStyle, "aria-hidden":
"true" }, onRenderInitials(props, renderPersonaCoinInitials))),
!hideImage && onRenderPersonaCoin(props, renderCoin),
React.createElement(index_1.PersonaPresence, tslib_1.__assign({},
personaPresenceProps)))) : // Otherwise, render just PersonaPresence.
props.presence ? (React.createElement(index_1.PersonaPresence,
tslib_1.__assign({}, personaPresenceProps))) : (
// Just render Contact Icon if there isn't a Presence prop.
React.createElement(Icon_1.Icon, { iconName: "Contact", className:
classNames.size10WithoutPresenceIcon })),
props.children));
});
exports.PersonaCoinBase.displayName = 'PersonaCoinBase';
var getCoinRenderer = function (onLoadingStateChange) { return function (_a) {
var coinSize = _a.coinSize, styles = _a.styles, imageUrl = _a.imageUrl,
imageAlt = _a.imageAlt, imageShouldFadeIn = _a.imageShouldFadeIn,
imageShouldStartVisible = _a.imageShouldStartVisible, theme = _a.theme,
showUnknownPersonaCoin = _a.showUnknownPersonaCoin, _b = _a.size, size = _b ===
void 0 ? DEFAULT_PROPS.size : _b;
// Render the Image component only if an image URL is provided
if (!imageUrl) {
return null;
}
theme: theme,
size: size,
showUnknownPersonaCoin: showUnknownPersonaCoin,
});
var dimension = coinSize || PersonaConsts_1.sizeToPixels[size];
return (React.createElement(Image_1.Image, { className: classNames.image,
imageFit: Image_1.ImageFit.cover, src: imageUrl, width: dimension, height:
dimension, alt: imageAlt, shouldFadeIn: imageShouldFadeIn, shouldStartVisible:
imageShouldStartVisible, onLoadingStateChange: onLoadingStateChange }));
}; };
var renderPersonaCoinInitials = function (_a) {
var imageInitials = _a.imageInitials, allowPhoneInitials =
_a.allowPhoneInitials, showUnknownPersonaCoin = _a.showUnknownPersonaCoin, text =
_a.text,
primaryText = _a.primaryText, theme = _a.theme;
if (showUnknownPersonaCoin) {
return React.createElement(Icon_1.Icon, { iconName: "Help" });
}
imageInitials = imageInitials || Utilities_1.getInitials(text || primaryText ||
'', isRTL, allowPhoneInitials);
return imageInitials !== '' ? React.createElement("span", null,
imageInitials) : React.createElement(Icon_1.Icon, { iconName: "Contact" });
};
//# sourceMappingURL=PersonaCoin.base.js.map
/***/ }),
/***/ 81689:
"use strict";

exports.PersonaCoin = void 0;
var PersonaCoin_base_1 = __webpack_require__(52598);
var PersonaCoin_styles_1 = __webpack_require__(97291);
/**
* PersonaCoin is used to render an individual's avatar and presence.
*/
exports.PersonaCoin = Utilities_1.styled(PersonaCoin_base_1.PersonaCoinBase,
PersonaCoin_styles_1.getStyles, undefined, {
scope: 'PersonaCoin',
});
//# sourceMappingURL=PersonaCoin.js.map
/***/ }),
/***/ 97291:
"use strict";

coin: 'ms-Persona-coin',
imageArea: 'ms-Persona-imageArea',
image: 'ms-Persona-image',
initials: 'ms-Persona-initials',
};
var _a;
var className = props.className, theme = props.theme, coinSize =
props.coinSize;
// Static colors used when displaying 'unknown persona' coin
var unknownPersonaBackgroundColor = 'rgb(234, 234, 234)';
var unknownPersonaFontColor = 'rgb(168, 0, 0)';
var dimension = coinSize || (props.size &&
PersonaConsts_1.sizeToPixels[props.size]) || 48;
return {
coin: [
classNames.coin,
fonts.medium,
className,
],
size10WithoutPresenceIcon: {
fontSize: fonts.xSmall.fontSize,
top: '5px',
right: 'auto',
left: 0,
},
imageArea: [
classNames.imageArea,
{
flex: '0 0 auto',
height: dimension,
width: dimension,
},
dimension <= 10 && {
height: 0,
width: 0,
},
],
image: [
classNames.image,
{
marginRight: '10px',
top: 0,
left: 0,
width: '100%',
height: '100%',
border: 0,
perspective: '1px',
},
dimension <= 10 && {
height: 0,
width: 0,
},
dimension > 10 && {
height: dimension,
width: dimension,
},
],
initials: [
classNames.initials,
{
color: props.showUnknownPersonaCoin ? unknownPersonaFontColor :
palette.white,
// copying the logic for the dimensions; defaulted to 46 for size48
lineHeight: dimension === 48 ? 46 : dimension,
height: dimension,
tslib_1.__assign(tslib_1.__assign({ border: '1px solid WindowText' },
Styling_1.getHighContrastNoAdjustStyle()), { color: 'WindowText', boxSizing:
'border-box', backgroundColor: 'Window !important' }),
_a.i = {
},
_a),
},
props.showUnknownPersonaCoin && {
backgroundColor: unknownPersonaBackgroundColor,
},
dimension < 32 && {
},
dimension >= 32 &&
dimension < 40 && {
},
dimension >= 40 &&
dimension < 56 && {
},
dimension >= 56 &&
dimension < 72 && {
},
dimension >= 72 &&
dimension < 100 && {
fontSize: fonts.xxLarge.fontSize,
},
dimension >= 100 && {
fontSize: fonts.superLarge.fontSize,
},
],
};
};
//# sourceMappingURL=PersonaCoin.styles.js.map
/***/ }),
/***/ 38787:
"use strict";

/***/ }),
/***/ 81266:
"use strict";
var _a;
exports.presenceBoolean = exports.sizeToPixels = exports.sizeBoolean =
exports.personaPresenceSize = exports.personaSize = void 0;
// Persona Sizes
var personaSize;
(function (personaSize) {
personaSize.size8 = '20px';
// TODO: remove in a future major release as it's deprecated.
})(personaSize = exports.personaSize || (exports.personaSize = {}));
// Persona Presence Sizes
var personaPresenceSize;
(function (personaPresenceSize) {
personaPresenceSize.size6 = '6px';
/**
* @deprecated This is now unused
*/
personaPresenceSize.border = '2px';
})(personaPresenceSize = exports.personaPresenceSize ||
(exports.personaPresenceSize = {}));
// TODO: remove the deprecated parts in a future major release.
var sizeBoolean = function (size) { return ({
isSize8: size === Persona_types_1.PersonaSize.size8,
isSize10: size === Persona_types_1.PersonaSize.size10 || size ===
Persona_types_1.PersonaSize.tiny,
Persona_types_1.PersonaSize.extraExtraSmall,
Persona_types_1.PersonaSize.extraSmall,
Persona_types_1.PersonaSize.small,
Persona_types_1.PersonaSize.regular,
Persona_types_1.PersonaSize.large,
Persona_types_1.PersonaSize.extraLarge,
}); };
exports.sizeBoolean = sizeBoolean;
exports.sizeToPixels = (_a = {},
// Old deprecated sizes
_a[Persona_types_1.PersonaSize.tiny] = 10,
_a[Persona_types_1.PersonaSize.extraExtraSmall] = 24,
_a[Persona_types_1.PersonaSize.extraSmall] = 28,
_a[Persona_types_1.PersonaSize.small] = 40,
_a[Persona_types_1.PersonaSize.regular] = 48,
_a[Persona_types_1.PersonaSize.large] = 72,
_a[Persona_types_1.PersonaSize.extraLarge] = 100,
// New sizes
_a[Persona_types_1.PersonaSize.size8] = 8,
_a);
var presenceBoolean = function (presence) { return ({
isAvailable: presence === Persona_types_1.PersonaPresence.online,
isAway: presence === Persona_types_1.PersonaPresence.away,
isBlocked: presence === Persona_types_1.PersonaPresence.blocked,
isBusy: presence === Persona_types_1.PersonaPresence.busy,
isDoNotDisturb: presence === Persona_types_1.PersonaPresence.dnd,
isOffline: presence === Persona_types_1.PersonaPresence.offline,
}); };
exports.presenceBoolean = presenceBoolean;
//# sourceMappingURL=PersonaConsts.js.map
/***/ }),
/***/ 26274:
"use strict";

exports.getPersonaInitialsColor = exports.initialsColorPropToColorCode = void 0;
/**
* Following colors are considered reserved and can only be set with overrides, so
they are excluded from this set:
* - `gray` and `black` can result in offensive persona coins with some initials
combinations
* - `red` often has a special meaning
* - `transparent` is not intended to be used with typical initials due to
accessibility issues;
* its primary use is for Facepile overflow buttons.
*/
var COLOR_SWATCHES_LOOKUP = [
Persona_types_1.PersonaInitialsColor.lightBlue,
Persona_types_1.PersonaInitialsColor.blue,
Persona_types_1.PersonaInitialsColor.darkBlue,
Persona_types_1.PersonaInitialsColor.teal,
Persona_types_1.PersonaInitialsColor.green,
Persona_types_1.PersonaInitialsColor.darkGreen,
Persona_types_1.PersonaInitialsColor.lightPink,
Persona_types_1.PersonaInitialsColor.pink,
Persona_types_1.PersonaInitialsColor.magenta,
Persona_types_1.PersonaInitialsColor.purple,
Persona_types_1.PersonaInitialsColor.orange,
Persona_types_1.PersonaInitialsColor.lightRed,
Persona_types_1.PersonaInitialsColor.darkRed,
Persona_types_1.PersonaInitialsColor.violet,
Persona_types_1.PersonaInitialsColor.gold,
Persona_types_1.PersonaInitialsColor.burgundy,
Persona_types_1.PersonaInitialsColor.warmGray,
Persona_types_1.PersonaInitialsColor.cyan,
Persona_types_1.PersonaInitialsColor.rust,
Persona_types_1.PersonaInitialsColor.coolGray,
];
var COLOR_SWATCHES_NUM_ENTRIES = COLOR_SWATCHES_LOOKUP.length;
function getInitialsColorFromName(displayName) {
var color = Persona_types_1.PersonaInitialsColor.blue;
if (!displayName) {
return color;
}
var hashCode = 0;
for (var iLen = displayName.length - 1; iLen >= 0; iLen--) {
var ch = displayName.charCodeAt(iLen);
var shift = iLen % 8;
// eslint-disable-next-line no-bitwise
hashCode ^= (ch << shift) + (ch >> (8 - shift));
}
color = COLOR_SWATCHES_LOOKUP[hashCode % COLOR_SWATCHES_NUM_ENTRIES];
return color;
}
function personaInitialsColorToHexCode(personaInitialsColor) {
switch (personaInitialsColor) {
case Persona_types_1.PersonaInitialsColor.lightBlue:
return '#4F6BED';
case Persona_types_1.PersonaInitialsColor.blue:
return '#0078D4';
case Persona_types_1.PersonaInitialsColor.darkBlue:
return '#004E8C';
case Persona_types_1.PersonaInitialsColor.teal:
return '#038387';
case Persona_types_1.PersonaInitialsColor.lightGreen:
case Persona_types_1.PersonaInitialsColor.green:
return '#498205';
case Persona_types_1.PersonaInitialsColor.darkGreen:
return '#0B6A0B';
case Persona_types_1.PersonaInitialsColor.lightPink:
return '#C239B3';
case Persona_types_1.PersonaInitialsColor.pink:
return '#E3008C';
case Persona_types_1.PersonaInitialsColor.magenta:
return '#881798';
case Persona_types_1.PersonaInitialsColor.purple:
return '#5C2E91';
case Persona_types_1.PersonaInitialsColor.orange:
return '#CA5010';
case Persona_types_1.PersonaInitialsColor.red:
return '#EE1111';
case Persona_types_1.PersonaInitialsColor.lightRed:
return '#D13438';
case Persona_types_1.PersonaInitialsColor.darkRed:
return '#A4262C';
case Persona_types_1.PersonaInitialsColor.transparent:
return 'transparent';
case Persona_types_1.PersonaInitialsColor.violet:
return '#8764B8';
case Persona_types_1.PersonaInitialsColor.gold:
return '#986F0B';
case Persona_types_1.PersonaInitialsColor.burgundy:
return '#750B1C';
case Persona_types_1.PersonaInitialsColor.warmGray:
return '#7A7574';
case Persona_types_1.PersonaInitialsColor.cyan:
return '#005B70';
case Persona_types_1.PersonaInitialsColor.rust:
return '#8E562E';
case Persona_types_1.PersonaInitialsColor.coolGray:
return '#69797E';
case Persona_types_1.PersonaInitialsColor.black:
return '#1D1D1D';
case Persona_types_1.PersonaInitialsColor.gray:
return '#393939';
}
}
/** @deprecated Use `getPersonaInitialsColor` */
function initialsColorPropToColorCode(props) {
return getPersonaInitialsColor(props);
}
exports.initialsColorPropToColorCode = initialsColorPropToColorCode;
/**
* Gets the hex color string (prefixed with #) for the given persona props.
* This is the logic used internally by the Persona control.
* @param props - Current persona props
* @returns Hex color string prefixed with #
*/
function getPersonaInitialsColor(props) {
var primaryText = props.primaryText, text = props.text;
var initialsColor = props.initialsColor;
var initialsColorCode;
if (typeof initialsColor === 'string') {
initialsColorCode = initialsColor;
}
else {
initialsColor = initialsColor !== undefined ? initialsColor :
getInitialsColorFromName(text || primaryText);
initialsColorCode = personaInitialsColorToHexCode(initialsColor);
}
return initialsColorCode;
}
exports.getPersonaInitialsColor = getPersonaInitialsColor;
//# sourceMappingURL=PersonaInitialsColor.js.map
/***/ }),
/***/ 87022:
"use strict";

exports.PersonaPresenceBase = void 0;
var coinSizeFontScaleFactor = 6;
var coinSizePresenceScaleFactor = 3;
var presenceMaxSize = 40;
var presenceFontMaxSize = 20;
// There can be many PersonaPresence rendered with different sizes.
cacheSize: 100,
});
/**
* PersonaPresence with no default styles.
* [Use the `getStyles` API to add your own
*/
exports.PersonaPresenceBase = React.forwardRef(function (props, forwardedRef) {
var coinSize = props.coinSize, isOutOfOffice = props.isOutOfOffice, styles =
props.styles, // Use getStyles from props.
presence = props.presence, theme = props.theme, presenceTitle =
props.presenceTitle, presenceColors = props.presenceColors;
// Render Presence Icon if Persona is above size 32.
var renderIcon = !(size.isSize8 || size.isSize10 || size.isSize16 ||
size.isSize24 || size.isSize28 || size.isSize32) &&
(coinSize ? coinSize > 32 : true);
var presenceHeightWidth = coinSize
? coinSize / coinSizePresenceScaleFactor < presenceMaxSize
? coinSize / coinSizePresenceScaleFactor + 'px'
: presenceMaxSize + 'px'
: '';
var presenceFontSize = coinSize
? coinSize / coinSizeFontScaleFactor < presenceFontMaxSize
? coinSize / coinSizeFontScaleFactor + 'px'
: presenceFontMaxSize + 'px'
: '';
var coinSizeWithPresenceIconStyle = coinSize
? { fontSize: presenceFontSize, lineHeight: presenceHeightWidth }
: undefined;
var coinSizeWithPresenceStyle = coinSize ? { width: presenceHeightWidth,
height: presenceHeightWidth } : undefined;
// Use getStyles from props, or fall back to getStyles from styles file.
theme: theme,
presence: presence,
size: props.size,
isOutOfOffice: isOutOfOffice,
presenceColors: presenceColors,
});
if (presence === Persona_types_1.PersonaPresence.none) {
return null;
}
return (React.createElement("div", { role: "presentation", className:
classNames.presence, style: coinSizeWithPresenceStyle, title: presenceTitle, ref:
mergedRootRef }, renderIcon && (React.createElement(Icon_1.Icon, { className:
classNames.presenceIcon, iconName: determineIcon(props.presence,
props.isOutOfOffice), style: coinSizeWithPresenceIconStyle }))));
});
exports.PersonaPresenceBase.displayName = 'PersonaPresenceBase';
function determineIcon(presence, isOutOfOffice) {
if (!presence) {
return undefined;
}
var oofIcon = 'SkypeArrow';
switch (Persona_types_1.PersonaPresence[presence]) {
case 'online':
return 'SkypeCheck';
case 'away':
return isOutOfOffice ? oofIcon : 'SkypeClock';
case 'dnd':
return 'SkypeMinus';
case 'offline':
return isOutOfOffice ? oofIcon : '';
}
return '';
}
//# sourceMappingURL=PersonaPresence.base.js.map
/***/ }),
/***/ 4648:
"use strict";

exports.PersonaPresence = void 0;
var PersonaPresence_base_1 = __webpack_require__(87022);
var PersonaPresence_styles_1 = __webpack_require__(85878);
/**
* PersonaPresence is used to render an individual's presence.
*/
exports.PersonaPresence =
Utilities_1.styled(PersonaPresence_base_1.PersonaPresenceBase,
PersonaPresence_styles_1.getStyles, undefined, { scope: 'PersonaPresence' });
//# sourceMappingURL=PersonaPresence.js.map
/***/ }),
/***/ 85878:
"use strict";

presence: 'ms-Persona-presence',
presenceIcon: 'ms-Persona-presenceIcon',
};
var _a, _b, _c, _d, _e, _f;
var theme = props.theme, presenceColors = props.presenceColors;
var presence = PersonaConsts_1.presenceBoolean(props.presence);
// Presence colors
var presenceColorAvailable = (presenceColors && presenceColors.available) ||
'#6BB700';
var presenceColorAway = (presenceColors && presenceColors.away) || '#FFAA44';
var presenceColorBusy = (presenceColors && presenceColors.busy) || '#C43148';
var presenceColorDnd = (presenceColors && presenceColors.dnd) || '#C50F1F';
var presenceColorOffline = (presenceColors && presenceColors.offline) ||
'#8A8886';
var presenceColorOof = (presenceColors && presenceColors.oof) || '#B4009E';
var presenceColorBackground = (presenceColors && presenceColors.background) ||
semanticColors.bodyBackground;
var isOpenCirclePresence = presence.isOffline ||
(props.isOutOfOffice && (presence.isAvailable || presence.isBusy ||
presence.isAway || presence.isDoNotDisturb));
var borderSizeForSmallPersonas = '1px';
var borderSizeForLargePersonas = '2px';
var borderSize = size.isSize72 || size.isSize100 ? borderSizeForLargePersonas :
borderSizeForSmallPersonas;
return {
presence: [
classNames.presence,
tslib_1.__assign(tslib_1.__assign({ position: 'absolute', height:
PersonaConsts_1.personaPresenceSize.size12, width:
PersonaConsts_1.personaPresenceSize.size12, borderRadius: '50%', top: 'auto',
right: '-2px', bottom: '-2px', border: "2px solid " + presenceColorBackground,
textAlign: 'center', boxSizing: 'content-box', backgroundClip: 'border-box' },
Styling_1.getHighContrastNoAdjustStyle()), { selectors: (_a = {},
},
_a) }),
right: 'auto',
top: '7px',
left: 0,
border: 0,
top: '9px',
},
_b),
},
size.isSize32) &&
makeSizeStyle(PersonaConsts_1.personaPresenceSize.size8),
(size.isSize40 || size.isSize48) &&
size.isSize16 && {
height: PersonaConsts_1.personaPresenceSize.size6,
width: PersonaConsts_1.personaPresenceSize.size6,
borderWidth: '1.5px',
},
size.isSize56 &&
size.isSize72 &&
size.isSize100 &&
size.isSize120 &&
presence.isAvailable && {
backgroundColor: presenceColorAvailable,
backgroundColor('Highlight'),
_c),
},
presence.isAway && backgroundColor(presenceColorAway),
presence.isBlocked && [
{
selectors: (_d = {
// Only show :after at larger sizes
':after': size.isSize40 || size.isSize48 ||
size.isSize72 || size.isSize100
? {
content: '""',
width: '100%',
height: borderSize,
backgroundColor: presenceColorBusy,
transform: 'translateY(-50%) rotate(-45deg)',
top: '50%',
left: 0,
}
: undefined
},
selectors: {
':after': {
width: "calc(100% - 4px)",
left: '2px',
},
},
},
_d),
},
],
presence.isBusy && backgroundColor(presenceColorBusy),
presence.isDoNotDisturb && backgroundColor(presenceColorDnd),
presence.isOffline && backgroundColor(presenceColorOffline),
(isOpenCirclePresence || presence.isBlocked) && [
{
backgroundColor: presenceColorBackground,
selectors: (_e = {
':before': {
content: '""',
width: '100%',
height: '100%',
top: 0,
left: 0,
border: borderSize + " solid " + presenceColorBusy,
}
},
selectors: {
':before': {
width: "calc(100% - 2px)",
height: "calc(100% - 2px)",
top: '1px',
left: '1px',
},
},
},
_e),
},
],
isOpenCirclePresence && presence.isAvailable &&
makeBeforeBorderStyle(borderSize, presenceColorAvailable),
isOpenCirclePresence && presence.isBusy &&
makeBeforeBorderStyle(borderSize, presenceColorBusy),
isOpenCirclePresence && presence.isAway &&
makeBeforeBorderStyle(borderSize, presenceColorOof),
isOpenCirclePresence && presence.isDoNotDisturb &&
makeBeforeBorderStyle(borderSize, presenceColorDnd),
isOpenCirclePresence && presence.isOffline &&
makeBeforeBorderStyle(borderSize, presenceColorOffline),
isOpenCirclePresence &&
presence.isOffline &&
props.isOutOfOffice &&
makeBeforeBorderStyle(borderSize, presenceColorOof),
],
presenceIcon: [
classNames.presenceIcon,
{
color: presenceColorBackground,
fontSize: '6px',
lineHeight: PersonaConsts_1.personaPresenceSize.size12,
color: 'Window',
},
_f),
},
size.isSize56 && {
fontSize: '8px',
},
size.isSize72 && {
},
size.isSize100 && {
},
size.isSize120 && {
},
presence.isAway && {
left: isOpenCirclePresence ? undefined : '1px',
},
isOpenCirclePresence && presence.isAvailable &&
makeOpenCircleIconStyle(presenceColorAvailable),
isOpenCirclePresence && presence.isBusy &&
makeOpenCircleIconStyle(presenceColorBusy),
isOpenCirclePresence && presence.isAway &&
makeOpenCircleIconStyle(presenceColorOof),
isOpenCirclePresence && presence.isDoNotDisturb &&
makeOpenCircleIconStyle(presenceColorDnd),
isOpenCirclePresence && presence.isOffline &&
makeOpenCircleIconStyle(presenceColorOffline),
isOpenCirclePresence && presence.isOffline && props.isOutOfOffice &&
makeOpenCircleIconStyle(presenceColorOof),
],
};
};
function makeOpenCircleIconStyle(color) {
return {
color: color,
borderColor: color,
};
}
function makeBeforeBorderStyle(borderSize, color) {
return {
selectors: {
':before': {
border: borderSize + " solid " + color,
},
},
};
}
function makeSizeStyle(size) {
return {
height: size,
width: size,
};
}
function backgroundColor(color) {
return { backgroundColor: color };
}
//# sourceMappingURL=PersonaPresence.styles.js.map
/***/ }),
/***/ 45140:
"use strict";

/***/ }),
/***/ 83320:
"use strict";

exports.getPersonaInitialsColor = void 0;
// Exporting in case someone would like to track the current color of a persona
var PersonaInitialsColor_1 = __webpack_require__(26274);
Object.defineProperty(exports, "getPersonaInitialsColor", ({ enumerable: true, get:
function () { return PersonaInitialsColor_1.getPersonaInitialsColor; } }));
/***/ }),
/***/ 79101:
"use strict";

exports.PivotBase = void 0;
var useOverflow_1 = __webpack_require__(97211);
var ContextualMenu_types_1 = __webpack_require__(54177);
var PivotItem_1 = __webpack_require__(67723);
var COMPONENT_NAME = 'Pivot';
var getTabId = function (props, pivotId, itemKey, index) {
if (props.getTabId) {
return props.getTabId(itemKey, index);
}
return pivotId + ("-Tab" + index);
};
// Gets the set of PivotLinks as array of IPivotItemProps
// The set of Links is determined by child components of type PivotItem
var getLinkItems = function (props, pivotId) {
var result = {
links: [],
keyToIndexMapping: {},
keyToTabIdMapping: {},
};
React.Children.forEach(React.Children.toArray(props.children), function (child,
index) {
if (isPivotItem(child)) {
var _a = child.props, linkText = _a.linkText, pivotItemProps =
tslib_1.__rest(_a, ["linkText"]);
var itemKey = child.props.itemKey || index.toString();
result.links.push(tslib_1.__assign(tslib_1.__assign({ headerText:
linkText }, pivotItemProps), { itemKey: itemKey }));
result.keyToIndexMapping[itemKey] = index;
result.keyToTabIdMapping[itemKey] = getTabId(props, pivotId, itemKey,
index);
}
else if (child) {
utilities_1.warn('The children of a Pivot component must be of type
PivotItem to be rendered.');
}
});
return result;
};
var isPivotItem = function (item) {
var _a;
return React.isValidElement(item) && ((_a = item.type) === null || _a === void
0 ? void 0 : _a.name) === PivotItem_1.PivotItem.name;
};
exports.PivotBase = React.forwardRef(function (props, ref) {
var focusZoneRef = React.useRef(null);
var overflowMenuButtonComponentRef = React.useRef(null);
var pivotId = react_hooks_1.useId('Pivot');
var _a = react_hooks_1.useControllableValue(props.selectedKey,
props.defaultSelectedKey), selectedKey = _a[0], setSelectedKey = _a[1];
var componentRef = props.componentRef, theme = props.theme, linkSize =
props.linkSize, linkFormat = props.linkFormat, overflowBehavior =
props.overflowBehavior, overflowAriaLabel = props.overflowAriaLabel, focusZoneProps
= props.focusZoneProps;
var classNames;
var nameProps = {
'aria-label': props['aria-label'],
'aria-labelledby': props['aria-labelledby'],
};
var divProps = utilities_1.getNativeProps(props, utilities_1.divProperties, [
'aria-label',
'aria-labelledby',
]);
var linkCollection = getLinkItems(props, pivotId);
var _a;
(_a = focusZoneRef.current) === null || _a === void 0 ? void 0 :
_a.focus();
},
}); });
var renderLinkContent = function (link) {
if (!link) {
return null;
}
var itemCount = link.itemCount, itemIcon = link.itemIcon, headerText =
link.headerText;
return (React.createElement("span", { className: classNames.linkContent },
itemIcon !== undefined && (React.createElement("span", { className:
classNames.icon },
React.createElement(Icon_1.Icon, { iconName: itemIcon }))),
headerText !== undefined && React.createElement("span", { className:
classNames.text },
" ",
link.headerText),
itemCount !== undefined && React.createElement("span", { className:
classNames.count },
" (",
itemCount,
")")));
};
var renderPivotLink = function (renderLinkCollection, link,
renderPivotLinkSelectedKey, className) {
var itemKey = link.itemKey, headerButtonProps = link.headerButtonProps,
onRenderItemLink = link.onRenderItemLink;
var tabId = renderLinkCollection.keyToTabIdMapping[itemKey];
var linkContent;
var isSelected = renderPivotLinkSelectedKey === itemKey;
if (onRenderItemLink) {
linkContent = onRenderItemLink(link, renderLinkContent);
}
else {
linkContent = renderLinkContent(link);
}
var contentString = link.headerText || '';
contentString += link.itemCount ? ' (' + link.itemCount + ')' : '';
// Adding space supplementary for icon
contentString += link.itemIcon ? ' xx' : '';
var itemSemantics = link.role && link.role !== 'tab'
? {
role: link.role,
}
: {
role: 'tab',
'aria-selected': isSelected,
};
return (React.createElement(Button_1.CommandButton, tslib_1.__assign({},
headerButtonProps, itemSemantics, { id: tabId, key: itemKey, className:
utilities_1.css(className, isSelected && classNames.linkIsSelected),
onClick: function (ev) { return onLinkClick(itemKey, ev); },
onKeyDown: function (ev) { return onKeyDown(itemKey, ev); }, "aria-
label": link.ariaLabel, name: link.headerText, keytipProps: link.keytipProps,
"data-content": contentString }), linkContent));
};
var onLinkClick = function (itemKey, ev) {
updateSelectedItem(itemKey, ev);
};
var onKeyDown = function (itemKey, ev) {
if (ev.which === utilities_1.KeyCodes.enter) {
updateSelectedItem(itemKey);
}
};
var updateSelectedItem = function (itemKey, ev) {
var _a;
setSelectedKey(itemKey);
linkCollection = getLinkItems(props, pivotId);
if (props.onLinkClick && linkCollection.keyToIndexMapping[itemKey] >= 0) {
var selectedIndex = linkCollection.keyToIndexMapping[itemKey];
var item = React.Children.toArray(props.children)[selectedIndex];
if (isPivotItem(item)) {
props.onLinkClick(item, ev);
}
}
(_a = overflowMenuButtonComponentRef.current) === null || _a === void 0 ?
void 0 : _a.dismissMenu();
};
var renderPivotItem = function (itemKey, isActive) {
if (props.headersOnly || !itemKey) {
return null;
}
var index = linkCollection.keyToIndexMapping[itemKey];
var selectedTabId = linkCollection.keyToTabIdMapping[itemKey];
return (React.createElement("div", { role: "tabpanel", hidden: !isActive,
key: itemKey, "aria-hidden": !isActive, "aria-labelledby": selectedTabId,
className: classNames.itemContainer }, React.Children.toArray(props.children)
[index]));
};
var isKeyValid = function (itemKey) {
return itemKey === null || (itemKey !== undefined &&
linkCollection.keyToIndexMapping[itemKey] !== undefined);
};
var getSelectedKey = function () {
if (isKeyValid(selectedKey)) {
return selectedKey;
}
if (linkCollection.links.length) {
return linkCollection.links[0].itemKey;
}
return undefined;
};
classNames = getClassNames(props.styles, {
theme: theme,
linkSize: linkSize,
linkFormat: linkFormat,
});
var renderedSelectedKey = getSelectedKey();
var renderedSelectedIndex = renderedSelectedKey ?
linkCollection.keyToIndexMapping[renderedSelectedKey] : 0;
var items = linkCollection.links.map(function (l) {
return renderPivotLink(linkCollection, l, renderedSelectedKey,
classNames.link);
});
// The overflow menu starts empty and items[] is updated as the overflow items
change
var overflowMenuProps = React.useMemo(function () { return ({
items: [],
alignTargetEdge: true,
directionalHint: ContextualMenu_types_1.DirectionalHint.bottomRightEdge,
}); }, []);
var overflowMenuButtonRef = useOverflow_1.useOverflow({
onOverflowItemsChanged: function (overflowIndex, elements) {
// Set data-is-overflowing on each item
elements.forEach(function (_a) {
var ele = _a.ele, isOverflowing = _a.isOverflowing;
return (ele.dataset.isOverflowing = "" + isOverflowing);
});
// Update the menu items
overflowMenuProps.items = linkCollection.links
.slice(overflowIndex)
.filter(function (link) { return link.itemKey !==
renderedSelectedKey; })
.map(function (link, index) {
link.role = 'menuitem';
return {
key: link.itemKey || "" + (overflowIndex + index),
onRender: function () { return renderPivotLink(linkCollection,
link, renderedSelectedKey, classNames.linkInMenu); },
};
});
},
rtl: utilities_1.getRTL(theme),
pinnedIndex: renderedSelectedIndex,
}).menuButtonRef;
return (React.createElement("div", tslib_1.__assign({ ref: ref }, divProps),
React.createElement(FocusZone_1.FocusZone, tslib_1.__assign({ componentRef:
focusZoneRef, role: "tablist" }, nameProps, { direction:
FocusZone_1.FocusZoneDirection.horizontal }, focusZoneProps, { className:
utilities_1.css(classNames.root, focusZoneProps === null || focusZoneProps === void
0 ? void 0 : focusZoneProps.className) }),
items,
overflowBehavior === 'menu' &&
(React.createElement(Button_1.CommandButton, { className:
utilities_1.css(classNames.link, classNames.overflowMenuButton), elementRef:
overflowMenuButtonRef, componentRef: overflowMenuButtonComponentRef, menuProps:
overflowMenuProps, menuIconProps: { iconName: 'More', style: { color:
'inherit' } }, ariaLabel: overflowAriaLabel }))),
renderedSelectedKey &&
linkCollection.links.map(function (link) {
return (link.alwaysRender === true || renderedSelectedKey ===
link.itemKey) &&
renderPivotItem(link.itemKey, renderedSelectedKey ===
link.itemKey);
})));
});
exports.PivotBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=Pivot.base.js.map
/***/ }),
/***/ 70711:
"use strict";

exports.Pivot = void 0;
var Pivot_base_1 = __webpack_require__(79101);
var Pivot_styles_1 = __webpack_require__(83027);
/**
* The Pivot control and related tabs pattern are used for navigating frequently
accessed,
* distinct content categories. Pivots allow for navigation between two or more
content
* views and relies on text headers to articulate the different sections of
content.
*/
exports.Pivot = utilities_1.styled(Pivot_base_1.PivotBase,
Pivot_styles_1.getStyles, undefined, {
scope: 'Pivot',
});
//# sourceMappingURL=Pivot.js.map
/***/ }),
/***/ 83027:
"use strict";

count: 'ms-Pivot-count',
icon: 'ms-Pivot-icon',
linkIsSelected: 'is-selected',
link: 'ms-Pivot-link',
linkContent: 'ms-Pivot-linkContent',
root: 'ms-Pivot',
rootIsLarge: 'ms-Pivot--large',
rootIsTabs: 'ms-Pivot--tabs',
text: 'ms-Pivot-text',
linkInMenu: 'ms-Pivot-linkInMenu',
overflowMenuButton: 'ms-Pivot-overflowMenuButton',
};
var getLinkStyles = function (props, classNames, isLinkInOverflowMenu) {
var _a, _b, _c;
if (isLinkInOverflowMenu === void 0) { isLinkInOverflowMenu = false; }
var linkSize = props.linkSize, linkFormat = props.linkFormat;
var _d = props.theme, semanticColors = _d.semanticColors, fonts = _d.fonts;
var rootIsLarge = linkSize === 'large';
var rootIsTabs = linkFormat === 'tabs';
return [
fonts.medium,
{
color: semanticColors.actionLink,
padding: '0 8px',
border: 0,
borderRadius: 0,
selectors: {
':hover': {
backgroundColor: semanticColors.buttonBackgroundHovered,
cursor: 'pointer',
},
':active': {
backgroundColor: semanticColors.buttonBackgroundPressed,
},
':focus': {
outline: 'none',
},
},
},
!isLinkInOverflowMenu && [
{
lineHeight: 44,
height: 44,
marginRight: 8,
_a["." + utilities_1.IsFocusVisibleClassName + " &:focus"] = {
outline: "1px solid " + semanticColors.focusBorder,
},
_a["." + utilities_1.IsFocusVisibleClassName + "
&:focus:after"] = {
content: 'attr(data-content)',
border: 0,
},
_a[':before'] = {
bottom: 0,
content: '""',
height: 2,
left: 8,
right: 8,
transition: "left " +
style_utilities_1.AnimationVariables.durationValue2 + " " +
style_utilities_1.AnimationVariables.easeFunction2 + ",\n
right " + style_utilities_1.AnimationVariables.durationValue2 + " " +
style_utilities_1.AnimationVariables.easeFunction2,
},
_a[':after'] = {
color: 'transparent',
content: 'attr(data-content)',
display: 'block',
fontWeight: style_utilities_1.FontWeights.bold,
height: 1,
overflow: 'hidden',
},
_a),
},
rootIsLarge && {
},
rootIsTabs && [
{
marginRight: 0,
height: 44,
lineHeight: 44,
backgroundColor: semanticColors.buttonBackground,
padding: '0 10px',
selectors: (_b = {
':focus': {
}
},
_b["." + utilities_1.IsFocusVisibleClassName + "
&:focus::before"] = {
height: 'auto',
transition: 'none',
},
_b['&:hover, &:focus'] = {
color: semanticColors.buttonTextCheckedHovered,
},
_b['&:active, &:hover'] = {
color: semanticColors.primaryButtonText,
backgroundColor:
semanticColors.primaryButtonBackground,
},
_b["&." + classNames.linkIsSelected] = {
backgroundColor:
semanticColors.primaryButtonBackground,
selectors: (_c = {
':before': {
transition: 'none',
top: 0,
left: 0,
right: 0,
bottom: 0,
content: '""',
height: 0,
},
':hover': {
backgroundColor:
semanticColors.primaryButtonBackgroundHovered,
},
'&:active': {
backgroundColor:
semanticColors.primaryButtonBackgroundPressed,
}
},
_c[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ fontWeight: style_utilities_1.FontWeights.semibold, color:
'HighlightText', background: 'Highlight' },
_c),
},
_b),
},
],
],
];
};
var _a, _b, _c, _d;
var className = props.className, linkSize = props.linkSize, linkFormat =
props.linkFormat, theme = props.theme;
var classNames = style_utilities_1.getGlobalClassNames(globalClassNames,
theme);
var rootIsLarge = linkSize === 'large';
var rootIsTabs = linkFormat === 'tabs';
return {
root: [
classNames.root,
fonts.medium,
{
},
rootIsLarge && classNames.rootIsLarge,
rootIsTabs && classNames.rootIsTabs,
className,
],
itemContainer: {
selectors: {
'&[hidden]': {
display: 'none',
},
},
},
link: tslib_1.__spreadArray(tslib_1.__spreadArray([
classNames.link
], getLinkStyles(props, classNames)), [
(_a = {},
_a["&[data-is-overflowing='true']"] = {
display: 'none',
},
_a),
]),
overflowMenuButton: [
classNames.overflowMenuButton,
(_b = {
right: 0
},
_b["." + classNames.link + "[data-is-overflowing='true'] ~ &"] = {
},
_b),
],
linkInMenu: tslib_1.__spreadArray(tslib_1.__spreadArray([
classNames.linkInMenu
], getLinkStyles(props, classNames, true)), [
{
textAlign: 'left',
width: '100%',
height: 36,
lineHeight: 36,
},
]),
linkIsSelected: [
classNames.link,
classNames.linkIsSelected,
{
selectors: (_c = {
':before': {
backgroundColor: semanticColors.inputBackgroundChecked,
},
_d),
},
':hover::before': {
left: 0,
right: 0,
}
},
color: 'Highlight',
},
_c),
},
],
linkContent: [
classNames.linkContent,
{
flex: '0 1 100%',
selectors: {
'& > * ': {
marginLeft: 4,
},
'& > *:first-child': {
marginLeft: 0,
},
},
},
],
text: [
classNames.text,
{
},
],
count: [
classNames.count,
{
},
],
icon: classNames.icon,
};
};
//# sourceMappingURL=Pivot.styles.js.map
/***/ }),
/***/ 51696:
"use strict";

exports.PivotLinkSize = exports.PivotLinkFormat = void 0;
/**
* {@docCategory Pivot}
* @deprecated Use strings 'links' or 'tabs' instead of this enum
*/
var PivotLinkFormat;
(function (PivotLinkFormat) {
/**
* Display Pivot Links as links
*/
PivotLinkFormat["links"] = "links";
/**
* Display Pivot Links as Tabs
*/
PivotLinkFormat["tabs"] = "tabs";
})(PivotLinkFormat = exports.PivotLinkFormat || (exports.PivotLinkFormat = {}));
/**
* {@docCategory Pivot}
* @deprecated Use strings 'normal' or 'large' instead of this enum
*/
var PivotLinkSize;
(function (PivotLinkSize) {
/**
* Display Link using normal font size
*/
PivotLinkSize["normal"] = "normal";
/**
* Display links using large font size
*/
PivotLinkSize["large"] = "large";
})(PivotLinkSize = exports.PivotLinkSize || (exports.PivotLinkSize = {}));
//# sourceMappingURL=Pivot.types.js.map
/***/ }),
/***/ 67723:
"use strict";

exports.PivotItem = void 0;
var COMPONENT_NAME = 'PivotItem';
var PivotItem = /** @class */ (function (_super) {
tslib_1.__extends(PivotItem, _super);
function PivotItem(props) {
utilities_1.warnDeprecations(COMPONENT_NAME, props, {
linkText: 'headerText',
});
return _this;
}
PivotItem.prototype.render = function () {
return React.createElement("div", tslib_1.__assign({},
utilities_1.getNativeProps(this.props, utilities_1.divProperties)),
this.props.children);
};
return PivotItem;
exports.PivotItem = PivotItem;
//# sourceMappingURL=PivotItem.js.map
/***/ }),
/***/ 38613:
"use strict";

//# sourceMappingURL=PivotItem.types.js.map
/***/ }),
/***/ 79094:
"use strict";

exports.PivotItem = void 0;
var PivotItem_1 = __webpack_require__(67723);
Object.defineProperty(exports, "PivotItem", ({ enumerable: true, get: function () {
return PivotItem_1.PivotItem; } }));
/***/ }),
/***/ 18972:
"use strict";

exports.Popup = void 0;
function useScrollbarAsync(props, root) {
var _a = React.useState(false), needsVerticalScrollBarState = _a[0],
setNeedsVerticalScrollBar = _a[1];
var _a;
// If overflowY is overridden, don't waste time calculating whether the
scrollbar is necessary.
if (props.style && props.style.overflowY) {
return;
}
var needsVerticalScrollBar = false;
if (root && root.current && ((_a = root.current) === null || _a ===
void 0 ? void 0 : _a.firstElementChild)) {
// ClientHeight returns the client height of an element rounded to
an
// integer. On some browsers at different zoom levels this rounding
// can generate different results for the root container and child
even
// though they are the same height. This causes us to show a scroll
bar
// when not needed. Ideally we would use
BoundingClientRect().height
// instead however seems that the API is 90% slower than using
ClientHeight.
// Therefore instead we will calculate the difference between
heights and
// allow for a 1px difference to still be considered ok and not
show the
// scroll bar.
var rootHeight = root.current.clientHeight;
var firstChildHeight = root.current.firstElementChild.clientHeight;
if (rootHeight > 0 && firstChildHeight > rootHeight) {
needsVerticalScrollBar = firstChildHeight - rootHeight > 1;
}
}
if (needsVerticalScrollBarState !== needsVerticalScrollBar) {
setNeedsVerticalScrollBar(needsVerticalScrollBar);
}
});
return function () { return async.dispose(); };
});
return needsVerticalScrollBarState;
}
function defaultFocusRestorer(options) {
var originalElement = options.originalElement, containsFocus =
options.containsFocus;
if (originalElement && containsFocus && originalElement !==
Utilities_1.getWindow()) {
// Make sure that the focus method actually exists
// In some cases the object might exist but not be a real element.
// This is primarily for IE 11 and should be removed once IE 11 is no
longer in use.
// This is wrapped in a setTimeout because of a React 16 bug that is
resolved in 17.
// Once we move to 17, the setTimeout should be removed (ref:
https://github.com/facebook/react/issues/17894#issuecomment-656094405)
var _a;
(_a = originalElement.focus) === null || _a === void 0 ? void 0 :
_a.call(originalElement);
}, 0);
}
}
function useRestoreFocus(props, root) {
var _a = props.onRestoreFocus, onRestoreFocus = _a === void 0 ?
defaultFocusRestorer : _a;
var originalFocusedElement = React.useRef();
var containsFocus = React.useRef(false);
originalFocusedElement.current = Utilities_1.getDocument().activeElement;
if (Utilities_1.doesElementContainFocus(root.current)) {
containsFocus.current = true;
}
var _a;
onRestoreFocus === null || onRestoreFocus === void 0 ? void 0 :
onRestoreFocus({
originalElement: originalFocusedElement.current,
containsFocus: containsFocus.current,
documentContainsFocus: ((_a = Utilities_1.getDocument()) === null
|| _a === void 0 ? void 0 : _a.hasFocus()) || false,
});
// De-reference DOM Node to avoid retainment via transpiled closure of
_onKeyDown
originalFocusedElement.current = undefined;
};
on first render
}, []);
react_hooks_1.useOnEvent(root, 'focus', React.useCallback(function () {
containsFocus.current = true;
}, []), true);
react_hooks_1.useOnEvent(root, 'blur', React.useCallback(function (ev) {
/** The popup should update this._containsFocus when:
* relatedTarget exists AND
* the relatedTarget is not contained within the popup.
* If the relatedTarget is within the popup, that means the popup still has
focus
* and focused moved from one element to another within the popup.
* If relatedTarget is undefined or null that usually means that a
* keyboard event occurred and focus didn't change
*/
if (root.current && ev.relatedTarget && !
root.current.contains(ev.relatedTarget)) {
containsFocus.current = false;
}
on first render
}, []), true);
}
function useHideSiblingNodes(props, root) {
var shouldHideSiblings = String(props['aria-modal']).toLowerCase() === 'true'
&& props.enableAriaHiddenSiblings;
if (!(shouldHideSiblings && root.current)) {
return;
}
var unmodalize = Utilities_1.modalize(root.current);
return unmodalize;
}, [root, shouldHideSiblings]);
}
/**
* This adds accessibility to Dialog and Panel controls
*/
exports.Popup = React.forwardRef(function (propsWithoutDefaults, forwardedRef) {
var props = Utilities_1.getPropsWithDefaults({ shouldRestoreFocus: true,
enableAriaHiddenSiblings: true }, propsWithoutDefaults);
var root = React.useRef();
var mergedRootRef = react_hooks_1.useMergedRefs(root, forwardedRef);
useHideSiblingNodes(props, root);
useRestoreFocus(props, root);
var role = props.role, className = props.className, ariaLabel =
props.ariaLabel, ariaLabelledBy = props.ariaLabelledBy, ariaDescribedBy =
props.ariaDescribedBy, style = props.style, children = props.children, onDismiss =
props.onDismiss;
var needsVerticalScrollBar = useScrollbarAsync(props, root);
var onKeyDown = React.useCallback(function (ev) {
switch (ev.which) {
if (onDismiss) {
onDismiss(ev);
}
break;
}
}, [onDismiss]);
react_hooks_1.useOnEvent(win, 'keydown', onKeyDown);
return (React.createElement("div", tslib_1.__assign({ ref: mergedRootRef },
Utilities_1.getNativeProps(props, Utilities_1.divProperties), { className:
className, role: role, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy,
"aria-describedby": ariaDescribedBy, onKeyDown: onKeyDown, style:
tslib_1.__assign({ overflowY: needsVerticalScrollBar ? 'scroll' : undefined,
outline: 'none' }, style) }), children));
});
exports.Popup.displayName = 'Popup';
//# sourceMappingURL=Popup.js.map
/***/ }),
/***/ 43928:
"use strict";

//# sourceMappingURL=Popup.types.js.map
/***/ }),
/***/ 32145:
"use strict";

/***/ }),
/***/ 20699:
"use strict";

exports.ProgressIndicatorBase = void 0;
// if the percentComplete is near 0, don't animate it.
// This prevents animations on reset to 0 scenarios
var ZERO_THRESHOLD = 0.01;
/**
* ProgressIndicator with no default styles.
*/
var ProgressIndicatorBase = /** @class */ (function (_super) {
tslib_1.__extends(ProgressIndicatorBase, _super);
function ProgressIndicatorBase(props) {
_this._onRenderProgress = function (props) {
var _a = _this.props, ariaLabel = _a.ariaLabel, ariaValueText =
_a.ariaValueText, barHeight = _a.barHeight, className = _a.className, description =
_a.description,
_b = _a.label,
label = _b === void 0 ? _this.props.title : _b, styles = _a.styles,
theme = _a.theme;
var percentComplete = typeof _this.props.percentComplete === 'number'
? Math.min(100, Math.max(0, _this.props.percentComplete * 100))
: undefined;
theme: theme,
barHeight: barHeight,
indeterminate: percentComplete === undefined ? true : false,
});
var progressBarStyles = {
width: percentComplete !== undefined ? percentComplete + '%' :
undefined,
transition: percentComplete !== undefined && percentComplete <
ZERO_THRESHOLD ? 'none' : undefined,
};
var ariaValueMin = percentComplete !== undefined ? 0 : undefined;
var ariaValueMax = percentComplete !== undefined ? 100 : undefined;
var ariaValueNow = percentComplete !== undefined ?
Math.floor(percentComplete) : undefined;
return (React.createElement("div", { className: classNames.itemProgress
},
classNames.progressTrack }),
React.createElement("div", { className: classNames.progressBar,
style: progressBarStyles, role: "progressbar", "aria-describedby": description ?
_this._descriptionId : undefined, "aria-label": ariaLabel, "aria-labelledby": label
? _this._labelId : undefined, "aria-valuemin": ariaValueMin, "aria-valuemax":
ariaValueMax, "aria-valuenow": ariaValueNow, "aria-valuetext": ariaValueText })));
};
var id = Utilities_1.getId('progress-indicator');
_this._labelId = id + '-label';
_this._descriptionId = id + '-description';
return _this;
}
ProgressIndicatorBase.prototype.render = function () {
var _a = this.props, barHeight = _a.barHeight, className = _a.className,
_b = _a.label,
label = _b === void 0 ? this.props.title : _b, // Fall back to deprecated
value.
description = _a.description, styles = _a.styles, theme = _a.theme,
progressHidden = _a.progressHidden, _c = _a.onRenderProgress, onRenderProgress = _c
=== void 0 ? this._onRenderProgress : _c;
var percentComplete = typeof this.props.percentComplete === 'number'
? Math.min(100, Math.max(0, this.props.percentComplete * 100))
: undefined;
theme: theme,
barHeight: barHeight,
indeterminate: percentComplete === undefined ? true : false,
});
label ? (React.createElement("div", { id: this._labelId, className:
classNames.itemName }, label)) : null,
!progressHidden
? onRenderProgress(tslib_1.__assign(tslib_1.__assign({},
this.props), { percentComplete: percentComplete }), this._onRenderProgress)
: null,
description ? (React.createElement("div", { id: this._descriptionId,
className: classNames.itemDescription }, description)) : null));
};
ProgressIndicatorBase.defaultProps = {
label: '',
description: '',
width: 180,
};
return ProgressIndicatorBase;
exports.ProgressIndicatorBase = ProgressIndicatorBase;
//# sourceMappingURL=ProgressIndicator.base.js.map
/***/ }),
/***/ 44488:
"use strict";

exports.ProgressIndicator = void 0;
var ProgressIndicator_base_1 = __webpack_require__(20699);
var ProgressIndicator_styles_1 = __webpack_require__(17839);
/**
* ProgressIndicator description
*/
exports.ProgressIndicator =
Utilities_1.styled(ProgressIndicator_base_1.ProgressIndicatorBase,
ProgressIndicator_styles_1.getStyles, undefined, { scope: 'ProgressIndicator' });
//# sourceMappingURL=ProgressIndicator.js.map
/***/ }),
/***/ 17839:
"use strict";

root: 'ms-ProgressIndicator',
itemName: 'ms-ProgressIndicator-itemName',
itemDescription: 'ms-ProgressIndicator-itemDescription',
itemProgress: 'ms-ProgressIndicator-itemProgress',
progressTrack: 'ms-ProgressIndicator-progressTrack',
progressBar: 'ms-ProgressIndicator-progressBar',
};
var IndeterminateProgress = Utilities_1.memoizeFunction(function () {
'0%': {
left: '-30%',
},
'100%': {
left: '100%',
},
});
});
var IndeterminateProgressRTL = Utilities_1.memoizeFunction(function () {
'100%': {
right: '-30%',
},
'0%': {
right: '100%',
},
});
});
var _a, _b, _c;
var isRTL = Utilities_1.getRTL(props.theme);
var className = props.className, indeterminate = props.indeterminate, theme =
props.theme, _d = props.barHeight, barHeight = _d === void 0 ? 2 : _d;
theme.fonts;
var marginBetweenText = 8;
var textHeight = 18;
var progressTrackColor = palette.neutralLight;
return {
root: [classNames.root, fonts.medium, className],
itemName: [
classNames.itemName,
Styling_1.noWrap,
{
paddingTop: marginBetweenText / 2,
lineHeight: textHeight + 2,
},
],
itemDescription: [
classNames.itemDescription,
{
lineHeight: textHeight,
},
],
itemProgress: [
classNames.itemProgress,
{
overflow: 'hidden',
height: barHeight,
padding: marginBetweenText + "px 0",
},
],
progressTrack: [
classNames.progressTrack,
{
width: '100%',
height: barHeight,
backgroundColor: progressTrackColor,
borderBottom: '1px solid WindowText',
},
_a),
},
],
progressBar: [
{
height: barHeight,
transition: 'width .3s ease',
width: 0,
tslib_1.__assign({ backgroundColor: 'highlight' },
_b),
},
indeterminate
? {
minWidth: '33%',
background: "linear-gradient(to right, " + progressTrackColor +
" 0%, " +
(palette.themePrimary + " 50%, " + progressTrackColor + "
100%)"),
animation: (isRTL ? IndeterminateProgressRTL() :
IndeterminateProgress()) + " 3s infinite",
background: "highlight",
},
_c),
}
: {
transition: 'width .15s linear',
},
classNames.progressBar,
],
};
};
//# sourceMappingURL=ProgressIndicator.styles.js.map
/***/ }),
/***/ 91885:
"use strict";

//# sourceMappingURL=ProgressIndicator.types.js.map
/***/ }),
/***/ 74738:
"use strict";

/***/ }),
/***/ 86720:
"use strict";

exports.RatingBase = void 0;
var Rating_types_1 = __webpack_require__(38991);
var RatingStar = function (props) {
return (React.createElement("div", { className: props.classNames.ratingStar },
props.classNames.ratingStarBack, iconName: props.fillPercentage === 0 ||
props.fillPercentage === 100 ? props.icon : props.unselectedIcon }),
!props.disabled && (React.createElement(Icon_1.Icon, { className:
props.classNames.ratingStarFront, iconName: props.icon, style: { width:
props.fillPercentage + '%' } }))));
};
var useComponentRef = function (componentRef, rating) {
rating: rating,
}); }, [rating]);
};
var useDebugWarnings = function (props) {
if (false) {}
};
var getClampedRating = function (rating, min, max) {
return Math.min(Math.max(rating !== null && rating !== void 0 ? rating : min,
min), max);
};
var getFillingPercentage = function (starNum, displayRating) {
var ceilValue = Math.ceil(displayRating);
var fillPercentage = 100;
if (starNum === displayRating) {
fillPercentage = 100;
}
else if (starNum === ceilValue) {
fillPercentage = 100 * (displayRating % 1);
}
else if (starNum > ceilValue) {
fillPercentage = 0;
}
return fillPercentage;
};
var getStarId = function (id, starNum) {
return id + "-star-" + (starNum - 1);
};
exports.RatingBase = React.forwardRef(function (props, forwardedRef) {
var id = react_hooks_1.useId('Rating');
var labelId = react_hooks_1.useId('RatingLabel');
var ariaLabel = props.ariaLabel, ariaLabelFormat = props.ariaLabelFormat,
disabled = props.disabled, getAriaLabel = props.getAriaLabel, styles =
props.styles,
_a = props.min,
minFromProps = _a === void 0 ? props.allowZeroStars ? 0 : 1 : _a, _b =
props.max, max = _b === void 0 ? 5 : _b, readOnly = props.readOnly, size =
props.size, theme = props.theme, _c = props.icon, icon = _c === void 0 ?
'FavoriteStarFill' : _c, _d = props.unselectedIcon, unselectedIcon = _d === void
0 ? 'FavoriteStar' : _d, onRenderStar = props.onRenderStar;
// Ensure min is >= 0 to avoid issues elsewhere
var min = Math.max(minFromProps, 0);
var _e = react_hooks_1.useControllableValue(props.rating, props.defaultRating,
props.onChange), rating = _e[0], setRating = _e[1];
/** Rating clamped within valid range. Will be `min` if `rating` is undefined.
*/
var displayRating = getClampedRating(rating, min, max);
useComponentRef(props.componentRef, displayRating);
Utilities_1.useFocusRects(rootRef);
disabled: disabled,
readOnly: readOnly,
theme: theme,
});
var readOnlyAriaLabel = getAriaLabel === null || getAriaLabel === void 0 ? void
0 : getAriaLabel(displayRating, max);
var normalModeAriaLabel = ariaLabel ? ariaLabel : readOnlyAriaLabel;
var stars = [];
var renderStar = function (starProps, renderer) {
return renderer ? renderer(starProps) : React.createElement(RatingStar,
tslib_1.__assign({}, starProps));
};
var _loop_1 = function (starNum) {
var fillPercentage = getFillingPercentage(starNum, displayRating);
var onSelectStar = function (ev) {
// Use the actual rating (not display value) here, to ensure that we
update if the actual
// rating is undefined and the user clicks the first star.
if (rating === undefined || Math.ceil(rating) !== starNum) {
setRating(starNum, ev);
}
};
stars.push(React.createElement("button", tslib_1.__assign({ className:
Utilities_1.css(classNames.ratingButton, size === Rating_types_1.RatingSize.Large ?
classNames.ratingStarIsLarge : classNames.ratingStarIsSmall), id: getStarId(id,
starNum), key: starNum }, (starNum === Math.ceil(displayRating) && { 'data-is-
current': true }), { onFocus: onSelectStar, onClick: onSelectStar, disabled: !!
(disabled || readOnly), role: "radio", "aria-hidden": readOnly ? 'true' :
undefined, type: "button", "aria-checked": starNum === Math.ceil(displayRating) }),
React.createElement("span", { id: labelId + "-" + starNum, className:
classNames.labelText }, Utilities_1.format(ariaLabelFormat || '', starNum, max)),
renderStar({
fillPercentage: fillPercentage,
disabled: disabled,
icon: fillPercentage > 0 ? icon : unselectedIcon,
starNum: starNum,
unselectedIcon: unselectedIcon,
}, onRenderStar)));
};
for (var starNum = 1; starNum <= max; starNum++) {
_loop_1(starNum);
}
var rootSizeClass = size === Rating_types_1.RatingSize.Large ?
classNames.rootIsLarge : classNames.rootIsSmall;
return (React.createElement("div", tslib_1.__assign({ ref: mergedRootRefs,
className: Utilities_1.css('ms-Rating-star', classNames.root, rootSizeClass),
"aria-label": !readOnly ? normalModeAriaLabel : undefined, id: id, role: !
readOnly ? 'radiogroup' : undefined }, divProps),
React.createElement(FocusZone_1.FocusZone, tslib_1.__assign({ direction:
FocusZone_1.FocusZoneDirection.bidirectional, className:
Utilities_1.css(classNames.ratingFocusZone, rootSizeClass), defaultActiveElement:
'#' + getStarId(id, Math.ceil(displayRating)) }, (readOnly && {
allowFocusRoot: true,
disabled: true,
role: 'textbox',
'aria-label': readOnlyAriaLabel,
'aria-readonly': true,
tabIndex: 0,
})), stars)));
});
exports.RatingBase.displayName = 'RatingBase';
//# sourceMappingURL=Rating.base.js.map
/***/ }),
/***/ 5262:
"use strict";

exports.Rating = void 0;
var Rating_styles_1 = __webpack_require__(16932);
var Rating_base_1 = __webpack_require__(86720);
exports.Rating = Utilities_1.styled(Rating_base_1.RatingBase,
Rating_styles_1.getStyles, undefined, { scope: 'Rating' });
//# sourceMappingURL=Rating.js.map
/***/ }),
/***/ 16932:
"use strict";

root: 'ms-RatingStar-root',
rootIsSmall: 'ms-RatingStar-root--small',
rootIsLarge: 'ms-RatingStar-root--large',
ratingStar: 'ms-RatingStar-container',
ratingStarBack: 'ms-RatingStar-back',
ratingStarFront: 'ms-RatingStar-front',
ratingButton: 'ms-Rating-button',
ratingStarIsSmall: 'ms-Rating--small',
ratingStartIsLarge: 'ms-Rating--large',
labelText: 'ms-Rating-labelText',
ratingFocusZone: 'ms-Rating-focuszone',
};
function _getColorWithHighContrast(color, highContrastColor) {
var _a;
return {
color: color,
color: highContrastColor,
},
_a),
};
}
var disabled = props.disabled, readOnly = props.readOnly, theme = props.theme;
var semanticColors = theme.semanticColors, palette = theme.palette;
var ratingSmallIconSize = 16;
var ratingLargeIconSize = 20;
var ratingVerticalPadding = 8;
var ratingHorizontalPadding = 2;
var ratingStarUncheckedColor = palette.neutralSecondary;
var ratingStarUncheckedHoverColor = palette.themePrimary;
var ratingStarUncheckedHoverSelectedColor = palette.themeDark;
var ratingStarCheckedColor = palette.neutralPrimary;
var ratingStarDisabledColor = semanticColors.disabledBodySubtext;
return {
root: [
classNames.root,
theme.fonts.medium,
!disabled &&
!readOnly && {
selectors: {
// This is part 1 of highlighting all stars up to the one the
user is hovering over
'&:hover': {
selectors: {
'.ms-RatingStar-back':
_getColorWithHighContrast(ratingStarCheckedColor, 'Highlight'),
},
},
},
},
],
rootIsSmall: [
classNames.rootIsSmall,
{
height: ratingSmallIconSize + ratingVerticalPadding * 2 + 'px',
},
],
rootIsLarge: [
classNames.rootIsLarge,
{
height: ratingLargeIconSize + ratingVerticalPadding * 2 + 'px',
},
],
ratingStar: [
classNames.ratingStar,
{
height: 'inherit',
},
],
ratingStarBack: [
classNames.ratingStarBack,
{
// TODO: Use a proper semantic color for this
color: ratingStarUncheckedColor,
width: '100%',
},
disabled && _getColorWithHighContrast(ratingStarDisabledColor,
'GrayText'),
],
ratingStarFront: [
classNames.ratingStarFront,
{
height: '100 %',
left: '0',
top: '0',
overflow: 'hidden',
},
_getColorWithHighContrast(ratingStarCheckedColor, 'Highlight'),
],
ratingButton: [
classNames.ratingButton,
{
padding: ratingVerticalPadding + "px " + ratingHorizontalPadding +
"px",
margin: '0px',
border: 'none',
cursor: 'pointer',
selectors: {
'&:disabled': {
cursor: 'default',
},
'&[disabled]': {
cursor: 'default',
},
},
},
!disabled &&
!readOnly && {
selectors: {
// This is part 2 of highlighting all stars up to the one the
user is hovering over
'&:hover ~ .ms-Rating-button': {
selectors: {
'.ms-RatingStar-back':
_getColorWithHighContrast(ratingStarUncheckedColor, 'WindowText'),
'.ms-RatingStar-front':
_getColorWithHighContrast(ratingStarUncheckedColor, 'WindowText'),
},
},
'&:hover': {
selectors: {
'.ms-RatingStar-back': {
color: ratingStarUncheckedHoverColor,
},
'.ms-RatingStar-front': {
color: ratingStarUncheckedHoverSelectedColor,
},
},
},
},
},
disabled && {
cursor: 'default',
},
],
ratingStarIsSmall: [
classNames.ratingStarIsSmall,
{
fontSize: ratingSmallIconSize + 'px',
lineHeight: ratingSmallIconSize + 'px',
height: ratingSmallIconSize + 'px',
},
],
ratingStarIsLarge: [
classNames.ratingStartIsLarge,
{
fontSize: ratingLargeIconSize + 'px',
lineHeight: ratingLargeIconSize + 'px',
height: ratingLargeIconSize + 'px',
},
],
labelText: [classNames.labelText, Styling_1.hiddenContentStyle],
ratingFocusZone: [
classNames.ratingFocusZone,
{
},
],
};
}
//# sourceMappingURL=Rating.styles.js.map
/***/ }),
/***/ 38991:
"use strict";

exports.RatingSize = void 0;
/**
* {@docCategory Rating}
*/
var RatingSize;
(function (RatingSize) {
RatingSize[RatingSize["Small"] = 0] = "Small";
RatingSize[RatingSize["Large"] = 1] = "Large";
})(RatingSize = exports.RatingSize || (exports.RatingSize = {}));
//# sourceMappingURL=Rating.types.js.map
/***/ }),
/***/ 46439:
"use strict";

/***/ }),
/***/ 86990:
"use strict";

exports.ResizeGroupBase = exports.MeasuredContext =
exports.getNextResizeGroupStateProvider = exports.getMeasurementCache = void 0;
var ResizeGroup_types_1 = __webpack_require__(46953);
/**
* Returns a simple object is able to store measurements with a given key.
*/
var getMeasurementCache = function () {
var measurementsCache = {};
return {
/**
* Checks if the provided data has a cacheKey. If it has a cacheKey and
there is a
* corresponding entry in the measurementsCache, then it will return that
value.
* Returns undefined otherwise.
*/
getCachedMeasurement: function (data) {
if (data && data.cacheKey &&
measurementsCache.hasOwnProperty(data.cacheKey)) {
return measurementsCache[data.cacheKey];
}
return undefined;
},
/**
* Should be called whenever there is a new measurement associated with a
given data object.
* If the data has a cacheKey, store that measurement in the
measurementsCache.
*/
addMeasurementToCache: function (data, measurement) {
if (data.cacheKey) {
measurementsCache[data.cacheKey] = measurement;
}
},
};
};
exports.getMeasurementCache = getMeasurementCache;
/**
* Returns a function that is able to compute the next state for the ResizeGroup
given the current
* state and any measurement updates.
*/
var getNextResizeGroupStateProvider = function (measurementCache) {
if (measurementCache === void 0) { measurementCache =
exports.getMeasurementCache(); }
var _measurementCache = measurementCache;
var _containerDimension;
/**
* Gets the width/height of the data rendered in a hidden div.
* @param measuredData - The data corresponding to the measurement we wish to
take.
* @param getElementToMeasureDimension - A function that returns the
measurement of the rendered data.
* Only called when the measurement is not in the cache.
*/
function _getMeasuredDimension(measuredData, getElementToMeasureDimension) {
var cachedDimension = _measurementCache.getCachedMeasurement(measuredData);
if (cachedDimension !== undefined) {
return cachedDimension;
}
var measuredDimension = getElementToMeasureDimension();
_measurementCache.addMeasurementToCache(measuredData, measuredDimension);
return measuredDimension;
}
/**
* Will get the next IResizeGroupState based on the current data while trying
to shrink contents
* to fit in the container.
* @param data - The initial data point to start measuring.
* @param onReduceData - Function that transforms the data into something that
should render with less width/height.
*/
function _shrinkContentsUntilTheyFit(data, onReduceData,
getElementToMeasureDimension) {
var dataToMeasure = data;
var measuredDimension = _getMeasuredDimension(data,
getElementToMeasureDimension);
while (measuredDimension > _containerDimension) {
var nextMeasuredData = onReduceData(dataToMeasure);
// We don't want to get stuck in an infinite render loop when there are
no more
// scaling steps, so implementations of onReduceData should return
undefined when
// there are no more scaling states to apply.
if (nextMeasuredData === undefined) {
return {
renderedData: dataToMeasure,
resizeDirection: undefined,
dataToMeasure: undefined,
};
}
measuredDimension =
_measurementCache.getCachedMeasurement(nextMeasuredData);
// If the measurement isn't in the cache, we need to re-render with
some data in a hidden div
if (measuredDimension === undefined) {
return {
dataToMeasure: nextMeasuredData,
resizeDirection: 'shrink',
};
}
dataToMeasure = nextMeasuredData;
}
return {
};
}
/**
* This function should be called when the state changes in a manner that might
allow for more content to fit
* on the screen, such as the window width/height growing.
* @param data - The initial data point to start measuring.
* @param onGrowData - Function that transforms the data into something that
may take up more space when rendering.
*/
function _growDataUntilItDoesNotFit(data, onGrowData,
getElementToMeasureDimension, onReduceData) {
var dataToMeasure = data;
var measuredDimension = _getMeasuredDimension(data,
getElementToMeasureDimension);
while (measuredDimension < _containerDimension) {
var nextMeasuredData = onGrowData(dataToMeasure);
// We don't want to get stuck in an infinite render loop when there are
no more
// scaling steps, so implementations of onGrowData should return
undefined when
// there are no more scaling states to apply.
if (nextMeasuredData === undefined) {
return {
};
}
measuredDimension =
_measurementCache.getCachedMeasurement(nextMeasuredData);
// If the measurement isn't in the cache, we need to re-render with
some data in a hidden div
if (measuredDimension === undefined) {
return {
dataToMeasure: nextMeasuredData,
};
}
dataToMeasure = nextMeasuredData;
}
// Once the loop is done, we should now shrink until the contents fit.
return tslib_1.__assign({ resizeDirection: 'shrink' },
_shrinkContentsUntilTheyFit(dataToMeasure, onReduceData,
getElementToMeasureDimension));
}
/**
* Handles an update to the container width/height.
* Should only be called when we knew the previous container width/height.
* @param newDimension - The new width/height of the container.
* @param fullDimensionData - The initial data passed in as a prop to
resizeGroup.
* @param renderedData - The data that was rendered prior to the container size
changing.
* @param onGrowData - Set to true if the Resize group has an onGrowData
function.
*/
function _updateContainerDimension(newDimension, fullDimensionData,
renderedData, onGrowData) {
var nextState;
if (newDimension > _containerDimension) {
if (onGrowData) {
nextState = {
resizeDirection: 'grow',
dataToMeasure: onGrowData(renderedData),
};
}
else {
nextState = {
dataToMeasure: fullDimensionData,
};
}
}
else {
nextState = {
dataToMeasure: renderedData,
};
}
_containerDimension = newDimension;
return tslib_1.__assign(tslib_1.__assign({}, nextState),
{ measureContainer: false });
}
function getNextState(props, currentState, getElementToMeasureDimension,
newContainerDimension) {
// If there is no new container width/height or data to measure, there is
no need for a new state update
if (newContainerDimension === undefined && currentState.dataToMeasure ===
undefined) {
return undefined;
}
if (newContainerDimension) {
// If we know the last container size and we rendered data at that
width/height, we can do an optimized render
if (_containerDimension && currentState.renderedData && !
currentState.dataToMeasure) {
return tslib_1.__assign(tslib_1.__assign({}, currentState),
_updateContainerDimension(newContainerDimension, props.data,
currentState.renderedData, props.onGrowData));
}
// If we are just setting the container width/height for the first
time, we can't do any optimizations
_containerDimension = newContainerDimension;
}
var nextState = tslib_1.__assign(tslib_1.__assign({}, currentState),
{ measureContainer: false });
if (currentState.dataToMeasure) {
if (currentState.resizeDirection === 'grow' && props.onGrowData) {
_growDataUntilItDoesNotFit(currentState.dataToMeasure, props.onGrowData,
getElementToMeasureDimension, props.onReduceData));
}
else {
_shrinkContentsUntilTheyFit(currentState.dataToMeasure, props.onReduceData,
getElementToMeasureDimension));
}
}
return nextState;
}
/** Function that determines if we need to render content for measurement based
on the measurement cache contents. */
function shouldRenderDataForMeasurement(dataToMeasure) {
if (!dataToMeasure || _measurementCache.getCachedMeasurement(dataToMeasure)
!== undefined) {
return false;
}
return true;
}
function getInitialResizeGroupState(data) {
return {
dataToMeasure: tslib_1.__assign({}, data),
resizeDirection: 'grow',
measureContainer: true,
};
}
return {
getNextState: getNextState,
shouldRenderDataForMeasurement: shouldRenderDataForMeasurement,
getInitialResizeGroupState: getInitialResizeGroupState,
};
};
exports.getNextResizeGroupStateProvider = getNextResizeGroupStateProvider;
// Provides a context property that (if true) tells any child components that
// they are only being used for measurement purposes and will not be visible.
exports.MeasuredContext = React.createContext({ isMeasured: false });
// Styles for the hidden div used for measurement
var hiddenDivStyles = { position: 'fixed', visibility: 'hidden' };
var hiddenParentStyles = { position: 'relative' };
var COMPONENT_NAME = 'ResizeGroup';
/**
* Use useReducer instead of userState because React is not batching the state
updates
* when state is set in callbacks of setTimeout or requestAnimationFrame.
* See issue: https://github.com/facebook/react/issues/14259
*/
function resizeDataReducer(state, action) {
var _a;
switch (action.type) {
case 'resizeData':
return tslib_1.__assign({}, action.value);
case 'dataToMeasure':
return tslib_1.__assign(tslib_1.__assign({}, state), { dataToMeasure:
action.value, resizeDirection: 'grow', measureContainer: true });
default:
return tslib_1.__assign(tslib_1.__assign({}, state), (_a = {},
_a[action.type] = action.value, _a));
}
}
function useResizeState(props, nextResizeGroupStateProvider, rootRef) {
var initialStateData = react_hooks_1.useConst(function () { return
nextResizeGroupStateProvider.getInitialResizeGroupState(props.data); });
var _a = React.useReducer(resizeDataReducer, initialStateData), resizeData =
_a[0], dispatchResizeDataAction = _a[1];
// Reset state when new data is provided
dispatchResizeDataAction({
type: 'dataToMeasure',
value: props.data,
});
}, [props.data]);
// Because it's possible that we may force more than one re-render per
animation frame, we
// want to make sure that the RAF request is using the most recent data.
var stateRef = React.useRef(initialStateData);
stateRef.current = tslib_1.__assign({}, resizeData);
var updateResizeState = React.useCallback(function (nextState) {
if (nextState) {
type: 'resizeData',
value: nextState,
});
}
}, []);
var remeasure = React.useCallback(function () {
if (rootRef.current) {
type: 'measureContainer',
value: true,
});
}
}, [rootRef]);
return [stateRef, updateResizeState, remeasure];
}
function useResizingBehavior(props, rootRef) {
var nextResizeGroupStateProvider =
react_hooks_1.useConst(exports.getNextResizeGroupStateProvider);
// A div that can be used for the initial measurement so that we can avoid
mounting a second instance
// of the component being measured for the initial render.
var initialHiddenDiv = React.useRef(null);
// A hidden div that is used for mounting a new instance of the component for
measurement in a hidden
// div without unmounting the currently visible content.
var updateHiddenDiv = React.useRef(null);
// Tracks if any content has been rendered to the user. This enables us to do
some performance optimizations
// for the initial render.
var hasRenderedContent = React.useRef(false);
var _a = useResizeState(props, nextResizeGroupStateProvider, rootRef), stateRef
= _a[0], updateResizeState = _a[1], remeasure = _a[2];
var _a;
if (stateRef.current.renderedData) {
hasRenderedContent.current = true;
(_a = props.dataDidRender) === null || _a === void 0 ? void 0 :
_a.call(props, stateRef.current.renderedData);
}
});
var containerDimension = undefined;
if (stateRef.current.measureContainer && rootRef.current) {
var boundingRect = rootRef.current.getBoundingClientRect();
containerDimension =
props.direction ===
ResizeGroup_types_1.ResizeGroupDirection.vertical ? boundingRect.height :
boundingRect.width;
}
var nextState = nextResizeGroupStateProvider.getNextState(props,
stateRef.current, function () {
var refToMeasure = !hasRenderedContent.current ? initialHiddenDiv :
updateHiddenDiv;
if (!refToMeasure.current) {
return 0;
}
var measuredBoundingRect =
refToMeasure.current.getBoundingClientRect();
return props.direction ===
ResizeGroup_types_1.ResizeGroupDirection.vertical
? measuredBoundingRect.height
: measuredBoundingRect.width;
}, containerDimension);
updateResizeState(nextState);
}, rootRef.current);
});
var win = WindowProvider_1.useWindow();
react_hooks_1.useOnEvent(win, 'resize', async.debounce(remeasure, RESIZE_DELAY,
{ leading: true }));
var dataNeedsMeasuring =
nextResizeGroupStateProvider.shouldRenderDataForMeasurement(stateRef.current.dataTo
Measure);
var isInitialMeasure = !hasRenderedContent.current && dataNeedsMeasuring;
return [
stateRef.current.dataToMeasure,
stateRef.current.renderedData,
remeasure,
initialHiddenDiv,
updateHiddenDiv,
dataNeedsMeasuring,
isInitialMeasure,
];
}
if (false) {}
}
var measuredContextValue = { isMeasured: true };
exports.ResizeGroupBase = React.forwardRef(function (props, forwardedRef) {
// The root div which is the container inside of which we are trying to fit
content.
var mergedRootRef = react_hooks_1.useMergedRefs(rootRef, forwardedRef);
var _a = useResizingBehavior(props, rootRef), dataToMeasure = _a[0],
renderedData = _a[1], remeasure = _a[2], initialHiddenDiv = _a[3], updateHiddenDiv
= _a[4], dataNeedsMeasuring = _a[5], isInitialMeasure = _a[6];
React.useImperativeHandle(props.componentRef, function () { return
({ remeasure: remeasure }); }, [remeasure]);
var className = props.className, onRenderData = props.onRenderData;
var divProps = Utilities_1.getNativeProps(props, Utilities_1.divProperties,
['data']);
// We only ever render the final content to the user. All measurements are done
in a hidden div.
// For the initial render, we want this to be as fast as possible, so we need
to make sure that we only mount one
// version of the component for measurement and the final render. For renders
that update what is on screen, we
// want to make sure that there are no jarring effects such as the screen
flashing as we apply scaling steps for
// measurement. In the update case, we mount a second version of the component
just for measurement purposes and
// leave the rendered content untouched until we know the next state to show to
the user.
return (React.createElement("div", tslib_1.__assign({}, divProps, { className:
className, ref: mergedRootRef }),
React.createElement("div", { style: hiddenParentStyles },
dataNeedsMeasuring && !isInitialMeasure && (React.createElement("div",
{ style: hiddenDivStyles, ref: updateHiddenDiv },
React.createElement(exports.MeasuredContext.Provider, { value:
measuredContextValue }, onRenderData(dataToMeasure)))),
React.createElement("div", { ref: initialHiddenDiv, style:
isInitialMeasure ? hiddenDivStyles : undefined, "data-automation-id":
"visibleContent" }, isInitialMeasure ? onRenderData(dataToMeasure) : renderedData
&& onRenderData(renderedData)))));
});
exports.ResizeGroupBase.displayName = 'ResizeGroupBase';
//# sourceMappingURL=ResizeGroup.base.js.map
/***/ }),
/***/ 99404:
"use strict";

exports.ResizeGroup = void 0;
var ResizeGroup_base_1 = __webpack_require__(86990);
exports.ResizeGroup = ResizeGroup_base_1.ResizeGroupBase;
//# sourceMappingURL=ResizeGroup.js.map
/***/ }),
/***/ 46953:
"use strict";

exports.ResizeGroupDirection = void 0;
/**
* {@docCategory ResizeGroup}
*/
var ResizeGroupDirection;
(function (ResizeGroupDirection) {
ResizeGroupDirection[ResizeGroupDirection["horizontal"] = 0] = "horizontal";
ResizeGroupDirection[ResizeGroupDirection["vertical"] = 1] = "vertical";
})(ResizeGroupDirection = exports.ResizeGroupDirection ||
(exports.ResizeGroupDirection = {}));
//# sourceMappingURL=ResizeGroup.types.js.map
/***/ }),
/***/ 9347:
"use strict";

/***/ }),
/***/ 40563:
"use strict";

exports.ScrollablePaneBase = void 0;
var ScrollablePane_types_1 = __webpack_require__(97407);
var ScrollablePaneBase = /** @class */ (function (_super) {
tslib_1.__extends(ScrollablePaneBase, _super);
function ScrollablePaneBase(props) {
_this._stickyAboveRef = React.createRef();
_this._stickyBelowRef = React.createRef();
_this._contentContainer = React.createRef();
_this.subscribe = function (handler) {
_this._subscribers.add(handler);
};
_this.unsubscribe = function (handler) {
_this._subscribers.delete(handler);
};
_this.addSticky = function (sticky) {
_this._stickies.add(sticky);
// If ScrollablePane is mounted, then sort sticky in correct place
if (_this.contentContainer) {
sticky.setDistanceFromTop(_this.contentContainer);
_this.sortSticky(sticky);
}
};
_this.removeSticky = function (sticky) {
_this._stickies.delete(sticky);
_this._removeStickyFromContainers(sticky);
_this.notifySubscribers();
};
_this.sortSticky = function (sticky, sortAgain) {
if (_this.stickyAbove && _this.stickyBelow) {
if (sortAgain) {
_this._removeStickyFromContainers(sticky);
}
if (sticky.canStickyTop && sticky.stickyContentTop) {
_this._addToStickyContainer(sticky, _this.stickyAbove,
sticky.stickyContentTop);
}
if (sticky.canStickyBottom && sticky.stickyContentBottom) {
_this._addToStickyContainer(sticky, _this.stickyBelow,
sticky.stickyContentBottom);
}
}
};
_this.updateStickyRefHeights = function () {
var stickyItems = _this._stickies;
var stickyTopHeight = 0;
var stickyBottomHeight = 0;
stickyItems.forEach(function (sticky) {
var _a = sticky.state, isStickyTop = _a.isStickyTop, isStickyBottom
= _a.isStickyBottom;
if (sticky.nonStickyContent) {
if (isStickyTop) {
stickyTopHeight += sticky.nonStickyContent.offsetHeight;
}
if (isStickyBottom) {
stickyBottomHeight += sticky.nonStickyContent.offsetHeight;
}
_this._checkStickyStatus(sticky);
}
});
_this.setState({
stickyTopHeight: stickyTopHeight,
stickyBottomHeight: stickyBottomHeight,
});
};
_this.notifySubscribers = function () {
_this._subscribers.forEach(function (handle) {
// this.stickyBelow is passed in for calculating distance to
determine Sticky status
handle(_this.contentContainer, _this.stickyBelow);
});
}
};
_this.getScrollPosition = function () {
return _this.contentContainer.scrollTop;
}
return 0;
};
_this.syncScrollSticky = function (sticky) {
if (sticky && _this.contentContainer) {
sticky.syncScroll(_this.contentContainer);
}
};
_this._getScrollablePaneContext = function () {
return {
scrollablePane: {
subscribe: _this.subscribe,
unsubscribe: _this.unsubscribe,
addSticky: _this.addSticky,
removeSticky: _this.removeSticky,
updateStickyRefHeights: _this.updateStickyRefHeights,
sortSticky: _this.sortSticky,
notifySubscribers: _this.notifySubscribers,
syncScrollSticky: _this.syncScrollSticky,
},
};
};
_this._addToStickyContainer = function (sticky, stickyContainer,
stickyContentToAdd) {
// If there's no children, append child to list, otherwise, sort though
array and append at correct position
if (!stickyContainer.children.length) {
stickyContainer.appendChild(stickyContentToAdd);
}
else {
// If stickyContentToAdd isn't a child element of target container,
then append
if (!stickyContainer.contains(stickyContentToAdd)) {
var stickyChildrenElements_1 =
[].slice.call(stickyContainer.children);
var stickyList_1 = [];
// Get stickies. Filter by canStickyTop/Bottom, then sort by
distance from top, and then
// filter by elements that are in the stickyContainer already.
_this._stickies.forEach(function (stickyItem) {
if (stickyContainer === _this.stickyAbove &&
sticky.canStickyTop) {
stickyList_1.push(stickyItem);
}
else if (sticky.canStickyBottom) {
stickyList_1.push(stickyItem);
}
});
var stickyListSorted = stickyList_1
.sort(function (a, b) {
return (a.state.distanceFromTop || 0) -
(b.state.distanceFromTop || 0);
})
.filter(function (item) {
var stickyContent = stickyContainer === _this.stickyAbove ?
item.stickyContentTop : item.stickyContentBottom;
if (stickyContent) {
return stickyChildrenElements_1.indexOf(stickyContent)
> -1;
}
return false;
});
// Get first element that has a distance from top that is
further than our sticky that is being added
var targetStickyToAppendBefore = undefined;
for (var _i = 0, stickyListSorted_1 = stickyListSorted; _i <
stickyListSorted_1.length; _i++) {
var stickyListItem = stickyListSorted_1[_i];
if ((stickyListItem.state.distanceFromTop || 0) >=
(sticky.state.distanceFromTop || 0)) {
targetStickyToAppendBefore = stickyListItem;
break;
}
}
// If target element to append before is known, grab respective
stickyContentTop/Bottom element
// and insert before
var targetContainer = null;
if (targetStickyToAppendBefore) {
targetContainer =
stickyContainer === _this.stickyAbove
? targetStickyToAppendBefore.stickyContentTop
: targetStickyToAppendBefore.stickyContentBottom;
}
stickyContainer.insertBefore(stickyContentToAdd,
targetContainer);
}
}
};
_this._removeStickyFromContainers = function (sticky) {
if (_this.stickyAbove && sticky.stickyContentTop &&
_this.stickyAbove.contains(sticky.stickyContentTop)) {
_this.stickyAbove.removeChild(sticky.stickyContentTop);
}
if (_this.stickyBelow && sticky.stickyContentBottom &&
_this.stickyBelow.contains(sticky.stickyContentBottom)) {
_this.stickyBelow.removeChild(sticky.stickyContentBottom);
}
};
_this._onWindowResize = function () {
var scrollbarWidth = _this._getScrollbarWidth();
var scrollbarHeight = _this._getScrollbarHeight();
_this.setState({
scrollbarWidth: scrollbarWidth,
scrollbarHeight: scrollbarHeight,
});
};
_this._getStickyContainerStyle = function (height, isTop) {
return tslib_1.__assign(tslib_1.__assign({ height: height },
(Utilities_1.getRTL(_this.props.theme)
? {
right: '0',
left: (_this.state.scrollbarWidth || _this._getScrollbarWidth()
|| 0) + "px",
}
: {
left: '0',
right: (_this.state.scrollbarWidth ||
_this._getScrollbarWidth() || 0) + "px",
})), (isTop
? {
top: '0',
}
: {
bottom: (_this.state.scrollbarHeight ||
_this._getScrollbarHeight() || 0) + "px",
}));
};
var contentContainer = _this.contentContainer;
if (contentContainer) {
_this._stickies.forEach(function (sticky) {
sticky.syncScroll(contentContainer);
});
}
_this._notifyThrottled();
};
_this._subscribers = new Set();
_this._stickies = new Set();
_this.state = {
stickyTopHeight: 0,
stickyBottomHeight: 0,
scrollbarWidth: 0,
scrollbarHeight: 0,
};
_this._notifyThrottled = _this._async.throttle(_this.notifySubscribers,
50);
return _this;
}
Object.defineProperty(ScrollablePaneBase.prototype, "root", {
get: function () {
return this._root.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ScrollablePaneBase.prototype, "stickyAbove", {
get: function () {
return this._stickyAboveRef.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ScrollablePaneBase.prototype, "stickyBelow", {
get: function () {
return this._stickyBelowRef.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ScrollablePaneBase.prototype, "contentContainer", {
get: function () {
return this._contentContainer.current;
},
enumerable: false,
configurable: true
});
ScrollablePaneBase.prototype.componentDidMount = function () {
var _this = this;
var initialScrollPosition = this.props.initialScrollPosition;
this._events.on(this.contentContainer, 'scroll', this._onScroll);
this._events.on(window, 'resize', this._onWindowResize);
if (this.contentContainer && initialScrollPosition) {
this.contentContainer.scrollTop = initialScrollPosition;
}
// Set sticky distances from top property, then sort in correct order and
notify subscribers
this.setStickiesDistanceFromTop();
this._stickies.forEach(function (sticky) {
_this.sortSticky(sticky);
});
this.notifySubscribers();
if ('MutationObserver' in window) {
this._mutationObserver = new MutationObserver(function (mutation) {
// Function to check if mutation is occuring in stickyAbove or
stickyBelow
function checkIfMutationIsSticky(mutationRecord) {
if (this.stickyAbove !== null && this.stickyBelow !== null) {
return this.stickyAbove.contains(mutationRecord.target) ||
this.stickyBelow.contains(mutationRecord.target);
}
return false;
}
// Compute the scrollbar height, which might have changed if the
content's width changed and caused overflow
var scrollbarHeight = _this._getScrollbarHeight();
// If the scrollbar height changed, update state so it's postioned
correctly below sticky footer
if (scrollbarHeight !== _this.state.scrollbarHeight) {
_this.setState({
scrollbarHeight: scrollbarHeight,
});
}
// Notify subscribers again to re-check whether Sticky should be
Sticky'd or not
// If mutation occurs in sticky header or footer, then update
sticky top/bottom heights
if (mutation.some(checkIfMutationIsSticky.bind(_this))) {
_this.updateStickyRefHeights();
}
else {
// If mutation occurs in scrollable region, then find Sticky it
belongs to and force update
var stickyList_2 = [];
_this._stickies.forEach(function (sticky) {
if (sticky.root &&
sticky.root.contains(mutation[0].target)) {
stickyList_2.push(sticky);
}
});
if (stickyList_2.length) {
stickyList_2.forEach(function (sticky) {
sticky.forceUpdate();
});
}
}
});
if (this.root) {
this._mutationObserver.observe(this.root, {
childList: true,
attributes: true,
subtree: true,
characterData: true,
});
}
}
};
ScrollablePaneBase.prototype.componentWillUnmount = function () {
if (this._mutationObserver) {
this._mutationObserver.disconnect();
}
};
// Only updates if props/state change, just to prevent excessive setState with
updateStickyRefHeights
ScrollablePaneBase.prototype.shouldComponentUpdate = function (nextProps,
nextState) {
return (this.props.children !== nextProps.children ||
this.props.initialScrollPosition !== nextProps.initialScrollPosition ||
this.props.className !== nextProps.className ||
this.state.stickyTopHeight !== nextState.stickyTopHeight ||
this.state.stickyBottomHeight !== nextState.stickyBottomHeight ||
this.state.scrollbarWidth !== nextState.scrollbarWidth ||
this.state.scrollbarHeight !== nextState.scrollbarHeight);
};
ScrollablePaneBase.prototype.componentDidUpdate = function (prevProps,
prevState) {
var initialScrollPosition = this.props.initialScrollPosition;
if (this.contentContainer &&
typeof initialScrollPosition === 'number' &&
prevProps.initialScrollPosition !== initialScrollPosition) {
this.contentContainer.scrollTop = initialScrollPosition;
}
// Update subscribers when stickyTopHeight/stickyBottomHeight changes
if (prevState.stickyTopHeight !== this.state.stickyTopHeight ||
prevState.stickyBottomHeight !== this.state.stickyBottomHeight) {
this.notifySubscribers();
}
this._async.setTimeout(this._onWindowResize, 0);
};
ScrollablePaneBase.prototype.render = function () {
var _a = this.props, className = _a.className, scrollContainerFocus =
_a.scrollContainerFocus, scrollContainerAriaLabel = _a.scrollContainerAriaLabel,
theme = _a.theme, styles = _a.styles, onScroll = _a.onScroll;
var _b = this.state, stickyTopHeight = _b.stickyTopHeight,
stickyBottomHeight = _b.stickyBottomHeight;
theme: theme,
scrollbarVisibility: this.props.scrollbarVisibility,
});
var scrollContainerProps = scrollContainerFocus
? {
role: 'group',
tabIndex: 0,
'aria-label': scrollContainerAriaLabel,
onScroll: onScroll,
}
: {
onScroll: onScroll,
};
Utilities_1.getNativeProps(tslib_1.__assign({}, this.props),
Utilities_1.divProperties,
// on React 17 onScroll is not being invoked on root element,
// as a fix this method will be provided to the container element
['onScroll']), { ref: this._root, className: classNames.root }),
React.createElement("div", { ref: this._stickyAboveRef, className:
classNames.stickyAbove, style: this._getStickyContainerStyle(stickyTopHeight, true)
}),
React.createElement("div", tslib_1.__assign({ ref:
this._contentContainer }, scrollContainerProps, { className:
classNames.contentContainer, "data-is-scrollable": true }),
React.createElement(ScrollablePane_types_1.ScrollablePaneContext.Provider, { value:
this._getScrollablePaneContext() }, this.props.children)),
React.createElement("div", { className: classNames.stickyBelow, style:
this._getStickyContainerStyle(stickyBottomHeight, false) },
React.createElement("div", { ref: this._stickyBelowRef, className:
classNames.stickyBelowItems }))));
};
ScrollablePaneBase.prototype.setStickiesDistanceFromTop = function () {
var _this = this;
if (this.contentContainer) {
this._stickies.forEach(function (sticky) {
sticky.setDistanceFromTop(_this.contentContainer);
});
}
};
ScrollablePaneBase.prototype.forceLayoutUpdate = function () {
this._onWindowResize();
};
ScrollablePaneBase.prototype._checkStickyStatus = function (sticky) {
if (this.stickyAbove && this.stickyBelow && this.contentContainer &&
sticky.nonStickyContent) {
// If sticky is sticky, then append content to appropriate container
if (sticky.state.isStickyTop || sticky.state.isStickyBottom) {
if (sticky.state.isStickyTop &&
!this.stickyAbove.contains(sticky.nonStickyContent) &&
sticky.stickyContentTop) {
sticky.addSticky(sticky.stickyContentTop);
}
if (sticky.state.isStickyBottom &&
!this.stickyBelow.contains(sticky.nonStickyContent) &&
sticky.stickyContentBottom) {
sticky.addSticky(sticky.stickyContentBottom);
}
}
else if (!this.contentContainer.contains(sticky.nonStickyContent)) {
// Reset sticky if it's not sticky and not in the contentContainer
element
sticky.resetSticky();
}
}
};
ScrollablePaneBase.prototype._getScrollbarWidth = function () {
var contentContainer = this.contentContainer;
return contentContainer ? contentContainer.offsetWidth -
contentContainer.clientWidth : 0;
};
ScrollablePaneBase.prototype._getScrollbarHeight = function () {
var contentContainer = this.contentContainer;
return contentContainer ? contentContainer.offsetHeight -
contentContainer.clientHeight : 0;
};
return ScrollablePaneBase;
exports.ScrollablePaneBase = ScrollablePaneBase;
//# sourceMappingURL=ScrollablePane.base.js.map
/***/ }),
/***/ 75378:
"use strict";

exports.ScrollablePane = void 0;
var ScrollablePane_styles_1 = __webpack_require__(91179);
var ScrollablePane_base_1 = __webpack_require__(40563);
exports.ScrollablePane =
Utilities_1.styled(ScrollablePane_base_1.ScrollablePaneBase,
ScrollablePane_styles_1.getStyles, undefined, { scope: 'ScrollablePane' });
//# sourceMappingURL=ScrollablePane.js.map
/***/ }),
/***/ 91179:
"use strict";

root: 'ms-ScrollablePane',
contentContainer: 'ms-ScrollablePane--contentContainer',
};
var _a, _b;
var AboveAndBelowStyles = {
};
var positioningStyle = {
top: 0,
right: 0,
bottom: 0,
left: 0,
};
return {
root: [classNames.root, theme.fonts.medium, positioningStyle, className],
contentContainer: [
classNames.contentContainer,
{
overflowY: props.scrollbarVisibility === 'always' ? 'scroll' :
'auto',
},
positioningStyle,
],
stickyAbove: [
{
top: 0,
zIndex: 1,
borderBottom: '1px solid WindowText',
},
_a),
},
AboveAndBelowStyles,
],
stickyBelow: [
{
bottom: 0,
borderTop: '1px solid WindowText',
},
_b),
},
],
stickyBelowItems: [
{
bottom: 0,
},
{
width: '100%',
},
],
};
};
//# sourceMappingURL=ScrollablePane.styles.js.map
/***/ }),
/***/ 97407:
"use strict";

exports.ScrollablePaneContext = exports.ScrollbarVisibility = void 0;
/**
* {@docCategory ScrollablePane}
*/
exports.ScrollbarVisibility = {
auto: 'auto',
always: 'always',
};
exports.ScrollablePaneContext = React.createContext({ scrollablePane: undefined });
//# sourceMappingURL=ScrollablePane.types.js.map
/***/ }),
/***/ 5902:
"use strict";

/***/ }),
/***/ 118:
"use strict";
exports.SearchBoxBase = void 0;
var COMPONENT_NAME = 'SearchBox';
var iconButtonStyles = { root: { height: 'auto' }, icon: { fontSize: '12px' } };
var iconButtonProps = { iconName: 'Clear' };
var defaultClearButtonProps = { ariaLabel: 'Clear text' };
var useComponentRef = function (componentRef, inputElementRef, hasFocus) {
focus: function () { var _a; return (_a = inputElementRef.current) === null
|| _a === void 0 ? void 0 : _a.focus(); },
hasFocus: function () { return hasFocus; },
}); }, [inputElementRef, hasFocus]);
};
exports.SearchBoxBase = React.forwardRef(function (props, forwardedRef) {
var ariaLabel = props.ariaLabel, className = props.className, _a =
props.defaultValue, defaultValue = _a === void 0 ? '' : _a, disabled =
props.disabled, underlined = props.underlined, styles = props.styles,
labelText = props.labelText,
_b = props.placeholder,
placeholder = _b === void 0 ? labelText : _b, theme = props.theme, _c =
props.clearButtonProps, clearButtonProps = _c === void 0 ?
defaultClearButtonProps : _c, _d = props.disableAnimation, disableAnimation = _d
=== void 0 ? false : _d, _e = props.showIcon, showIcon = _e === void 0 ? false :
_e, customOnClear = props.onClear, customOnBlur = props.onBlur, customOnEscape =
props.onEscape, customOnSearch = props.onSearch, customOnKeyDown = props.onKeyDown,
iconProps = props.iconProps, role = props.role, onChange = props.onChange,
onChanged = props.onChanged;
var _f = React.useState(false), hasFocus = _f[0], setHasFocus = _f[1];
var prevChangeTimestamp = React.useRef();
var _g = react_hooks_1.useControllableValue(props.value, defaultValue, function
(ev, newValue) {
if (ev && ev.timeStamp === prevChangeTimestamp.current) {
// For historical reasons, SearchBox handles both onInput and onChange
(we can't modify this
// outside a major version due to potential to break partners' tests
and possibly apps).
// Only call props.onChange for one of the events.
return;
}
prevChangeTimestamp.current = ev === null || ev === void 0 ? void 0 :
ev.timeStamp;
onChange === null || onChange === void 0 ? void 0 : onChange(ev, newValue);
onChanged === null || onChanged === void 0 ? void 0 : onChanged(newValue);
}), uncastValue = _g[0], setValue = _g[1];
var value = String(uncastValue);
var rootElementRef = React.useRef(null);
var inputElementRef = React.useRef(null);
var mergedRootRef = react_hooks_1.useMergedRefs(rootElementRef, forwardedRef);
var id = react_hooks_1.useId(COMPONENT_NAME, props.id);
var customOnClearClick = clearButtonProps.onClick;
theme: theme,
hasFocus: hasFocus,
disabled: disabled,
hasInput: value.length > 0,
disableAnimation: disableAnimation,
showIcon: showIcon,
});
Utilities_1.inputProperties, [
'className',
'placeholder',
'onFocus',
'onBlur',
'value',
'role',
]);
var onClear = React.useCallback(function (ev) {
var _a;
customOnClear === null || customOnClear === void 0 ? void 0 :
customOnClear(ev);
setValue('');
(_a = inputElementRef.current) === null || _a === void 0 ? void 0 :
_a.focus();
}
}, [customOnClear, setValue]);
var onClearClick = React.useCallback(function (ev) {
customOnClearClick === null || customOnClearClick === void 0 ? void 0 :
customOnClearClick(ev);
onClear(ev);
}
}, [customOnClearClick, onClear]);
var onFocusCapture = function (ev) {
var _a;
setHasFocus(true);
ev);
};
var onClickFocus = function () {
if (inputElementRef.current) {
inputElementRef.current.focus();
inputElementRef.current.selectionStart =
inputElementRef.current.selectionEnd = 0;
}
};
var onBlur = React.useCallback(function (ev) {
setHasFocus(false);
customOnBlur === null || customOnBlur === void 0 ? void 0 :
customOnBlur(ev);
}, [customOnBlur]);
var onInputChange = function (ev) {
setValue(ev.target.value, ev);
};
switch (ev.which) {
customOnEscape === null || customOnEscape === void 0 ? void 0 :
customOnEscape(ev);
// Only call onClear if the search box has a value to clear.
Otherwise, allow the Esc key
// to propagate from the empty search box to a parent element such
as a dialog, etc.
if (value && !ev.defaultPrevented) {
onClear(ev);
}
break;
if (customOnSearch) {
customOnSearch(value);
}
break;
default:
// REVIEW: Why aren't we calling customOnKeyDown for Escape or
Enter?
customOnKeyDown === null || customOnKeyDown === void 0 ? void 0 :
customOnKeyDown(ev);
// REVIEW: Why are we calling stopPropagation if customOnKeyDown
called preventDefault?
// customOnKeyDown should call stopPropagation if it needs it.
}
break;
}
};
useDebugWarning(props);
useComponentRef(props.componentRef, inputElementRef, hasFocus);
return (React.createElement("div", { role: role, ref: mergedRootRef, className:
classNames.root, onFocusCapture: onFocusCapture },
React.createElement("div", { className: classNames.iconContainer, onClick:
onClickFocus, "aria-hidden": true },
React.createElement(Icon_1.Icon, tslib_1.__assign({ iconName:
"Search" }, iconProps, { className: classNames.icon }))),
React.createElement("input", tslib_1.__assign({}, nativeProps, { id: id,
className: classNames.field, placeholder: placeholder, onChange: onInputChange,
onInput: onInputChange, onBlur: onBlur, onKeyDown: onKeyDown, value: value,
disabled: disabled, role: "searchbox", "aria-label": ariaLabel, ref:
inputElementRef })),
value.length > 0 && (React.createElement("div", { className:
classNames.clearButton },
React.createElement(Button_1.IconButton, tslib_1.__assign({ onBlur:
onBlur, styles: iconButtonStyles, iconProps: iconButtonProps }, clearButtonProps, {
onClick: onClearClick }))))));
});
exports.SearchBoxBase.displayName = COMPONENT_NAME;
function useDebugWarning(props) {
if (false) {}
}
//# sourceMappingURL=SearchBox.base.js.map
/***/ }),
/***/ 87653:
"use strict";

exports.SearchBox = void 0;
var SearchBox_base_1 = __webpack_require__(118);
var SearchBox_styles_1 = __webpack_require__(58146);
exports.SearchBox = Utilities_1.styled(SearchBox_base_1.SearchBoxBase,
SearchBox_styles_1.getStyles, undefined, { scope: 'SearchBox' });
//# sourceMappingURL=SearchBox.js.map
/***/ }),
/***/ 58146:
"use strict";

root: 'ms-SearchBox',
iconContainer: 'ms-SearchBox-iconContainer',
icon: 'ms-SearchBox-icon',
clearButton: 'ms-SearchBox-clearButton',
field: 'ms-SearchBox-field',
};
var _a, _b, _c, _d, _e;
var theme = props.theme, underlined = props.underlined, disabled =
props.disabled, hasFocus = props.hasFocus, className = props.className, hasInput =
props.hasInput, disableAnimation = props.disableAnimation, showIcon =
props.showIcon;
var palette = theme.palette, fonts = theme.fonts, semanticColors =
theme.semanticColors, effects = theme.effects;
// placeholder style constants
var placeholderStyles = {
opacity: 1,
};
var inputIconAlt = palette.neutralSecondary;
var inputIconAltHovered = palette.neutralPrimary;
var inputBorderDisabled = palette.neutralLighter;
var inputBackgroundHovered = palette.neutralLighter;
var inputBackgroundDisabled = palette.neutralLighter;
return {
root: [
classNames.root,
fonts.medium,
{
color: semanticColors.inputText,
display: 'flex',
flexWrap: 'nowrap',
// The 1px top and bottom padding ensure the input field does not
overlap the border
padding: '1px 0 1px 4px',
border: "1px solid " + semanticColors.inputBorder,
height: 32,
},
_a[':hover'] = {
},
_b),
},
_a[":hover ." + classNames.iconContainer] = {
color: semanticColors.inputIconHovered,
},
_a),
},
!hasFocus &&
hasInput && {
_c[":hover ." + classNames.iconContainer] = {
width: 4,
},
_c[":hover ." + classNames.icon] = {
opacity: 0,
},
_c),
},
hasFocus && [
'is-active',
{
},
Styling_1.getInputFocusStyle(semanticColors.inputFocusBorderAlt,
underlined ? 0 : effects.roundedCorner2, underlined ? 'borderBottom' : 'border'),
],
showIcon && [
{
_d[":hover ." + classNames.iconContainer] = {
width: 32,
},
_d[":hover ." + classNames.icon] = {
opacity: 1,
},
_d),
},
],
disabled && [
'is-disabled',
{
borderColor: inputBorderDisabled,
backgroundColor: inputBackgroundDisabled,
cursor: 'default',
},
_e),
},
],
underlined && [
'is-underlined',
{
borderWidth: '0 0 1px 0',
borderRadius: 0,
// Underlined SearchBox has a larger padding left to vertically
align with the waffle in product
padding: '1px 0 1px 8px',
},
],
underlined &&
disabled && {
},
hasInput && 'can-clear',
className,
],
iconContainer: [
{
display: 'flex',
flexShrink: 0,
fontSize: 16,
width: 32,
color: semanticColors.inputIcon,
cursor: 'text',
},
hasFocus && {
width: 4,
},
disabled && {
color: semanticColors.inputIconDisabled,
},
!disableAnimation && {
transition: "width " + Styling_1.AnimationVariables.durationValue1,
},
showIcon &&
hasFocus && {
width: 32,
},
],
icon: [
classNames.icon,
{
opacity: 1,
},
hasFocus && {
opacity: 0,
},
!disableAnimation && {
transition: "opacity " +
Styling_1.AnimationVariables.durationValue1 + " 0s",
},
showIcon &&
hasFocus && {
opacity: 1,
},
],
clearButton: [
classNames.clearButton,
{
display: 'flex',
cursor: 'pointer',
flexBasis: '32px',
flexShrink: 0,
padding: 0,
margin: '-1px 0px',
selectors: {
'&:hover .ms-Button': {
backgroundColor: inputBackgroundHovered,
},
'&:hover .ms-Button-icon': {
color: inputIconAltHovered,
},
'.ms-Button': {
borderRadius: Utilities_1.getRTL(theme) ? '1px 0 0 1px' :
'0 1px 1px 0',
},
'.ms-Button-icon': {
color: inputIconAlt,
},
},
},
],
field: [
classNames.field,
{
border: 'none',
outline: 'none',
flex: '1 1 0px',
// The default implicit value of 'auto' prevents the input from
shrinking. Setting min-width to
// 0px allows the input element to shrink to fit the container.
minWidth: '0px',
overflow: 'hidden',
// This padding forces the text placement to round up.
paddingBottom: 0.5,
// This removes the IE specific clear button in the input since we
implemented our own
selectors: {
'::-ms-clear': {
display: 'none',
},
},
},
disabled && {
},
],
};
}
//# sourceMappingURL=SearchBox.styles.js.map
/***/ }),
/***/ 45418:
"use strict";

//# sourceMappingURL=SearchBox.types.js.map
/***/ }),
/***/ 85317:
"use strict";

/***/ }),
/***/ 93598:
"use strict";

exports.BaseSelectedItemsList = void 0;
var BaseSelectedItemsList = /** @class */ (function (_super) {
tslib_1.__extends(BaseSelectedItemsList, _super);
function BaseSelectedItemsList(basePickerProps) {
_this.addItems = function (items) {
var processedItems = _this.props.onItemSelected
? _this.props.onItemSelected(items)
: items;
var processedItemObjects = processedItems;
var processedItemPromiseLikes = processedItems;
if (processedItemPromiseLikes && processedItemPromiseLikes.then) {
processedItemPromiseLikes.then(function (resolvedProcessedItems) {
var newItems =
_this.state.items.concat(resolvedProcessedItems);
_this.updateItems(newItems);
});
}
else {
var newItems = _this.state.items.concat(processedItemObjects);
}
};
_this.removeItemAt = function (index) {
var items = _this.state.items;
if (_this._canRemoveItem(items[index])) {
if (index > -1) {
if (_this.props.onItemsDeleted) {
_this.props.onItemsDeleted([items[index]]);
}
var newItems = items.slice(0, index).concat(items.slice(index +
1));
}
}
};
_this.removeItem = function (item) {
var index = items.indexOf(item);
_this.removeItemAt(index);
};
_this.replaceItem = function (itemToReplace, itemsToReplaceWith) {
var index = items.indexOf(itemToReplace);
if (index > -1) {
var newItems = items
.slice(0, index)
.concat(itemsToReplaceWith)
.concat(items.slice(index + 1));
}
};
_this.removeItems = function (itemsToRemove) {
var itemsCanRemove = itemsToRemove.filter(function (item) { return
_this._canRemoveItem(item); });
var newItems = items.filter(function (item) { return
itemsCanRemove.indexOf(item) === -1; });
var firstItemToRemove = itemsCanRemove[0];
var index = items.indexOf(firstItemToRemove);
if (_this.props.onItemsDeleted) {
_this.props.onItemsDeleted(itemsCanRemove);
}
_this.updateItems(newItems, index);
};
_this.onCopy = function (ev) {
if (_this.props.onCopyItems && _this.selection.getSelectedCount() > 0)
{
var selectedItems = _this.selection.getSelection();
_this.copyItems(selectedItems);
}
};
_this.renderItems = function () {
var removeButtonAriaLabel = _this.props.removeButtonAriaLabel;
var onRenderItem = _this.props.onRenderItem;
return items.map(function (item, index) {
return onRenderItem({
item: item,
index: index,
key: item.key ? item.key : index,
selected: _this.selection.isIndexSelected(index),
onRemoveItem: function () { return _this.removeItem(item); },
onItemChange: _this.onItemChange,
removeButtonAriaLabel: removeButtonAriaLabel,
onCopyItem: function (itemToCopy) { return
_this.copyItems([itemToCopy]); },
});
});
};
_this.onSelectionChanged = function () {
};
_this.onItemChange = function (changedItem, index) {
if (index >= 0) {
var newItems = items;
newItems[index] = changedItem;
}
};
var items = basePickerProps.selectedItems ||
basePickerProps.defaultSelectedItems || [];
_this.state = {
items: items,
};
// Create a new selection if one is not specified
_this._defaultSelection = new Selection_1.Selection({ onSelectionChanged:
_this.onSelectionChanged });
return _this;
}
BaseSelectedItemsList.getDerivedStateFromProps = function (newProps) {
if (newProps.selectedItems) {
return { items: newProps.selectedItems };
}
return null;
};
Object.defineProperty(BaseSelectedItemsList.prototype, "items", {
get: function () {
return this.state.items;
},
enumerable: false,
configurable: true
});
BaseSelectedItemsList.prototype.removeSelectedItems = function () {
if (this.state.items.length && this.selection.getSelectedCount() > 0) {
this.removeItems(this.selection.getSelection());
}
};
/**
* Controls what happens whenever there is an action that impacts the selected
items.
* If selectedItems is provided, this will act as a controlled component and
will not update its own state.
*/
BaseSelectedItemsList.prototype.updateItems = function (items, focusIndex) {
var _this = this;
if (this.props.selectedItems) {
// If the component is a controlled component then the controlling
component will need to pass the new props
this.onChange(items);
}
else {
this.setState({ items: items }, function () {
_this._onSelectedItemsUpdated(items, focusIndex);
});
}
};
BaseSelectedItemsList.prototype.hasSelectedItems = function () {
return this.selection.getSelectedCount() > 0;
};
BaseSelectedItemsList.prototype.componentDidUpdate = function (oldProps,
oldState) {
if (this.state.items && this.state.items !== oldState.items) {
this.selection.setItems(this.state.items);
}
};
BaseSelectedItemsList.prototype.unselectAll = function () {
this.selection.setAllSelected(false);
};
BaseSelectedItemsList.prototype.highlightedItems = function () {
return this.selection.getSelection();
};
BaseSelectedItemsList.prototype.componentDidMount = function () {
};
Object.defineProperty(BaseSelectedItemsList.prototype, "selection", {
get: function () {
var _a;
return (_a = this.props.selection) !== null && _a !== void 0 ? _a :
this._defaultSelection;
},
enumerable: false,
configurable: true
});
BaseSelectedItemsList.prototype.render = function () {
return this.renderItems();
};
BaseSelectedItemsList.prototype.onChange = function (items) {
this.props.onChange(items);
}
};
BaseSelectedItemsList.prototype.copyItems = function (items) {
if (this.props.onCopyItems) {
var copyText = this.props.onCopyItems(items);
var copyInput = document.createElement('input');
document.body.appendChild(copyInput);
try {
// Try to copy the text directly to the clipboard
copyInput.value = copyText;
copyInput.select();
if (!document.execCommand('copy')) {
// The command failed. Fallback to the method below.
throw new Error();
}
}
catch (err) {
// no op
}
finally {
document.body.removeChild(copyInput);
}
}
};
BaseSelectedItemsList.prototype._onSelectedItemsUpdated = function (items,
focusIndex) {
};
BaseSelectedItemsList.prototype._canRemoveItem = function (item) {
return !this.props.canRemoveItem || this.props.canRemoveItem(item);
};
return BaseSelectedItemsList;
exports.BaseSelectedItemsList = BaseSelectedItemsList;
//# sourceMappingURL=BaseSelectedItemsList.js.map
/***/ }),
/***/ 38227:
"use strict";

//# sourceMappingURL=BaseSelectedItemsList.types.js.map
/***/ }),
/***/ 80043:
"use strict";

exports.EditingItem = void 0;
var EditingItem_styles_1 = __webpack_require__(92135);
var EditingItem = /** @class */ (function (_super) {
tslib_1.__extends(EditingItem, _super);
function EditingItem(props) {
_this._editingFloatingPicker = React.createRef();
_this._renderEditingSuggestions = function () {
var FloatingPicker = _this.props.onRenderFloatingPicker;
var floatingPickerProps = _this.props.floatingPickerProps;
if (!FloatingPicker || !floatingPickerProps) {
return React.createElement(React.Fragment, null);
}
return (React.createElement(FloatingPicker,
tslib_1.__assign({ componentRef: _this._editingFloatingPicker, onChange:
_this._onSuggestionSelected, inputElement: _this._editingInput, selectedItems:
[] }, floatingPickerProps)));
};
_this._resolveInputRef = function (ref) {
_this._editingInput = ref;
_this.forceUpdate(function () {
_this._editingInput.focus();
});
};
_this._onInputClick = function () {
_this._editingFloatingPicker.current &&
_this._editingFloatingPicker.current.showPicker(true /*updatevalue*/);
};
_this._onInputBlur = function (ev) {
if (_this._editingFloatingPicker.current && ev.relatedTarget !== null)
{
var target = ev.relatedTarget;
if (target.className.indexOf('ms-Suggestions-itemButton') === -1 &&
target.className.indexOf('ms-Suggestions-sectionButton') === -
1) {
_this._editingFloatingPicker.current.forceResolveSuggestion();
}
}
};
_this._onInputChange = function (ev) {
var value = ev.target.value;
if (value === '') {
if (_this.props.onRemoveItem) {
_this.props.onRemoveItem();
}
}
else {
_this._editingFloatingPicker.current &&
_this._editingFloatingPicker.current.onQueryStringChanged(value);
}
};
_this._onSuggestionSelected = function (item) {
_this.props.onEditingComplete(_this.props.item, item);
};
_this.state = { contextualMenuVisible: false };
return _this;
}
EditingItem.prototype.componentDidMount = function () {
var getEditingItemText = this.props.getEditingItemText;
var itemText = getEditingItemText(this.props.item);
this._editingFloatingPicker.current &&
this._editingFloatingPicker.current.onQueryStringChanged(itemText);
this._editingInput.value = itemText;
this._editingInput.focus();
};
EditingItem.prototype.render = function () {
var itemId = Utilities_1.getId();
Utilities_1.inputProperties);
var classNames = getClassNames(EditingItem_styles_1.getStyles);
return (React.createElement("div", { "aria-labelledby":
'editingItemPersona-' + itemId, className: classNames.root },
React.createElement("input", tslib_1.__assign({ autoCapitalize: 'off',
autoComplete: 'off' }, nativeProps, { ref: this._resolveInputRef, onChange:
this._onInputChange, onKeyDown: this._onInputKeyDown, onBlur: this._onInputBlur,
onClick: this._onInputClick, "data-lpignore": true, className: classNames.input,
id: itemId })),
this._renderEditingSuggestions()));
};
EditingItem.prototype._onInputKeyDown = function (ev) {
if (ev.which === Utilities_1.KeyCodes.backspace || ev.which ===
Utilities_1.KeyCodes.del) {
}
};
return EditingItem;
exports.EditingItem = EditingItem;
//# sourceMappingURL=EditingItem.js.map
/***/ }),
/***/ 92135:
"use strict";

root: 'ms-EditingItem',
input: 'ms-EditingItem-input',
};
var getStyles = function (prop) {
var theme = Styling_1.getTheme();
if (!theme) {
throw new Error('theme is undefined or null in Editing item getStyles
function.');
}
return {
root: [
classNames.root,
{
margin: '4px',
},
],
input: [
classNames.input,
{
border: '0px',
outline: 'none',
width: '100%',
selectors: {
'::-ms-clear': {
display: 'none',
},
},
},
],
};
};
//# sourceMappingURL=EditingItem.styles.js.map
/***/ }),
/***/ 86890:
"use strict";

//# sourceMappingURL=EditingItem.types.js.map
/***/ }),
/***/ 56369:
"use strict";

exports.ExtendedSelectedItem = void 0;
var ExtendedSelectedItem = /** @class */ (function (_super) {
tslib_1.__extends(ExtendedSelectedItem, _super);
function ExtendedSelectedItem(props) {
_this.persona = React.createRef();
return _this;
}
ExtendedSelectedItem.prototype.render = function () {
var _a, _b;
var _c = this.props, item = _c.item, onExpandItem = _c.onExpandItem,
onRemoveItem = _c.onRemoveItem, removeButtonAriaLabel = _c.removeButtonAriaLabel,
index = _c.index, selected = _c.selected;
return (React.createElement("div", { ref: this.persona, className:
Utilities_1.css('ms-PickerPersona-container', styles.personaContainer, (_a = {},
_a['is-selected ' + styles.personaContainerIsSelected] = selected, _a), (_b = {},
_b['is-invalid ' + styles.validationError] = !item.isValid, _b)), "data-is-
focusable": true, "data-is-sub-focuszone": true, "data-selection-index": index,
role: 'listitem', "aria-labelledby": 'selectedItemPersona-' + itemId },
React.createElement("div", { hidden: !item.canExpand || onExpandItem
=== undefined },
React.createElement(Button_1.IconButton, { onClick:
this._onClickIconButton(onExpandItem), iconProps: { iconName: 'Add', style:
{ fontSize: '14px' } }, className: Utilities_1.css('ms-PickerItem-removeButton',
styles.expandButton, styles.actionButton), ariaLabel: removeButtonAriaLabel })),
Utilities_1.css(styles.personaWrapper) },
React.createElement("div", { className: Utilities_1.css('ms-
PickerItem-content', styles.itemContent), id: 'selectedItemPersona-' + itemId },
React.createElement(Persona_1.Persona, tslib_1.__assign({},
item, { onRenderCoin: this.props.renderPersonaCoin, onRenderPrimaryText:
this.props.renderPrimaryText, size: Persona_1.PersonaSize.size32 }))),
React.createElement(Button_1.IconButton, { onClick:
this._onClickIconButton(onRemoveItem), iconProps: { iconName: 'Cancel', style:
{ fontSize: '14px' } }, className: Utilities_1.css('ms-PickerItem-removeButton',
styles.removeButton, styles.actionButton), ariaLabel: removeButtonAriaLabel }))));
};
ExtendedSelectedItem.prototype._onClickIconButton = function (action) {
if (action) {
action();
}
};
};
return ExtendedSelectedItem;
exports.ExtendedSelectedItem = ExtendedSelectedItem;
//# sourceMappingURL=ExtendedSelectedItem.js.map
/***/ }),
/***/ 67114:
"use strict";

exports.itemContainer = exports.personaDetails = exports.personaWrapper =
exports.expandButton = exports.removeButton = exports.itemContent =
exports.validationError = exports.personaContainerIsSelected = exports.actionButton
= exports.hover = exports.personaContainer = void 0;
load_themed_styles_1.loadStyles([{ "rawString": ".personaContainer_6625fd9a{border-
radius:15px;display:-webkit-inline-box;display:-ms-inline-flexbox;display:inline-
flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;background:"
}, { "theme": "themeLighterAlt", "defaultValue": "#eff6fc" }, { "rawString":
";margin:4px;cursor:default;-webkit-user-select:none;-moz-user-select:none;-ms-
user-select:none;user-select:none;vertical-
align:middle;position:relative}.personaContainer_6625fd9a::-moz-focus-
inner{border:0}.personaContainer_6625fd9a{outline:transparent}.personaContainer_662
5fd9a{position:relative}.ms-Fabric--
isFocusVisible .personaContainer_6625fd9a:focus:after{-webkit-box-sizing:border-
box;box-sizing:border-box;content:\"\";position:absolute;top:-2px;right:-
2px;bottom:-2px;left:-2px;pointer-events:none;border:1px solid " }, { "theme":
"focusBorder", "defaultValue": "#605e5c" }, { "rawString": ";border-
radius:0}.personaContainer_6625fd9a .ms-Persona-primaryText{color:" }, { "theme":
"themeDark", "defaultValue": "#005a9e" }, { "rawString": ";font-size:14px;font-
weight:400}.personaContainer_6625fd9a .ms-Persona-
primaryText.hover_6625fd9a{color:" }, { "theme": "themeDark", "defaultValue":
"#005a9e" }, { "rawString": "}@media screen and (-ms-high-contrast:active),screen
and (forced-colors:active){.personaContainer_6625fd9a .ms-Persona-
primaryText{color:HighlightText}}.personaContainer_6625fd9a .actionButton_6625fd9a:
hover{background:" }, { "theme": "themeLight", "defaultValue": "#c7e0f4" },
{ "rawString": "}.personaContainer_6625fd9a .actionButton_6625fd9a .ms-Button-
icon{color:" }, { "theme": "themeDark", "defaultValue": "#005a9e" }, { "rawString":
"}@media screen and (-ms-high-contrast:active),screen and (forced-colors:active)
{.personaContainer_6625fd9a .actionButton_6625fd9a .ms-Button-
icon{color:HighlightText}}.personaContainer_6625fd9a:hover{background:" },
{ "theme": "themeLighter", "defaultValue": "#deecf9" }, { "rawString":
"}.personaContainer_6625fd9a:hover .ms-Persona-primaryText{color:" }, { "theme":
"themeDark", "defaultValue": "#005a9e" }, { "rawString": ";font-size:14px;font-
weight:400}@media screen and (-ms-high-contrast:active),screen and (forced-
colors:active){.personaContainer_6625fd9a:hover .ms-Persona-
primaryText{color:HighlightText}}.personaContainer_6625fd9a.personaContainerIsSelec
ted_6625fd9a{background:" }, { "theme": "themePrimary", "defaultValue":
"#0078d4" }, { "rawString":
"}.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a .ms-Persona-
primaryText{color:" }, { "theme": "white", "defaultValue": "#ffffff" },
{ "rawString": "}@media screen and (-ms-high-contrast:active),screen and (forced-
colors:active){.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a .ms-
Persona-
primaryText{color:HighlightText}}.personaContainer_6625fd9a.personaContainerIsSelec
ted_6625fd9a .actionButton_6625fd9a{color:" }, { "theme": "white", "defaultValue":
"#ffffff" }, { "rawString":
"}.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a .actionButton_6625
fd9a .ms-Button-icon{color:" }, { "theme": "themeDark", "defaultValue":
"#005a9e" }, { "rawString":
"}.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a .actionButton_6625
fd9a .ms-Button-icon:hover{background:" }, { "theme": "themeDark", "defaultValue":
"#005a9e" }, { "rawString": "}@media screen and (-ms-high-contrast:active),screen
and (forced-colors:active)
{.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a .actionButton_6625f
d9a .ms-Button-icon{color:HighlightText}}@media screen and (-ms-high-
{.personaContainer_6625fd9a.personaContainerIsSelected_6625fd9a{border-
color:Highlight;background:Highlight;-ms-high-contrast-
adjust:none}}.personaContainer_6625fd9a.validationError_6625fd9a .ms-Persona-
primaryText{color:" }, { "theme": "red", "defaultValue": "#e81123" },
{ "rawString": "}.personaContainer_6625fd9a.validationError_6625fd9a .ms-Persona-
initials{font-size:20px}@media screen and (-ms-high-contrast:active),screen and
(forced-colors:active){.personaContainer_6625fd9a{border:1px solid
WindowText}}.personaContainer_6625fd9a .itemContent_6625fd9a{-webkit-box-flex:0;-
ms-flex:0 1 auto;flex:0 1 auto;min-width:0;max-
width:100%}.personaContainer_6625fd9a .removeButton_6625fd9a{border-radius:15px;-
webkit-box-flex:0;-ms-flex:0 0 auto;flex:0 0 auto;width:33px;height:33px;-ms-flex-
preferred-size:32px;flex-
basis:32px}.personaContainer_6625fd9a .expandButton_6625fd9a{border-radius:15px 0 0
15px;height:33px;width:44px;padding-right:16px;position:inherit;display:-webkit-
box;display:-ms-flexbox;display:flex;margin-right:-
17px}.personaContainer_6625fd9a .personaWrapper_6625fd9a{position:relative;display:
inherit}.personaContainer_6625fd9a .personaWrapper_6625fd9a .ms-Persona-
details{padding:0 8px}.personaContainer_6625fd9a .personaDetails_6625fd9a{-webkit-
box-flex:0;-ms-flex:0 1 auto;flex:0 1 auto}.itemContainer_6625fd9a{display:inline-
block;vertical-align:top}" }]);
exports.personaContainer = "personaContainer_6625fd9a";
exports.hover = "hover_6625fd9a";
exports.actionButton = "actionButton_6625fd9a";
exports.personaContainerIsSelected = "personaContainerIsSelected_6625fd9a";
exports.validationError = "validationError_6625fd9a";
exports.itemContent = "itemContent_6625fd9a";
exports.removeButton = "removeButton_6625fd9a";
exports.expandButton = "expandButton_6625fd9a";
exports.personaWrapper = "personaWrapper_6625fd9a";
exports.personaDetails = "personaDetails_6625fd9a";
exports.itemContainer = "itemContainer_6625fd9a";
//# sourceMappingURL=ExtendedSelectedItem.scss.js.map
/***/ }),
/***/ 79170:
"use strict";

exports.SelectedItemWithContextMenu = void 0;
var SelectedItemWithContextMenu = /** @class */ (function (_super) {
tslib_1.__extends(SelectedItemWithContextMenu, _super);
function SelectedItemWithContextMenu(props) {
_this.itemElement = React.createRef();
if (_this.props.beginEditing && !_this.props.item.isValid) {
_this.props.beginEditing(_this.props.item);
}
else {
_this.setState({ contextualMenuVisible: true });
}
};
_this._onCloseContextualMenu = function (ev) {
_this.setState({ contextualMenuVisible: false });
};
return _this;
}
SelectedItemWithContextMenu.prototype.render = function () {
return (React.createElement("div", { ref: this.itemElement, onContextMenu:
this._onClick },
this.props.renderedItem,
this.state.contextualMenuVisible ?
(React.createElement(ContextualMenu_1.ContextualMenu, { items:
this.props.menuItems, shouldFocusOnMount: true, target: this.itemElement.current,
onDismiss: this._onCloseContextualMenu, directionalHint:
ContextualMenu_1.DirectionalHint.bottomLeftEdge })) : null));
};
return SelectedItemWithContextMenu;
exports.SelectedItemWithContextMenu = SelectedItemWithContextMenu;
//# sourceMappingURL=SelectedItemWithContextMenu.js.map
/***/ }),
/***/ 37790:
"use strict";

exports.SelectedPeopleList = exports.BasePeopleSelectedItemsList = void 0;
var BaseSelectedItemsList_1 = __webpack_require__(93598);
var ExtendedSelectedItem_1 = __webpack_require__(56369);
var SelectedItemWithContextMenu_1 = __webpack_require__(79170);
var EditingItem_1 = __webpack_require__(80043);
/**
* {@docCategory SelectedPeopleList}
*/
var BasePeopleSelectedItemsList = /** @class */ (function (_super) {
tslib_1.__extends(BasePeopleSelectedItemsList, _super);
function BasePeopleSelectedItemsList() {
}
return BasePeopleSelectedItemsList;
}(BaseSelectedItemsList_1.BaseSelectedItemsList));
exports.BasePeopleSelectedItemsList = BasePeopleSelectedItemsList;
/**
* Standard People Picker.
*/
var SelectedPeopleList = /** @class */ (function (_super) {
tslib_1.__extends(SelectedPeopleList, _super);
function SelectedPeopleList() {
_this.renderItems = function () {
return items.map(function (item, index) { return
_this._renderItem(item, index); });
};
_this._beginEditing = function (item) {
item.isEditing = true;
};
_this._completeEditing = function (oldItem, newItem) {
oldItem.isEditing = false;
_this.replaceItem(oldItem, newItem);
};
return _this;
}
SelectedPeopleList.prototype._renderItem = function (item, index) {
var _this = this;
var removeButtonAriaLabel = this.props.removeButtonAriaLabel;
var expandGroup = this.props.onExpandGroup;
var props = {
item: item,
index: index,
selected: this.selection.isIndexSelected(index),
onItemChange: this.onItemChange,
onCopyItem: function (itemToCopy) { return
_this.copyItems([itemToCopy]); },
onExpandItem: expandGroup ? function () { return expandGroup(item); } :
undefined,
menuItems: this._createMenuItems(item),
};
var hasContextMenu = props.menuItems.length > 0;
if (item.isEditing && hasContextMenu) {
return (React.createElement(EditingItem_1.EditingItem,
tslib_1.__assign({}, props, { onRenderFloatingPicker:
this.props.onRenderFloatingPicker, floatingPickerProps:
this.props.floatingPickerProps, onEditingComplete: this._completeEditing,
getEditingItemText: this.props.getEditingItemText })));
}
else {
// This cast is here because we are guaranteed that onRenderItem is set
// from static defaultProps
// TODO: Move this component to composition with required onRenderItem
to remove
// this cast.
var onRenderItem = this.props.onRenderItem;
var renderedItem = onRenderItem(props);
return hasContextMenu ?
(React.createElement(SelectedItemWithContextMenu_1.SelectedItemWithContextMenu,
{ key: props.key, renderedItem: renderedItem, beginEditing: this._beginEditing,
menuItems: this._createMenuItems(props.item), item: props.item })) :
(renderedItem);
}
};
SelectedPeopleList.prototype._createMenuItems = function (item) {
var _this = this;
var menuItems = [];
if (this.props.editMenuItemText && this.props.getEditingItemText) {
menuItems.push({
key: 'Edit',
text: this.props.editMenuItemText,
onClick: function (ev, menuItem) {
_this._beginEditing(menuItem.data);
},
data: item,
});
}
if (this.props.removeMenuItemText) {
menuItems.push({
key: 'Remove',
text: this.props.removeMenuItemText,
_this.removeItem(menuItem.data);
},
data: item,
});
}
if (this.props.copyMenuItemText) {
menuItems.push({
key: 'Copy',
text: this.props.copyMenuItemText,
if (_this.props.onCopyItems) {
_this.copyItems([menuItem.data]);
}
},
data: item,
});
}
return menuItems;
};
SelectedPeopleList.defaultProps = {
onRenderItem: function (props) { return
React.createElement(ExtendedSelectedItem_1.ExtendedSelectedItem,
tslib_1.__assign({}, props)); },
};
return SelectedPeopleList;
}(BasePeopleSelectedItemsList));
exports.SelectedPeopleList = SelectedPeopleList;
//# sourceMappingURL=SelectedPeopleList.js.map
/***/ }),
/***/ 45155:
"use strict";

/***/ }),
/***/ 64413:
"use strict";

exports.SeparatorBase = void 0;
exports.SeparatorBase = React.forwardRef(function (props, ref) {
vertical = props.vertical, alignContent = props.alignContent, children =
props.children;
theme: theme,
alignContent: alignContent,
vertical: vertical,
});
React.createElement("div", { className: classNames.content, role:
"separator", "aria-orientation": vertical ? 'vertical' : 'horizontal' },
children)));
});
//# sourceMappingURL=Separator.base.js.map
/***/ }),
/***/ 92394:
"use strict";

exports.Separator = void 0;
var Separator_styles_1 = __webpack_require__(35118);
var Separator_base_1 = __webpack_require__(64413);
exports.Separator = Utilities_1.styled(Separator_base_1.SeparatorBase,
Separator_styles_1.getStyles, undefined, {
scope: 'Separator',
});
exports.Separator.displayName = 'Separator';
//# sourceMappingURL=Separator.js.map
/***/ }),
/***/ 35118:
"use strict";

var _a, _b;
var theme = props.theme, alignContent = props.alignContent, vertical =
props.vertical, className = props.className;
var alignStart = alignContent === 'start';
var alignCenter = alignContent === 'center';
var alignEnd = alignContent === 'end';
return {
root: [
theme.fonts.medium,
{
},
alignContent && {
textAlign: alignContent,
},
!alignContent && {
},
vertical &&
(alignCenter || !alignContent) && {
},
vertical &&
alignStart && {
},
vertical &&
alignEnd && {
verticalAlign: 'bottom',
},
vertical && {
padding: '0 4px',
height: 'inherit',
display: 'table-cell',
zIndex: 1,
selectors: {
':after': (_a = {
backgroundColor: theme.palette.neutralLighter,
width: '1px',
content: '""',
top: '0',
bottom: '0',
left: '50%',
right: '0',
zIndex: -1
},
},
_a),
},
},
!vertical && {
padding: '4px 0',
selectors: {
':before': (_b = {
backgroundColor: theme.palette.neutralLighter,
height: '1px',
content: '""',
display: 'block',
top: '50%',
bottom: '0',
left: '0',
right: '0'
},
},
_b),
},
},
className,
],
content: [
{
padding: '0 12px',
background: theme.semanticColors.bodyBackground,
},
vertical && {
padding: '12px 0',
},
],
};
};
//# sourceMappingURL=Separator.styles.js.map
/***/ }),
/***/ 13577:
"use strict";

//# sourceMappingURL=Separator.types.js.map
/***/ }),
/***/ 77238:
"use strict";

/***/ }),
/***/ 11386:
"use strict";

exports.ShimmerBase = void 0;
var ShimmerElementsGroup_1 = __webpack_require__(1542);
var TRANSITION_ANIMATION_INTERVAL = 200; /* ms */
var COMPONENT_NAME = 'Shimmer';
/**
* {@docCategory Shimmer}
*/
exports.ShimmerBase = React.forwardRef(function (props, ref) {
var styles = props.styles, shimmerElements = props.shimmerElements, children =
props.children, width = props.width, className = props.className,
customElementsGroup = props.customElementsGroup, theme = props.theme, ariaLabel =
props.ariaLabel, shimmerColors = props.shimmerColors, _a = props.isDataLoaded,
isDataLoaded = _a === void 0 ? false : _a;
theme: theme,
isDataLoaded: isDataLoaded,
transitionAnimationInterval: TRANSITION_ANIMATION_INTERVAL,
shimmerColor: shimmerColors && shimmerColors.shimmer,
shimmerWaveColor: shimmerColors && shimmerColors.shimmerWave,
});
lastTimeoutId: 0,
});
var _b = react_hooks_1.useSetTimeout(), setTimeout = _b.setTimeout,
clearTimeout = _b.clearTimeout;
/**
* Flag for knowing when to remove the shimmerWrapper from the DOM.
*/
var _c = React.useState(isDataLoaded), contentLoaded = _c[0], setContentLoaded
= _c[1];
var divStyleProp = { width: width ? width : '100%' };
if (isDataLoaded !== contentLoaded) {
if (isDataLoaded) {
internalState.lastTimeoutId = setTimeout(function () {
setContentLoaded(true);
}, TRANSITION_ANIMATION_INTERVAL);
return function () { return
clearTimeout(internalState.lastTimeoutId); };
}
else {
setContentLoaded(false);
}
}
// eslint-disable-next-line react-hooks/exhaustive-deps -- Should only run
when isDataLoaded changes.
}, [isDataLoaded]);
return (React.createElement("div", tslib_1.__assign({}, divProps, { className:
classNames.root, ref: ref }),
!contentLoaded && (React.createElement("div", { style: divStyleProp,
className: classNames.shimmerWrapper },
React.createElement("div", { className: classNames.shimmerGradient }),
customElementsGroup ? (customElementsGroup) :
(React.createElement(ShimmerElementsGroup_1.ShimmerElementsGroup,
{ shimmerElements: shimmerElements, backgroundColor: shimmerColors &&
shimmerColors.background })))),
children && React.createElement("div", { className:
classNames.dataWrapper }, children),
ariaLabel && !isDataLoaded && (React.createElement("div", { role: "status",
"aria-live": "polite" },
React.createElement("div", { className: classNames.screenReaderText
}, ariaLabel))))));
});
exports.ShimmerBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=Shimmer.base.js.map
/***/ }),
/***/ 524:
"use strict";

exports.Shimmer = void 0;
var Shimmer_styles_1 = __webpack_require__(68056);
var Shimmer_base_1 = __webpack_require__(11386);
exports.Shimmer = Utilities_1.styled(Shimmer_base_1.ShimmerBase,
Shimmer_styles_1.getStyles, undefined, {
scope: 'Shimmer',
});
//# sourceMappingURL=Shimmer.js.map
/***/ }),
/***/ 68056:
"use strict";

root: 'ms-Shimmer-container',
shimmerWrapper: 'ms-Shimmer-shimmerWrapper',
shimmerGradient: 'ms-Shimmer-shimmerGradient',
dataWrapper: 'ms-Shimmer-dataWrapper',
};
var BACKGROUND_OFF_SCREEN_POSITION = '100%';
var shimmerAnimation = Utilities_1.memoizeFunction(function () {
'0%': {
transform: "translateX(-" + BACKGROUND_OFF_SCREEN_POSITION + ")",
},
'100%': {
transform: "translateX(" + BACKGROUND_OFF_SCREEN_POSITION + ")",
},
});
});
var shimmerAnimationRTL = Utilities_1.memoizeFunction(function () {
'100%': {
},
'0%': {
transform: "translateX(" + BACKGROUND_OFF_SCREEN_POSITION + ")",
},
});
});
var _a;
var isDataLoaded = props.isDataLoaded, className = props.className, theme =
props.theme, transitionAnimationInterval = props.transitionAnimationInterval,
shimmerColor = props.shimmerColor, shimmerWaveColor = props.shimmerWaveColor;
return {
root: [
classNames.root,
theme.fonts.medium,
{
height: 'auto',
},
className,
],
shimmerWrapper: [
classNames.shimmerWrapper,
{
overflow: 'hidden',
transform: 'translateZ(0)',
backgroundColor: shimmerColor || semanticColors.disabledBackground,
transition: "opacity " + transitionAnimationInterval + "ms",
selectors: (_a = {
'> *': {
transform: 'translateZ(0)',
}
},
tslib_1.__assign({ background: "WindowText\n linear-
gradient(\n to right,\n
transparent 0%,\n Window 50%,\n
transparent 100%)\n 0 0 / 90% 100%\n
no-repeat" }, Styling_1.getHighContrastNoAdjustStyle()),
_a),
},
isDataLoaded && {
opacity: '0',
top: '0',
bottom: '0',
left: '0',
right: '0',
},
],
shimmerGradient: [
classNames.shimmerGradient,
{
top: 0,
left: 0,
width: '100%',
height: '100%',
background: (shimmerColor || semanticColors.disabledBackground) +
"\n linear-gradient(\n to right,\n
" + (shimmerColor || semanticColors.disabledBackground) + " 0%,\n
" + (shimmerWaveColor || semanticColors.bodyDivider) + " 50%,\n
" + (shimmerColor || semanticColors.disabledBackground) + " 100%)\n
0 0 / 90% 100%\n no-repeat",
animationTimingFunction: 'ease-in-out',
animationIterationCount: 'infinite',
animationName: isRTL ? shimmerAnimationRTL() : shimmerAnimation(),
},
],
dataWrapper: [
classNames.dataWrapper,
{
top: '0',
bottom: '0',
left: '0',
right: '0',
opacity: '0',
background: 'none',
border: 'none',
transition: "opacity " + transitionAnimationInterval + "ms",
},
isDataLoaded && {
opacity: '1',
position: 'static',
},
],
};
}
//# sourceMappingURL=Shimmer.styles.js.map
/***/ }),
/***/ 85635:
"use strict";

exports.ShimmerElementsDefaultHeights = exports.ShimmerElementType = void 0;
/**
* Describes the possible types for shimmer elements used.
*/
var ShimmerElementType;
(function (ShimmerElementType) {
/**
* Line element type
*/
ShimmerElementType[ShimmerElementType["line"] = 1] = "line";
/**
* Circle element type
*/
ShimmerElementType[ShimmerElementType["circle"] = 2] = "circle";
/**
* Gap element type
*/
ShimmerElementType[ShimmerElementType["gap"] = 3] = "gap";
})(ShimmerElementType = exports.ShimmerElementType || (exports.ShimmerElementType =
{}));
/**
* Describes the default heights for shimmer elements when omitted in
implementation.
*/
var ShimmerElementsDefaultHeights;
(function (ShimmerElementsDefaultHeights) {
/**
* Default height of the line element when not provided by user: 16px
*/
ShimmerElementsDefaultHeights[ShimmerElementsDefaultHeights["line"] = 16] =
"line";
/**
* Default height of the gap element when not provided by user: 16px
*/
ShimmerElementsDefaultHeights[ShimmerElementsDefaultHeights["gap"] = 16] =
"gap";
/**
* Default height of the circle element when not provided by user: 24px
*/
ShimmerElementsDefaultHeights[ShimmerElementsDefaultHeights["circle"] = 24] =
"circle";
})(ShimmerElementsDefaultHeights = exports.ShimmerElementsDefaultHeights ||
(exports.ShimmerElementsDefaultHeights = {}));
//# sourceMappingURL=Shimmer.types.js.map
/***/ }),
/***/ 57451:
"use strict";
exports.ShimmerCircleBase = void 0;
var ShimmerCircleBase = function (props) {
var height = props.height, styles = props.styles, borderStyle =
props.borderStyle, theme = props.theme;
theme: theme,
height: height,
borderStyle: borderStyle,
});
React.createElement("svg", { viewBox: "0 0 10 10", width: height, height:
height, className: classNames.svg },
React.createElement("path", { d: "M0,0 L10,0 L10,10 L0,10 L0,0 Z M0,5
C0,7.76142375 2.23857625,10 5,10 C7.76142375,10 10,7.76142375 10,5 C10,2.23857625
7.76142375,2.22044605e-16 5,0 C2.23857625,-2.22044605e-16 0,2.23857625 0,5 L0,5
Z" }))));
};
exports.ShimmerCircleBase = ShimmerCircleBase;
//# sourceMappingURL=ShimmerCircle.base.js.map
/***/ }),
/***/ 79508:
"use strict";

exports.ShimmerCircle = void 0;
var ShimmerCircle_styles_1 = __webpack_require__(73400);
var ShimmerCircle_base_1 = __webpack_require__(57451);
exports.ShimmerCircle = Utilities_1.styled(ShimmerCircle_base_1.ShimmerCircleBase,
ShimmerCircle_styles_1.getStyles, undefined, { scope: 'ShimmerCircle' });
//# sourceMappingURL=ShimmerCircle.js.map
/***/ }),
/***/ 73400:
"use strict";

root: 'ms-ShimmerCircle-root',
svg: 'ms-ShimmerCircle-svg',
};
var _a, _b;
var height = props.height, borderStyle = props.borderStyle, theme =
props.theme;
var globalClassNames = Styling_1.getGlobalClassNames(GlobalClassNames, theme);
var borderStyles = borderStyle || {};
return {
root: [
globalClassNames.root,
theme.fonts.medium,
{
width: height + "px",
height: height + "px",
minWidth: height + "px",
borderTopStyle: 'solid',
borderBottomStyle: 'solid',
borderColor: semanticColors.bodyBackground,
},
_a),
},
borderStyles,
],
svg: [
globalClassNames.svg,
{
display: 'block',
fill: semanticColors.bodyBackground,
fill: 'Window',
},
_b),
},
],
};
}
//# sourceMappingURL=ShimmerCircle.styles.js.map
/***/ }),
/***/ 54234:
"use strict";

//# sourceMappingURL=ShimmerCircle.types.js.map
/***/ }),
/***/ 3724:
"use strict";
exports.ShimmerElementsGroupBase = void 0;
var Shimmer_types_1 = __webpack_require__(85635);
var ShimmerLine_1 = __webpack_require__(81332);
var ShimmerGap_1 = __webpack_require__(90147);
var ShimmerCircle_1 = __webpack_require__(79508);
/**
*/
var ShimmerElementsGroupBase = function (props) {
var styles = props.styles, _a = props.width, width = _a === void 0 ? 'auto' :
_a, shimmerElements = props.shimmerElements, _b = props.rowHeight, rowHeight = _b
=== void 0 ? findMaxElementHeight(shimmerElements || []) : _b, _c = props.flexWrap,
flexWrap = _c === void 0 ? false : _c, theme = props.theme, backgroundColor =
props.backgroundColor;
theme: theme,
flexWrap: flexWrap,
});
return (React.createElement("div", { style: { width: width }, className:
classNames.root }, getRenderedElements(shimmerElements, backgroundColor,
rowHeight)));
};
exports.ShimmerElementsGroupBase = ShimmerElementsGroupBase;
function getRenderedElements(shimmerElements, backgroundColor, rowHeight) {
var renderedElements = shimmerElements ? (shimmerElements.map(
// false positive
// eslint-disable-next-line array-callback-return
function (element, index) {
var type = element.type, filteredElem = tslib_1.__rest(element, ["type"]);
var verticalAlign = filteredElem.verticalAlign, height =
filteredElem.height;
var styles = getElementStyles(verticalAlign, type, height, backgroundColor,
rowHeight);
switch (element.type) {
case Shimmer_types_1.ShimmerElementType.circle:
return React.createElement(ShimmerCircle_1.ShimmerCircle,
tslib_1.__assign({ key: index }, filteredElem, { styles: styles }));
case Shimmer_types_1.ShimmerElementType.gap:
return React.createElement(ShimmerGap_1.ShimmerGap,
case Shimmer_types_1.ShimmerElementType.line:
return React.createElement(ShimmerLine_1.ShimmerLine,
}
})) : (React.createElement(ShimmerLine_1.ShimmerLine, { height:
Shimmer_types_1.ShimmerElementsDefaultHeights.line }));
return renderedElements;
}
var getElementStyles = Utilities_1.memoizeFunction(function (verticalAlign,
elementType, elementHeight, backgroundColor, rowHeight) {
var dif = rowHeight && elementHeight ? rowHeight - elementHeight : 0;
var borderStyle;
if (!verticalAlign || verticalAlign === 'center') {
borderStyle = {
borderBottomWidth: (dif ? Math.floor(dif / 2) : 0) + "px",
borderTopWidth: (dif ? Math.ceil(dif / 2) : 0) + "px",
};
}
else if (verticalAlign && verticalAlign === 'top') {
borderStyle = {
borderBottomWidth: dif + "px",
borderTopWidth: "0px",
};
}
else if (verticalAlign && verticalAlign === 'bottom') {
borderStyle = {
borderBottomWidth: "0px",
borderTopWidth: dif + "px",
};
}
if (backgroundColor) {
switch (elementType) {
return {
root: tslib_1.__assign(tslib_1.__assign({}, borderStyle),
{ borderColor: backgroundColor }),
svg: { fill: backgroundColor },
};
return {
{ borderColor: backgroundColor, backgroundColor: backgroundColor }),
};
return {
{ borderColor: backgroundColor }),
topLeftCorner: { fill: backgroundColor },
topRightCorner: { fill: backgroundColor },
bottomLeftCorner: { fill: backgroundColor },
bottomRightCorner: { fill: backgroundColor },
};
}
}
return {
root: borderStyle,
};
});
/**
* User should not worry to provide which of the elements is the highest so we do
the calculation for him.
* Plus if user forgot to specify the height we assign their defaults.
*/
function findMaxElementHeight(shimmerElements) {
var shimmerElementsDefaulted = shimmerElements.map(function (element) {
switch (element.type) {
if (!element.height) {
element.height =
Shimmer_types_1.ShimmerElementsDefaultHeights.circle;
}
break;
element.height =
Shimmer_types_1.ShimmerElementsDefaultHeights.line;
}
break;
element.height =
Shimmer_types_1.ShimmerElementsDefaultHeights.gap;
}
break;
}
return element;
});
var rowHeight = shimmerElementsDefaulted.reduce(function (acc, next) {
return next.height ? (next.height > acc ? next.height : acc) : acc;
}, 0);
return rowHeight;
}
//# sourceMappingURL=ShimmerElementsGroup.base.js.map
/***/ }),
/***/ 1542:
"use strict";

exports.ShimmerElementsGroup = void 0;
var ShimmerElementsGroup_base_1 = __webpack_require__(3724);
var ShimmerElementsGroup_styles_1 = __webpack_require__(80159);
exports.ShimmerElementsGroup =
Utilities_1.styled(ShimmerElementsGroup_base_1.ShimmerElementsGroupBase,
ShimmerElementsGroup_styles_1.getStyles, undefined, { scope: 'ShimmerElementsGroup'
});
//# sourceMappingURL=ShimmerElementsGroup.js.map
/***/ }),
/***/ 80159:
"use strict";

root: 'ms-ShimmerElementsGroup-root',
};
var flexWrap = props.flexWrap, theme = props.theme;
return {
root: [
classNames.root,
theme.fonts.medium,
{
display: 'flex',
flexWrap: flexWrap ? 'wrap' : 'nowrap',
},
],
};
}
//# sourceMappingURL=ShimmerElementsGroup.styles.js.map
/***/ }),
/***/ 91704:
"use strict";

//# sourceMappingURL=ShimmerElementsGroup.types.js.map
/***/ }),
/***/ 77774:
"use strict";

exports.ShimmerGapBase = void 0;
/**
*/
var ShimmerGapBase = function (props) {
var height = props.height, styles = props.styles, _a = props.width, width = _a
=== void 0 ? '10px' : _a, borderStyle = props.borderStyle, theme = props.theme;
theme: theme,
height: height,
});
return (React.createElement("div", { style: { width: width, minWidth: typeof
width === 'number' ? width + "px" : 'auto' }, className: classNames.root }));
};
exports.ShimmerGapBase = ShimmerGapBase;
//# sourceMappingURL=ShimmerGap.base.js.map
/***/ }),
/***/ 90147:
"use strict";
exports.ShimmerGap = void 0;
var ShimmerGap_base_1 = __webpack_require__(77774);
var ShimmerGap_styles_1 = __webpack_require__(84379);
exports.ShimmerGap = Utilities_1.styled(ShimmerGap_base_1.ShimmerGapBase,
ShimmerGap_styles_1.getStyles, undefined, {
scope: 'ShimmerGap',
});
//# sourceMappingURL=ShimmerGap.js.map
/***/ }),
/***/ 84379:
"use strict";

root: 'ms-ShimmerGap-root',
};
var _a;
props.theme;
return {
root: [
theme.fonts.medium,
{
},
_a),
},
borderStyles,
],
};
}
//# sourceMappingURL=ShimmerGap.styles.js.map
/***/ }),
/***/ 23782:
"use strict";

//# sourceMappingURL=ShimmerGap.types.js.map
/***/ }),
/***/ 12233:
"use strict";

exports.ShimmerLineBase = void 0;
/**
*/
var ShimmerLineBase = function (props) {
var height = props.height, styles = props.styles, _a = props.width, width = _a
=== void 0 ? '100%' : _a, borderStyle = props.borderStyle, theme = props.theme;
theme: theme,
height: height,
});
return (React.createElement("div", { style: { width: width, minWidth: typeof
width === 'number' ? width + "px" : 'auto' }, className: classNames.root },
React.createElement("svg", { width: "2", height: "2", className:
classNames.topLeftCorner },
React.createElement("path", { d: "M0 2 A 2 2, 0, 0, 1, 2 0 L 0 0
Z" })),
classNames.topRightCorner },
Z" })),
classNames.bottomRightCorner },
Z" })),
classNames.bottomLeftCorner },
Z" }))));
};
exports.ShimmerLineBase = ShimmerLineBase;
//# sourceMappingURL=ShimmerLine.base.js.map
/***/ }),
/***/ 81332:
"use strict";

exports.ShimmerLine = void 0;
var ShimmerLine_base_1 = __webpack_require__(12233);
var ShimmerLine_styles_1 = __webpack_require__(858);
exports.ShimmerLine = Utilities_1.styled(ShimmerLine_base_1.ShimmerLineBase,
ShimmerLine_styles_1.getStyles, undefined, {
scope: 'ShimmerLine',
});
//# sourceMappingURL=ShimmerLine.js.map
/***/ }),
/***/ 858:
"use strict";

root: 'ms-ShimmerLine-root',
topLeftCorner: 'ms-ShimmerLine-topLeftCorner',
topRightCorner: 'ms-ShimmerLine-topRightCorner',
bottomLeftCorner: 'ms-ShimmerLine-bottomLeftCorner',
bottomRightCorner: 'ms-ShimmerLine-bottomRightCorner',
};
var _a;
props.theme;
var sharedCornerStyles = {
fill: semanticColors.bodyBackground,
};
return {
root: [
theme.fonts.medium,
{
borderWidth: 0,
selectors: {
'> *': {
fill: 'Window',
},
},
},
_a),
},
borderStyles,
],
topLeftCorner: [
globalClassNames.topLeftCorner,
{
top: '0',
left: '0',
},
sharedCornerStyles,
],
topRightCorner: [
globalClassNames.topRightCorner,
{
top: '0',
right: '0',
},
sharedCornerStyles,
],
bottomRightCorner: [
globalClassNames.bottomRightCorner,
{
bottom: '0',
right: '0',
},
sharedCornerStyles,
],
bottomLeftCorner: [
globalClassNames.bottomLeftCorner,
{
bottom: '0',
left: '0',
},
sharedCornerStyles,
],
};
}
//# sourceMappingURL=ShimmerLine.styles.js.map
/***/ }),
/***/ 68076:
"use strict";

//# sourceMappingURL=ShimmerLine.types.js.map
/***/ }),
/***/ 13486:
"use strict";

/***/ }),
/***/ 62418:
"use strict";

exports.SliderBase = void 0;
var useSlider_1 = __webpack_require__(13330);
var COMPONENT_NAME = 'SliderBase';
exports.SliderBase = React.forwardRef(function (props, ref) {
var slotProps = useSlider_1.useSlider(props, ref);
if (false) {}
return (React.createElement("div", tslib_1.__assign({}, slotProps.root),
slotProps && React.createElement(Label_1.Label, tslib_1.__assign({},
slotProps.label)),
React.createElement("div", tslib_1.__assign({}, slotProps.container),
props.ranged &&
(props.vertical
? slotProps.valueLabel && React.createElement(Label_1.Label,
tslib_1.__assign({}, slotProps.valueLabel))
: slotProps.lowerValueLabel &&
React.createElement(Label_1.Label, tslib_1.__assign({},
slotProps.lowerValueLabel))),
React.createElement("div", tslib_1.__assign({}, slotProps.sliderBox),
React.createElement("div", tslib_1.__assign({},
slotProps.sliderLine),
props.ranged && React.createElement("span",
tslib_1.__assign({}, slotProps.lowerValueThumb)),
React.createElement("span", tslib_1.__assign({},
slotProps.thumb)),
slotProps.zeroTick && React.createElement("span",
tslib_1.__assign({}, slotProps.zeroTick)),
slotProps.bottomInactiveTrack)),
slotProps.activeTrack)),
slotProps.topInactiveTrack)))),
props.ranged && props.vertical
? slotProps.lowerValueLabel && React.createElement(Label_1.Label,
tslib_1.__assign({}, slotProps.lowerValueLabel))
: slotProps.valueLabel && React.createElement(Label_1.Label,
tslib_1.__assign({}, slotProps.valueLabel))),
React.createElement(utilities_1.FocusRects, null)));
});
exports.SliderBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=Slider.base.js.map
/***/ }),
/***/ 52275:
"use strict";

exports.Slider = void 0;
var Slider_base_1 = __webpack_require__(62418);
var Slider_styles_1 = __webpack_require__(79713);
exports.Slider = utilities_1.styled(Slider_base_1.SliderBase,
Slider_styles_1.getStyles, undefined, {
scope: 'Slider',
});
//# sourceMappingURL=Slider.js.map
/***/ }),
/***/ 79713:
"use strict";

root: 'ms-Slider',
enabled: 'ms-Slider-enabled',
disabled: 'ms-Slider-disabled',
row: 'ms-Slider-row',
column: 'ms-Slider-column',
container: 'ms-Slider-container',
slideBox: 'ms-Slider-slideBox',
line: 'ms-Slider-line',
thumb: 'ms-Slider-thumb',
activeSection: 'ms-Slider-active',
inactiveSection: 'ms-Slider-inactive',
valueLabel: 'ms-Slider-value',
showValue: 'ms-Slider-showValue',
showTransitions: 'ms-Slider-showTransitions',
zeroTick: 'ms-Slider-zeroTick',
};
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
var className = props.className, titleLabelClassName =
props.titleLabelClassName, theme = props.theme, vertical = props.vertical, disabled
= props.disabled, showTransitions = props.showTransitions, showValue =
props.showValue, ranged = props.ranged;
theme);
/** Tokens:
* The word "active" in the token refers to the selected section of the
slider
* The word "inactive" in the token refers to the unselected section of the
slider */
var pressedActiveSectionColor = semanticColors.inputBackgroundCheckedHovered;
var hoveredActiveSectionColor = semanticColors.inputBackgroundChecked;
var hoveredPressedinactiveSectionColor = palette.neutralSecondaryAlt;
var restActiveSectionColor = palette.neutralPrimary;
var restInactiveSectionColor = palette.neutralSecondaryAlt;
var disabledActiveSectionColor = semanticColors.disabledText;
var disabledInactiveSectionColor = semanticColors.disabledBackground;
var thumbBackgroundColor = semanticColors.inputBackground;
var thumbBorderColor = semanticColors.smallInputBorder;
var thumbDisabledBorderColor = semanticColors.disabledBorder;
var slideBoxActiveSectionStyles = !disabled && {
backgroundColor: pressedActiveSectionColor,
},
_a),
};
var slideBoxInactiveSectionStyles = !disabled && {
backgroundColor: hoveredPressedinactiveSectionColor,
},
_b),
};
var slideHoverSectionStyles = !disabled && {
backgroundColor: hoveredActiveSectionColor,
},
_c),
};
var slideBoxActiveThumbStyles = !disabled && {
border: "2px solid " + pressedActiveSectionColor,
},
_d),
};
var slideBoxActiveZeroTickStyles = !props.disabled && {
backgroundColor: semanticColors.inputPlaceholderBackgroundChecked,
},
_e),
};
return {
root:
tslib_1.__spreadArray(tslib_1.__spreadArray(tslib_1.__spreadArray(tslib_1.__spreadA
rray(tslib_1.__spreadArray([
classNames.root,
theme.fonts.medium,
{
userSelect: 'none',
},
vertical && {
marginRight: 8,
}
], [!disabled ? classNames.enabled : undefined]), [disabled ?
classNames.disabled : undefined]), [!vertical ? classNames.row : undefined]),
[vertical ? classNames.column : undefined]), [
className,
]),
titleLabel: [
{
padding: 0,
},
titleLabelClassName,
],
container: [
{
display: 'flex',
flexWrap: 'nowrap',
},
vertical && {
height: '100%',
margin: '8px 0',
},
],
slideBox: tslib_1.__spreadArray(tslib_1.__spreadArray([
classNames.slideBox,
!ranged && style_utilities_1.getFocusStyle(theme),
{
border: 'none',
flexGrow: 1,
lineHeight: 28,
display: 'flex',
_f[":active ." + classNames.activeSection] =
slideBoxActiveSectionStyles,
_f[":hover ." + classNames.activeSection] =
slideHoverSectionStyles,
_f[":active ." + classNames.inactiveSection] =
slideBoxInactiveSectionStyles,
_f[":hover ." + classNames.inactiveSection] =
slideBoxInactiveSectionStyles,
_f[":active ." + classNames.thumb] = slideBoxActiveThumbStyles,
_f[":hover ." + classNames.thumb] = slideBoxActiveThumbStyles,
_f[":active ." + classNames.zeroTick] =
slideBoxActiveZeroTickStyles,
_f[":hover ." + classNames.zeroTick] =
slideBoxActiveZeroTickStyles,
},
_f),
},
vertical
? {
height: '100%',
width: 28,
padding: '8px 0', // Make room for thumb at bottom of line
}
: {
height: 28,
width: 'auto',
padding: '0 8px', // Make room for thumb at ends of line
}
], [showValue ? classNames.showValue : undefined]), [showTransitions ?
classNames.showTransitions : undefined]),
thumb: [
classNames.thumb,
ranged && style_utilities_1.getFocusStyle(theme, { inset: -4 }),
{
borderWidth: 2,
borderColor: thumbBorderColor,
borderRadius: 10,
background: thumbBackgroundColor,
display: 'block',
width: 16,
height: 16,
},
vertical
? {
left: -6,
margin: '0 auto',
transform: 'translateY(8px)',
}
: {
top: -6,
transform: utilities_1.getRTL(theme) ? 'translateX(50%)' :
'translateX(-50%)',
},
showTransitions && {
transition: "left " +
},
disabled && {
borderColor: thumbDisabledBorderColor,
},
_g),
},
],
line: [
classNames.line,
{
display: 'flex',
},
vertical
? {
height: '100%',
width: 4,
margin: '0 auto',
flexDirection: 'column-reverse',
}
: {
width: '100%',
},
],
lineContainer: [
{
borderRadius: 4,
},
vertical
? {
width: 4,
height: '100%',
}
: {
height: 4,
width: '100%',
},
],
activeSection: [
classNames.activeSection,
{
background: restActiveSectionColor,
_h[style_utilities_1.HighContrastSelector] = {
},
_h),
},
transition: "width " +
},
disabled && {
background: disabledActiveSectionColor,
_j[style_utilities_1.HighContrastSelector] = {
},
_j),
},
],
inactiveSection: [
classNames.inactiveSection,
{
background: restInactiveSectionColor,
},
_k),
},
transition: "width " +
},
disabled && {
background: disabledInactiveSectionColor,
_l[style_utilities_1.HighContrastSelector] = {
},
_l),
},
],
zeroTick: [
classNames.zeroTick,
{
background: semanticColors.disabledBorder,
_m[style_utilities_1.HighContrastSelector] = {
},
_m),
},
props.disabled && {
background: semanticColors.disabledBackground,
_o[style_utilities_1.HighContrastSelector] = {
},
_o),
},
props.vertical
? {
width: '16px',
height: '1px',
transform: utilities_1.getRTL(theme) ? 'translateX(6px)' :
'translateX(-6px)',
}
: {
width: '1px',
height: '16px',
transform: 'translateY(-6px)',
},
],
valueLabel: [
classNames.valueLabel,
{
flexShrink: 1,
width: 30,
lineHeight: '1', // using a string here meaning it's relative to
the size of the font
},
vertical
? {
margin: '0 auto',
width: 40,
}
: {
margin: '0 8px',
width: 40,
},
],
};
};
//# sourceMappingURL=Slider.styles.js.map
/***/ }),
/***/ 93643:
"use strict";

//# sourceMappingURL=Slider.types.js.map
/***/ }),
/***/ 37242:
"use strict";

/***/ }),
/***/ 13330:
"use strict";

exports.useSlider = exports.ONKEYDOWN_TIMEOUT_DURATION = void 0;
exports.ONKEYDOWN_TIMEOUT_DURATION = 1000;
var getSlotStyleFn = function (sty) {
return function (value) {
var _a;
return _a = {},
_a[sty] = value + "%",
_a;
};
};
var getPercent = function (value, sliderMin, sliderMax) {
return sliderMax === sliderMin ? 0 : ((value - sliderMin) / (sliderMax -
sliderMin)) * 100;
};
var useComponentRef = function (props, thumb, value, range) {
get value() {
return value;
},
get range() {
return range;
},
if (thumb.current) {
thumb.current.focus();
}
},
}); }, [thumb, value, range]);
};
var useSlider = function (props, ref) {
var _a = props.step, step = _a === void 0 ? 1 : _a, className =
props.className, _b = props.disabled, disabled = _b === void 0 ? false : _b, label
= props.label, _c = props.max, max = _c === void 0 ? 10 : _c, _d = props.min, min =
_d === void 0 ? 0 : _d, _e = props.showValue, showValue = _e === void 0 ? true :
_e, _f = props.buttonProps, buttonProps = _f === void 0 ? {} : _f, _g =
props.vertical, vertical = _g === void 0 ? false : _g, snapToStep =
props.snapToStep, valueFormat = props.valueFormat, styles = props.styles, theme =
props.theme, originFromZero = props.originFromZero, ariaLabelledBy = props["aria-
labelledby"], ariaLabel = props["aria-label"], ranged = props.ranged, onChange =
props.onChange, onChanged = props.onChanged;
var disposables = React.useRef([]);
var _h = react_hooks_1.useSetTimeout(), setTimeout = _h.setTimeout,
clearTimeout = _h.clearTimeout;
var sliderLine = React.useRef(null);
// Casting here is necessary because useControllableValue expects the event for
the change callback
// to extend React.SyntheticEvent, when in fact for Slider, the event could be
either a React event
// or a native browser event depending on the context.
var _j = react_hooks_1.useControllableValue(props.value, props.defaultValue,
function (ev, v) {
return onChange === null || onChange === void 0 ? void 0 : onChange(v,
ranged ? [internalState.latestLowerValue, v] : undefined, ev);
}), unclampedValue = _j[0], setValue = _j[1];
var _k = react_hooks_1.useControllableValue(props.lowerValue,
props.defaultLowerValue, function (ev, lv) { return onChange === null || onChange
=== void 0 ? void 0 : onChange(internalState.latestValue, [lv,
internalState.latestValue], ev); }), unclampedLowerValue = _k[0], setLowerValue =
_k[1];
// Ensure that value is always a number and is clamped by min/max.
var value = Math.max(min, Math.min(max, unclampedValue || 0));
var lowerValue = Math.max(min, Math.min(value, unclampedLowerValue || 0));
onKeyDownTimer: -1,
isAdjustingLowerValue: false,
latestValue: value,
latestLowerValue: lowerValue,
});
// On each render, update this saved value used by callbacks. (This should be
safe even if render
// is called multiple times, because an event handler or timeout callback will
only run once.)
internalState.latestValue = value;
internalState.latestLowerValue = lowerValue;
var id = react_hooks_1.useId('Slider', props.id || (buttonProps === null ||
buttonProps === void 0 ? void 0 : buttonProps.id));
disabled: disabled,
vertical: vertical,
showTransitions: !snapToStep && !internalState.isBetweenSteps,
showValue: showValue,
ranged: ranged,
theme: theme,
});
var steps = (max - min) / step;
var clearOnKeyDownTimer = function () {
clearTimeout(internalState.onKeyDownTimer);
internalState.onKeyDownTimer = -1;
};
var setOnKeyDownTimer = function (event) {
clearOnKeyDownTimer();
if (onChanged) {
internalState.onKeyDownTimer = setTimeout(function () {
onChanged(event, internalState.latestValue, ranged ?
[internalState.latestLowerValue, internalState.latestValue] : undefined);
}, exports.ONKEYDOWN_TIMEOUT_DURATION);
}
};
var getAriaValueText = function (valueProps) {
var ariaValueText = props.ariaValueText;
if (valueProps !== undefined) {
return ariaValueText ? ariaValueText(valueProps) :
valueProps.toString();
}
return undefined;
};
/**
* Update `value` or `lowerValue`, including clamping between min/max and
rounding to
* appropriate precision.
* @param newValue - New current value of the slider, possibly rounded to a
whole step.
* @param newUnroundedValue - Like `newValue` but without the rounding to a
step. If this is
* provided and not equal to `newValue`, ìnternalState.isBetweenSteps` will be
set, which
* may cause thumb movement animations to be disabled.
*/
var updateValue = function (ev, newValue, newUnroundedValue) {
newValue = Math.min(max, Math.max(min, newValue));
newUnroundedValue = newUnroundedValue !== undefined ? Math.min(max,
Math.max(min, newUnroundedValue)) : undefined;
var numDec = 0;
if (isFinite(step)) {
while (Math.round(step * Math.pow(10, numDec)) / Math.pow(10, numDec) !
== step) {
numDec++;
}
}
// Make sure value has correct number of decimal places based on number of
decimals in step
var roundedValue = parseFloat(newValue.toFixed(numDec));
internalState.isBetweenSteps = newUnroundedValue !== undefined &&
newUnroundedValue !== roundedValue;
if (ranged) {
// decided which thumb value to change
if (internalState.isAdjustingLowerValue &&
(originFromZero ? roundedValue <= 0 : roundedValue <=
internalState.latestValue)) {
setLowerValue(roundedValue, ev);
}
else if (!internalState.isAdjustingLowerValue &&
(originFromZero ? roundedValue >= 0 : roundedValue >=
internalState.latestLowerValue)) {
setValue(roundedValue, ev);
}
}
else {
setValue(roundedValue, ev);
}
};
var onKeyDown = function (event) {
var newCurrentValue = internalState.isAdjustingLowerValue
? internalState.latestLowerValue
: internalState.latestValue;
var diff = 0;
switch (event.which) {
case utilities_1.getRTLSafeKeyCode(utilities_1.KeyCodes.left,
props.theme):
diff = -step;
setOnKeyDownTimer(event);
break;
case utilities_1.getRTLSafeKeyCode(utilities_1.KeyCodes.right,
props.theme):
case utilities_1.KeyCodes.up:
diff = step;
break;
case utilities_1.KeyCodes.home:
newCurrentValue = min;
break;
case utilities_1.KeyCodes.end:
newCurrentValue = max;
break;
default:
return;
}
updateValue(event, newCurrentValue + diff);
};
var getPosition = function (event, verticalProp) {
var currentPosition = 0;
switch (event.type) {
case 'mousedown':
case 'mousemove':
currentPosition = !verticalProp ? event.clientX : event.clientY;
break;
case 'touchstart':
case 'touchmove':
currentPosition = !verticalProp
? event.touches[0].clientX
: event.touches[0].clientY;
break;
}
return currentPosition;
};
var calculateCurrentSteps = function (event) {
var sliderPositionRect = sliderLine.current.getBoundingClientRect();
var sliderLength = !props.vertical ? sliderPositionRect.width :
sliderPositionRect.height;
var stepLength = sliderLength / steps;
var currentSteps;
var distance;
if (!props.vertical) {
var left = getPosition(event, props.vertical);
distance = utilities_1.getRTL(props.theme) ? sliderPositionRect.right -
left : left - sliderPositionRect.left;
currentSteps = distance / stepLength;
}
else {
var bottom = getPosition(event, props.vertical);
distance = sliderPositionRect.bottom - bottom;
currentSteps = distance / stepLength;
}
return currentSteps;
};
var onMouseMoveOrTouchMove = function (event, suppressEventCancelation) {
var currentSteps = calculateCurrentSteps(event);
var newUnroundedValue = min + step * currentSteps;
var newCurrentValue = min + step * Math.round(currentSteps);
updateValue(event, newCurrentValue, newUnroundedValue);
if (!suppressEventCancelation) {
}
};
var onMouseDownOrTouchStart = function (event) {
if (ranged) {
var currentSteps = calculateCurrentSteps(event);
var newValue = min + step * currentSteps;
internalState.isAdjustingLowerValue =
newValue <= internalState.latestLowerValue ||
newValue - internalState.latestLowerValue <=
internalState.latestValue - newValue;
}
if (event.type === 'mousedown') {
disposables.current.push(utilities_1.on(window, 'mousemove',
onMouseMoveOrTouchMove, true), utilities_1.on(window, 'mouseup',
onMouseUpOrTouchEnd, true));
}
else if (event.type === 'touchstart') {
disposables.current.push(utilities_1.on(window, 'touchmove',
onMouseMoveOrTouchMove, true), utilities_1.on(window, 'touchend',
onMouseUpOrTouchEnd, true));
}
onMouseMoveOrTouchMove(event, true);
};
var onMouseUpOrTouchEnd = function (event) {
// Done adjusting, so clear this value
internalState.isBetweenSteps = undefined;
onChanged === null || onChanged === void 0 ? void 0 : onChanged(event,
internalState.latestValue, ranged ? [internalState.latestLowerValue,
internalState.latestValue] : undefined);
disposeListeners();
};
var onThumbFocus = function (event) {
internalState.isAdjustingLowerValue = event.target ===
lowerValueThumbRef.current;
};
var disposeListeners = function () {
disposables.current.forEach(function (dispose) { return dispose(); });
disposables.current = [];
};
var lowerValueThumbRef = React.useRef(null);
var thumbRef = React.useRef(null);
useComponentRef(props, ranged && !vertical ? lowerValueThumbRef : thumbRef,
value, ranged ? [lowerValue, value] : undefined);
var getPositionStyles = getSlotStyleFn(vertical ? 'bottom' :
utilities_1.getRTL(props.theme) ? 'right' : 'left');
var getTrackStyles = getSlotStyleFn(vertical ? 'height' : 'width');
var originValue = originFromZero ? 0 : min;
var valuePercent = getPercent(value, min, max);
var lowerValuePercent = getPercent(lowerValue, min, max);
var originPercentOfLine = getPercent(originValue, min, max);
var activeSectionWidth = ranged ? valuePercent - lowerValuePercent :
Math.abs(originPercentOfLine - valuePercent);
var topSectionWidth = Math.min(100 - valuePercent, 100 - originPercentOfLine);
var bottomSectionWidth = ranged ? lowerValuePercent : Math.min(valuePercent,
originPercentOfLine);
var rootProps = {
ref: ref,
};
var labelProps = {
className: classNames.titleLabel,
children: label,
disabled: disabled,
htmlFor: ariaLabel ? undefined : id,
};
var valueLabelProps = showValue
? {
className: classNames.valueLabel,
children: valueFormat ? valueFormat(value) : value,
disabled: disabled,
htmlFor: disabled ? id : undefined,
}
: undefined;
var lowerValueLabelProps = ranged && showValue
? {
className: classNames.valueLabel,
children: valueFormat ? valueFormat(lowerValue) : lowerValue,
disabled: disabled,
}
: undefined;
var zeroTickProps = originFromZero
? {
className: classNames.zeroTick,
style: getPositionStyles(originPercentOfLine),
}
: undefined;
var trackActiveProps = {
className: utilities_1.css(classNames.lineContainer,
classNames.activeSection),
style: getTrackStyles(activeSectionWidth),
};
var trackTopInactiveProps = {
classNames.inactiveSection),
style: getTrackStyles(topSectionWidth),
};
var trackBottomInactiveProps = {
classNames.inactiveSection),
style: getTrackStyles(bottomSectionWidth),
};
var sliderProps = tslib_1.__assign({ 'aria-disabled': disabled, role: 'slider',
tabIndex: disabled ? undefined : 0 }, { 'data-is-focusable': !disabled });
var sliderBoxProps = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ id:
id, className: utilities_1.css(classNames.slideBox, buttonProps.className) }, (!
disabled && {
onMouseDown: onMouseDownOrTouchStart,
onTouchStart: onMouseDownOrTouchStart,
onKeyDown: onKeyDown,
})), (buttonProps &&
utilities_1.getNativeProps(buttonProps, utilities_1.divProperties, ['id',
'className']))), (!ranged && tslib_1.__assign(tslib_1.__assign({}, sliderProps),
{ 'aria-valuemin': min, 'aria-valuemax': max, 'aria-valuenow': value, 'aria-
valuetext': getAriaValueText(value), 'aria-label': ariaLabel || label, 'aria-
labelledby': ariaLabelledBy })));
var onFocusProp = disabled ? {} : { onFocus: onThumbFocus };
var thumbProps = tslib_1.__assign({ ref: thumbRef, className: classNames.thumb,
style: getPositionStyles(valuePercent) }, (ranged &&
tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sliderProps), onFocusProp),
{ id: "max-" + id, 'aria-valuemin': lowerValue, 'aria-valuemax': max, 'aria-
valuenow': value, 'aria-valuetext': getAriaValueText(value), 'aria-label': "max " +
(ariaLabel || label) })));
var lowerValueThumbProps = ranged
? tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ ref:
lowerValueThumbRef, className: classNames.thumb, style:
getPositionStyles(lowerValuePercent) }, sliderProps), onFocusProp), { id: "min-" +
id, 'aria-valuemin': min, 'aria-valuemax': value, 'aria-valuenow': lowerValue,
'aria-valuetext': getAriaValueText(lowerValue), 'aria-label': "min " + (ariaLabel
|| label) }) : undefined;
var containerProps = {
className: classNames.container,
};
var sliderLineProps = {
ref: sliderLine,
className: classNames.line,
};
return {
root: rootProps,
label: labelProps,
sliderBox: sliderBoxProps,
container: containerProps,
valueLabel: valueLabelProps,
lowerValueLabel: lowerValueLabelProps,
thumb: thumbProps,
lowerValueThumb: lowerValueThumbProps,
zeroTick: zeroTickProps,
activeTrack: trackActiveProps,
topInactiveTrack: trackTopInactiveProps,
bottomInactiveTrack: trackBottomInactiveProps,
sliderLine: sliderLineProps,
};
};
exports.useSlider = useSlider;
//# sourceMappingURL=useSlider.js.map
/***/ }),
/***/ 77764:
"use strict";

exports.SpinButtonBase = void 0;
var SpinButton_styles_1 = __webpack_require__(38320);
var SpinButton_types_1 = __webpack_require__(2283);
var COMPONENT_NAME = 'SpinButton';
disabled: false,
label: '',
step: 1,
labelPosition: Positioning_1.Position.start,
incrementButtonIcon: { iconName: 'ChevronUpSmall' },
decrementButtonIcon: { iconName: 'ChevronDownSmall' },
};
var INITIAL_STEP_DELAY = 400;
var STEP_DELAY = 75;
var useComponentRef = function (props, input, value) {
get value() {
return value;
},
if (input.current) {
input.current.focus();
}
},
}); }, [input, value]);
};
var noOp = function () {
/**
* A noop input change handler. Using onInput instead of onChange was meant to
address an issue
* which apparently has been resolved in React 16
(https://github.com/facebook/react/issues/7027).
* The no-op onChange handler was still needed because React gives console
errors if an input
* doesn't have onChange.
*
* TODO (Fabric 8?) - switch to just calling onChange (this is a breaking
change for any tests,
* ours or 3rd-party, which simulate entering text in a SpinButton)
*/
};
/** Clamp the value to the provided min and/or max */
var clampValue = function (value, _a) {
var min = _a.min, max = _a.max;
if (typeof max === 'number') {
value = Math.min(value, max);
}
if (typeof min === 'number') {
value = Math.max(value, min);
}
return value;
};
exports.SpinButtonBase = React.forwardRef(function (propsWithoutDefaults, ref) {
var disabled = props.disabled, label = props.label, min = props.min, max =
props.max, step = props.step, defaultValue = props.defaultValue, valueFromProps =
props.value, precisionFromProps = props.precision, labelPosition =
props.labelPosition, iconProps = props.iconProps, incrementButtonIcon =
props.incrementButtonIcon, incrementButtonAriaLabel =
props.incrementButtonAriaLabel, decrementButtonIcon = props.decrementButtonIcon,
decrementButtonAriaLabel = props.decrementButtonAriaLabel, ariaLabel =
props.ariaLabel, ariaDescribedBy = props.ariaDescribedBy, customUpArrowButtonStyles
= props.upArrowButtonStyles, customDownArrowButtonStyles =
props.downArrowButtonStyles, theme = props.theme, ariaPositionInSet =
props.ariaPositionInSet, ariaSetSize = props.ariaSetSize, ariaValueNow =
props.ariaValueNow, ariaValueText = props.ariaValueText, className =
props.className, inputProps = props.inputProps, onDecrement = props.onDecrement,
onIncrement = props.onIncrement, iconButtonProps = props.iconButtonProps,
onValidate = props.onValidate, onChange = props.onChange, styles = props.styles;
var input = React.useRef(null);
var inputId = react_hooks_1.useId('input');
var labelId = react_hooks_1.useId('Label');
var _a = React.useState(false), isFocused = _a[0], setIsFocused = _a[1];
var _b = React.useState(SpinButton_types_1.KeyboardSpinDirection.notSpinning),
keyboardSpinDirection = _b[0], setKeyboardSpinDirection = _b[1];
var precision = React.useMemo(function () {
return precisionFromProps !== null && precisionFromProps !== void 0 ?
precisionFromProps : Math.max(Utilities_1.calculatePrecision(step), 0);
}, [precisionFromProps, step]);
/**
* Actual current value. If `props.value` is provided (controlled), it will
always be used.
* If not (uncontrolled), this tracks the current value based on user
modifications.
* Note that while the user is editing text in the field, this will not be
updated until "commit"
* (blur or press enter).
*/
var _c = react_hooks_1.useControllableValue(valueFromProps, defaultValue !==
null && defaultValue !== void 0 ? defaultValue : String(min || 0), onChange), value
= _c[0], setValue = _c[1];
/**
* "Uncommitted" internal value while the user is editing text in the field.
This lets us wait to
* call ònChange` (and possibly update the real value) until the user
"commits" the value by
* pressing enter or blurring the field.
*/
var _d = React.useState(), intermediateValue = _d[0], setIntermediateValue =
_d[1];
var internalState = React.useRef({
stepTimeoutHandle: -1,
latestValue: undefined,
latestIntermediateValue: undefined,
}).current;
// On each render, update this saved value used by callbacks. (This should be
safe even if render
// is called multiple times, because an event handler or timeout callback will
only run once.)
internalState.latestValue = value;
internalState.latestIntermediateValue = intermediateValue;
var previousValueFromProps = react_hooks_1.usePrevious(valueFromProps);
// If props.value changes while editing, clear the intermediate value
if (valueFromProps !== previousValueFromProps && intermediateValue !==
undefined) {
setIntermediateValue(undefined);
}
}, [valueFromProps, previousValueFromProps, intermediateValue]);
theme: theme,
disabled: disabled,
isFocused: isFocused,
keyboardSpinDirection: keyboardSpinDirection,
labelPosition: labelPosition,
});
var nativeProps = Utilities_1.getNativeProps(props, Utilities_1.divProperties,
[
'onBlur',
'onFocus',
'className',
'onChange',
]);
/** Validate (commit) function called on blur or enter keypress. */
var validate = React.useCallback(function (ev) {
// Only run validation if the value changed
var enteredValue = internalState.latestIntermediateValue;
if (enteredValue !== undefined && enteredValue !==
internalState.latestValue) {
var newValue = void 0;
if (onValidate) {
newValue = onValidate(enteredValue, ev);
}
else if (enteredValue && enteredValue.trim().length && !
isNaN(Number(enteredValue))) {
// default validation handling
newValue = String(clampValue(Number(enteredValue), { min: min, max:
max }));
}
if (newValue !== undefined && newValue !== internalState.latestValue) {
// Commit the value if it changed
setValue(newValue, ev);
}
}
// Done validating, so clear the intermediate typed value (if any)
}, [internalState, max, min, onValidate, setValue]);
/**
* Stop spinning (clear any currently pending update and set spinning to false)
*/
var stop = React.useCallback(function () {
if (internalState.stepTimeoutHandle >= 0) {
async.clearTimeout(internalState.stepTimeoutHandle);
internalState.stepTimeoutHandle = -1;
}
if (internalState.spinningByMouse || keyboardSpinDirection !==
SpinButton_types_1.KeyboardSpinDirection.notSpinning) {
internalState.spinningByMouse = false;
setKeyboardSpinDirection(SpinButton_types_1.KeyboardSpinDirection.notSpinning);
}
}, [internalState, keyboardSpinDirection, async]);
/**
* Update the value with the given stepFunction.
* Also starts spinning for mousedown events by scheduling another update with
setTimeout.
* @param stepFunction - function to use to step by
* @param event - The event that triggered the updateValue
*/
var updateValue = React.useCallback(function (stepFunction, ev) {
ev.persist();
if (internalState.latestIntermediateValue !== undefined) {
// Edge case: if intermediateValue is set, this means that the user was
editing the input
// text and then started spinning (either with mouse or keyboard). We
need to validate and
// call onChange before starting to spin.
if (ev.type === 'keydown') {
// For the arrow keys, we have to manually trigger validation.
// (For the buttons, validation will happen automatically since the
input's onBlur will
// be triggered after mousedown on the button completes.)
validate(ev);
}
// After handling any value updates, do the spinning update
updateValue(stepFunction, ev);
});
return;
}
// Call the step function and update the value.
// (Note: we access the latest value via internalState (not directly) to
ensure we don't use
// a stale captured value. This is mainly important for spinning by mouse,
where we trigger
// additional calls to the original updateValue function via setTimeout. It
also lets us
// avoid useCallback deps on frequently changing values.)
var newValue = stepFunction(internalState.latestValue || '', ev);
if (newValue !== undefined && newValue !== internalState.latestValue) {
setValue(newValue, ev);
}
// Schedule the next spin if applicable
// (will be canceled if there's a mouseup before the timeout runs)
var wasSpinning = internalState.spinningByMouse;
internalState.spinningByMouse = ev.type === 'mousedown';
if (internalState.spinningByMouse) {
internalState.stepTimeoutHandle = async.setTimeout(function () {
updateValue(stepFunction, ev);
}, wasSpinning ? STEP_DELAY : INITIAL_STEP_DELAY);
}
}, [internalState, async, validate, setValue]);
/** Composed increment handler (uses `props.onIncrement` or default) */
var handleIncrement = React.useCallback(function (newValue) {
if (onIncrement) {
return onIncrement(newValue);
}
else {
var numericValue = clampValue(Number(newValue) + Number(step), { max:
max });
numericValue = Utilities_1.precisionRound(numericValue, precision);
return String(numericValue);
}
}, [precision, max, onIncrement, step]);
/** Composed decrement handler (uses `props.onDecrement` or default) */
var handleDecrement = React.useCallback(function (newValue) {
if (onDecrement) {
return onDecrement(newValue);
}
else {
var numericValue = clampValue(Number(newValue) - Number(step), { min:
min });
numericValue = Utilities_1.precisionRound(numericValue, precision);
return String(numericValue);
}
}, [precision, min, onDecrement, step]);
/** Handles when the user types in the input */
var handleInputChange = function (ev) {
setIntermediateValue(ev.target.value);
};
/** Composed focus handler (does internal stuff and calls `props.onFocus`) */
var handleFocus = function (ev) {
var _a;
// We can't set focus on a non-existing element
if (!input.current) {
return;
}
if (internalState.spinningByMouse || keyboardSpinDirection !==
SpinButton_types_1.KeyboardSpinDirection.notSpinning) {
stop();
}
input.current.select();
setIsFocused(true);
ev);
};
/** Composed blur handler (does internal stuff and calls `props.onBlur`) */
var handleBlur = function (ev) {
var _a;
validate(ev);
setIsFocused(false);
(_a = props.onBlur) === null || _a === void 0 ? void 0 : _a.call(props,
ev);
};
/** Update value when arrow keys are pressed, commit on enter, or revert on
escape */
var handleKeyDown = function (ev) {
// eat the up and down arrow keys to keep focus in the spinButton
// (especially when a spinButton is inside of a FocusZone)
if (ev.which === Utilities_1.KeyCodes.up || ev.which ===
Utilities_1.KeyCodes.down || ev.which === Utilities_1.KeyCodes.enter) {
}
if (disabled) {
stop();
return;
}
var spinDirection = SpinButton_types_1.KeyboardSpinDirection.notSpinning;
switch (ev.which) {
spinDirection = SpinButton_types_1.KeyboardSpinDirection.up;
updateValue(handleIncrement, ev);
break;
spinDirection = SpinButton_types_1.KeyboardSpinDirection.down;
updateValue(handleDecrement, ev);
break;
// Commit the edited value
validate(ev);
break;
// Revert to previous value
break;
}
// style the increment/decrement button to look active
// when the corresponding up/down arrow keys trigger a step
if (keyboardSpinDirection !== spinDirection) {
setKeyboardSpinDirection(spinDirection);
}
};
/** Stop spinning on keyUp if the up or down arrow key fired this event */
var handleKeyUp = React.useCallback(function (ev) {
if (disabled || ev.which === Utilities_1.KeyCodes.up || ev.which ===
Utilities_1.KeyCodes.down) {
stop();
return;
}
}, [disabled, stop]);
var handleIncrementMouseDown = React.useCallback(function (ev) {
updateValue(handleIncrement, ev);
}, [handleIncrement, updateValue]);
var handleDecrementMouseDown = React.useCallback(function (ev) {
updateValue(handleDecrement, ev);
}, [handleDecrement, updateValue]);
useComponentRef(props, input, value);
var valueIsNumber = !!value && !isNaN(Number(value)); // Number('') is 0 which
may not be desirable
var labelContent = (iconProps || label) && (React.createElement("div",
{ className: classNames.labelWrapper },
iconProps && React.createElement(Icon_1.Icon, tslib_1.__assign({},
iconProps, { className: classNames.icon, "aria-hidden": "true" })),
label && (React.createElement(Label_1.Label, { id: labelId, htmlFor:
inputId, className: classNames.label, disabled: disabled }, label))));
labelPosition !== Positioning_1.Position.bottom && labelContent,
React.createElement("div", tslib_1.__assign({}, nativeProps, { className:
classNames.spinButtonWrapper, "aria-label": ariaLabel && ariaLabel, "aria-
posinset": ariaPositionInSet, "aria-setsize": ariaSetSize, "data-ktp-target":
true }),
React.createElement("input", tslib_1.__assign({
// Display intermediateValue while editing the text (before commit)
value: intermediateValue !== null && intermediateValue !== void 0 ?
intermediateValue : value, id: inputId, onChange: noOp, onInput: handleInputChange,
className: classNames.input, type: "text", autoComplete: "off", role: "spinbutton",
"aria-labelledby": label && labelId, "aria-valuenow": ariaValueNow !== null &&
ariaValueNow !== void 0 ? ariaValueNow : (valueIsNumber ? Number(value) :
undefined), "aria-valuetext": ariaValueText !== null && ariaValueText !== void 0 ?
ariaValueText : (valueIsNumber ? undefined : value), "aria-valuemin": min, "aria-
valuemax": max, "aria-describedby": ariaDescribedBy, onBlur: handleBlur, ref:
input, onFocus: handleFocus, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp,
disabled: disabled, "aria-disabled": disabled, "data-lpignore": true, "data-ktp-
execute-target": true }, inputProps)),
classNames.arrowButtonsContainer },
React.createElement(Button_1.IconButton, tslib_1.__assign({ styles:
SpinButton_styles_1.getArrowButtonStyles(theme, true, customUpArrowButtonStyles),
className: 'ms-UpButton', checked: keyboardSpinDirection ===
SpinButton_types_1.KeyboardSpinDirection.up, disabled: disabled, iconProps:
incrementButtonIcon, onMouseDown: handleIncrementMouseDown, onMouseLeave: stop,
onMouseUp: stop, tabIndex: -1, ariaLabel: incrementButtonAriaLabel, "data-is-
focusable": false }, iconButtonProps)),
React.createElement(Button_1.IconButton, tslib_1.__assign({ styles:
SpinButton_styles_1.getArrowButtonStyles(theme, false,
customDownArrowButtonStyles), className: 'ms-DownButton', checked:
keyboardSpinDirection === SpinButton_types_1.KeyboardSpinDirection.down, disabled:
disabled, iconProps: decrementButtonIcon, onMouseDown: handleDecrementMouseDown,
onMouseLeave: stop, onMouseUp: stop, tabIndex: -1, ariaLabel:
decrementButtonAriaLabel, "data-is-focusable": false }, iconButtonProps)))),
labelPosition === Positioning_1.Position.bottom && labelContent));
});
exports.SpinButtonBase.displayName = COMPONENT_NAME;
var useDebugWarnings = function (props) {
if (false) {}
};
//# sourceMappingURL=SpinButton.base.js.map
/***/ }),
/***/ 51692:
"use strict";

exports.SpinButton = void 0;
var SpinButton_base_1 = __webpack_require__(77764);
var SpinButton_styles_1 = __webpack_require__(38320);
/**
* The SpinButton control and related tabs pattern are used for navigating
frequently accessed,
* distinct content categories. SpinButtons allow for navigation between two or
more content
* views and relies on text headers to articulate the different sections of
content.
*/
exports.SpinButton = Utilities_1.styled(SpinButton_base_1.SpinButtonBase,
SpinButton_styles_1.getStyles, undefined, {
scope: 'SpinButton',
});
//# sourceMappingURL=SpinButton.js.map
/***/ }),
/***/ 38320:
"use strict";

exports.getStyles = exports.getArrowButtonStyles = void 0;
var ARROW_BUTTON_WIDTH = 23;
var ARROW_BUTTON_ICON_SIZE = 8;
var DEFAULT_HEIGHT = 32;
var DEFAULT_MIN_WIDTH = 86;
var LABEL_MARGIN = 10;
var getDisabledStyles = Utilities_1.memoizeFunction(function (theme) {
var _a;
var SpinButtonTextColorDisabled = semanticColors.disabledText;
var SpinButtonBackgroundColorDisabled = semanticColors.disabledBackground;
return {
backgroundColor: SpinButtonBackgroundColorDisabled,
cursor: 'default',
color: SpinButtonTextColorDisabled,
selectors: (_a = {
':after': {
borderColor: SpinButtonBackgroundColorDisabled,
}
},
color: 'GrayText',
},
_a),
};
});
exports.getArrowButtonStyles = Utilities_1.memoizeFunction(function (theme,
isUpArrow, customSpecificArrowStyles) {
var _a, _b, _c;
theme.effects;
// TODO: after updating the semanticColor slots all this need to be
reevaluated.
var ArrowButtonTextColor = palette.neutralSecondary;
var ArrowButtonTextColorHovered = semanticColors.buttonText;
var ArrowButtonTextColorPressed = semanticColors.buttonText;
var ArrowButtonBackgroundHovered = semanticColors.buttonBackgroundHovered;
var ArrowButtonBackgroundPressed = semanticColors.buttonBackgroundPressed;
var defaultArrowButtonStyles = {
root: {
outline: 'none',
display: 'block',
height: '50%',
width: ARROW_BUTTON_WIDTH,
padding: 0,
cursor: 'default',
color: ArrowButtonTextColor,
selectors: {
'&.ms-DownButton': {
borderRadius: "0 0 " + effects.roundedCorner2 + " 0",
},
'&.ms-UpButton': {
borderRadius: "0 " + effects.roundedCorner2 + " 0 0",
},
},
},
rootHovered: {
backgroundColor: ArrowButtonBackgroundHovered,
color: ArrowButtonTextColorHovered,
},
rootChecked: {
backgroundColor: ArrowButtonBackgroundPressed,
color: ArrowButtonTextColorPressed,
},
_a),
},
rootPressed: {
backgroundColor: ArrowButtonBackgroundPressed,
color: ArrowButtonTextColorPressed,
},
_b),
},
rootDisabled: {
opacity: 0.5,
color: 'GrayText',
opacity: 1,
},
_c),
},
icon: {
fontSize: ARROW_BUTTON_ICON_SIZE,
marginTop: 0,
marginRight: 0,
marginBottom: 0,
marginLeft: 0,
},
};
// No specific styles needed as of now.
var defaultUpArrowButtonStyles = {};
var defaultDownArrowButtonStyles = {};
return Styling_1.concatStyleSets(defaultArrowButtonStyles, isUpArrow ?
defaultUpArrowButtonStyles : defaultDownArrowButtonStyles,
customSpecificArrowStyles);
});
var _a, _b;
var theme = props.theme, className = props.className, labelPosition =
props.labelPosition, disabled = props.disabled, isFocused = props.isFocused;
theme.effects, fonts = theme.fonts;
var SpinButtonRootBorderColor = semanticColors.inputBorder;
var SpinButtonRootBackgroundColor = semanticColors.inputBackground;
var SpinButtonRootBorderColorHovered = semanticColors.inputBorderHovered;
var SpinButtonRootBorderColorFocused = semanticColors.inputFocusBorderAlt;
var SpinButtonInputTextColor = semanticColors.inputText;
var SpinButtonInputTextColorSelected = palette.white;
var SpinButtonInputBackgroundColorSelected =
semanticColors.inputBackgroundChecked;
var SpinButtonIconDisabledColor = semanticColors.disabledText;
return {
root: [
fonts.medium,
{
outline: 'none',
width: '100%',
minWidth: DEFAULT_MIN_WIDTH,
},
className,
],
labelWrapper: [
{
},
labelPosition === Positioning_1.Position.start && {
height: DEFAULT_HEIGHT,
float: 'left',
marginRight: LABEL_MARGIN,
},
labelPosition === Positioning_1.Position.end && {
float: 'right',
marginLeft: LABEL_MARGIN,
},
labelPosition === Positioning_1.Position.top && {
// Due to the lineHeight set on the label (below), the height of
the wrapper (contains icon+label)
// ends up 1px taller than a standard label height, causing the
vertical alignment to be off when
// the SpinButton is displayed with the label on top next to other
form fields.
// Decrease the wrapper's effective height slightly to compensate.
marginBottom: -1,
},
],
icon: [
{
padding: '0 5px',
},
disabled && {
color: SpinButtonIconDisabledColor,
},
],
label: {
// centering the label with the icon by forcing the exact same height
as the icon.
lineHeight: Styling_1.IconFontSizes.large,
},
spinButtonWrapper: [
{
display: 'flex',
minWidth: DEFAULT_MIN_WIDTH,
selectors: {
// setting border using pseudo-element here in order to
prevent:
// input and chevron buttons to overlap border under certain
resolutions
':after': {
content: "''",
left: 0,
top: 0,
bottom: 0,
right: 0,
borderWidth: '1px',
borderColor: SpinButtonRootBorderColor,
},
},
},
(labelPosition === Positioning_1.Position.top || labelPosition ===
Positioning_1.Position.bottom) && {
width: '100%',
},
!disabled && [
{
selectors: {
':hover': {
selectors: (_a = {
':after': {
borderColor:
SpinButtonRootBorderColorHovered,
}
},
selectors: {
':after': {
},
},
},
_a),
},
},
},
isFocused && {
selectors: {
'&&':
Styling_1.getInputFocusStyle(SpinButtonRootBorderColorFocused,
effects.roundedCorner2),
},
},
],
disabled && getDisabledStyles(theme),
],
input: [
'ms-spinButton-input',
{
boxShadow: 'none',
flex: 1,
margin: 0,
color: SpinButtonInputTextColor,
backgroundColor: SpinButtonRootBackgroundColor,
height: '100%',
outline: 0,
display: 'block',
minWidth: DEFAULT_MIN_WIDTH - ARROW_BUTTON_WIDTH - 2,
overflow: 'hidden',
cursor: 'text',
userSelect: 'text',
borderRadius: effects.roundedCorner2 + " 0 0 " +
effects.roundedCorner2,
},
!disabled && {
selectors: {
'::selection': {
backgroundColor: SpinButtonInputBackgroundColorSelected,
color: SpinButtonInputTextColorSelected,
},
_b),
},
},
},
],
arrowButtonsContainer: [
{
display: 'block',
height: '100%',
cursor: 'default',
},
],
};
};
//# sourceMappingURL=SpinButton.styles.js.map
/***/ }),
/***/ 2283:
"use strict";

exports.KeyboardSpinDirection = void 0;
/**
* {@docCategory SpinButton}
*/
var KeyboardSpinDirection;
(function (KeyboardSpinDirection) {
KeyboardSpinDirection[KeyboardSpinDirection["down"] = -1] = "down";
KeyboardSpinDirection[KeyboardSpinDirection["notSpinning"] = 0] =
"notSpinning";
KeyboardSpinDirection[KeyboardSpinDirection["up"] = 1] = "up";
})(KeyboardSpinDirection = exports.KeyboardSpinDirection ||
(exports.KeyboardSpinDirection = {}));
//# sourceMappingURL=SpinButton.types.js.map
/***/ }),
/***/ 29558:
"use strict";

/***/ }),
/***/ 44987:
"use strict";

exports.SpinnerBase = void 0;
var Spinner_types_1 = __webpack_require__(17993);
var SpinnerBase = /** @class */ (function (_super) {
tslib_1.__extends(SpinnerBase, _super);
function SpinnerBase() {
}
SpinnerBase.prototype.render = function () {
var _a = this.props, type = _a.type, size = _a.size, ariaLabel =
_a.ariaLabel, ariaLive = _a.ariaLive, styles = _a.styles, label = _a.label, theme =
_a.theme, className = _a.className, labelPosition = _a.labelPosition;
var statusMessage = ariaLabel;
Utilities_1.divProperties, ['size']);
// SpinnerType is deprecated. If someone is still using this property,
rather than putting the SpinnerType into the
// ISpinnerStyleProps, we'll map SpinnerType to its equivalent SpinnerSize
and pass that in. Once SpinnerType
// finally goes away we should delete this.
var styleSize = size;
if (styleSize === undefined && type !== undefined) {
styleSize = type === Spinner_types_1.SpinnerType.large ?
Spinner_types_1.SpinnerSize.large : Spinner_types_1.SpinnerSize.medium;
}
theme: theme,
size: styleSize,
labelPosition: labelPosition,
});
return (React.createElement("div", tslib_1.__assign({}, nativeProps,
{ className: classNames.root }),
React.createElement("div", { className: classNames.circle }),
label && React.createElement("div", { className: classNames.label },
label),
statusMessage && (React.createElement("div", { role: "status", "aria-
live": ariaLive },
classNames.screenReaderText }, statusMessage))))));
};
SpinnerBase.defaultProps = {
size: Spinner_types_1.SpinnerSize.medium,
ariaLive: 'polite',
labelPosition: 'bottom',
};
return SpinnerBase;
exports.SpinnerBase = SpinnerBase;
//# sourceMappingURL=Spinner.base.js.map
/***/ }),
/***/ 5994:
"use strict";

exports.Spinner = void 0;
var Spinner_base_1 = __webpack_require__(44987);
var Spinner_styles_1 = __webpack_require__(42106);
exports.Spinner = Utilities_1.styled(Spinner_base_1.SpinnerBase,
Spinner_styles_1.getStyles, undefined, { scope: 'Spinner' });
//# sourceMappingURL=Spinner.js.map
/***/ }),
/***/ 42106:
"use strict";

var Spinner_types_1 = __webpack_require__(17993);
root: 'ms-Spinner',
circle: 'ms-Spinner-circle',
label: 'ms-Spinner-label',
};
var spinAnimation = Utilities_1.memoizeFunction(function () {
'0%': {
},
'100%': {
},
});
});
var _a;
var theme = props.theme, size = props.size, className = props.className,
labelPosition = props.labelPosition;
return {
root: [
classNames.root,
{
display: 'flex',
},
labelPosition === 'top' && {
flexDirection: 'column-reverse',
},
labelPosition === 'right' && {
},
labelPosition === 'left' && {
},
className,
],
circle: [
classNames.circle,
{
border: '1.5px solid ' + palette.themeLight,
borderTopColor: palette.themePrimary,
animationName: spinAnimation(),
animationDuration: '1.3s',
animationIterationCount: 'infinite',
animationTimingFunction: 'cubic-bezier(.53,.21,.29,.67)',
tslib_1.__assign({ borderTopColor: 'Highlight' },
_a),
},
size === Spinner_types_1.SpinnerSize.xSmall && [
'ms-Spinner--xSmall',
{
width: 12,
height: 12,
},
],
size === Spinner_types_1.SpinnerSize.small && [
'ms-Spinner--small',
{
width: 16,
height: 16,
},
],
size === Spinner_types_1.SpinnerSize.medium && [
'ms-Spinner--medium',
{
width: 20,
height: 20,
},
],
size === Spinner_types_1.SpinnerSize.large && [
'ms-Spinner--large',
{
width: 28,
height: 28,
},
],
],
label: [
classNames.label,
theme.fonts.small,
{
margin: '8px 0 0',
},
labelPosition === 'top' && {
margin: '0 0 8px',
},
labelPosition === 'right' && {
margin: '0 0 0 8px',
},
labelPosition === 'left' && {
margin: '0 8px 0 0',
},
],
};
};
//# sourceMappingURL=Spinner.styles.js.map
/***/ }),
/***/ 17993:
"use strict";

exports.SpinnerType = exports.SpinnerSize = void 0;
/**
* Possible variations of the spinner circle size.
* {@docCategory Spinner}
*/
var SpinnerSize;
(function (SpinnerSize) {
/**
* 12px Spinner diameter
*/
SpinnerSize[SpinnerSize["xSmall"] = 0] = "xSmall";
/**
*/
SpinnerSize[SpinnerSize["small"] = 1] = "small";
/**
*/
SpinnerSize[SpinnerSize["medium"] = 2] = "medium";
/**
*/
SpinnerSize[SpinnerSize["large"] = 3] = "large";
})(SpinnerSize = exports.SpinnerSize || (exports.SpinnerSize = {}));
/**
* @deprecated Use `SpinnerSize` instead. Will be removed at \>= 2.0.0.
* {@docCategory Spinner}
*/
var SpinnerType;
(function (SpinnerType) {
/**
* @deprecated Use `SpinnerSize.medium` instead. Will be removed at \>= 2.0.0.
*/
SpinnerType[SpinnerType["normal"] = 0] = "normal";
/**
* @deprecated Use `SpinnerSize.large` instead. Will be removed at \>= 2.0.0.
*/
SpinnerType[SpinnerType["large"] = 1] = "large";
})(SpinnerType = exports.SpinnerType || (exports.SpinnerType = {}));
//# sourceMappingURL=Spinner.types.js.map
/***/ }),
/***/ 17776:
"use strict";

/***/ }),
/***/ 91137:
"use strict";

exports.Stack = void 0;
/** @jsxRuntime classic */
/** @jsx withSlots */
var foundation_legacy_1 = __webpack_require__(3188);
var Stack_styles_1 = __webpack_require__(23083);
var StackItem_1 = __webpack_require__(72528);
var StackView = function (props) {
var _a = props.as, RootType = _a === void 0 ? 'div' : _a, disableShrink =
props.disableShrink, wrap = props.wrap, rest = tslib_1.__rest(props, ["as",
"disableShrink", "wrap"]);
Utilities_1.warnDeprecations('Stack', props, {
gap: 'tokens.childrenGap',
maxHeight: 'tokens.maxHeight',
maxWidth: 'tokens.maxWidth',
padding: 'tokens.padding',
});
// React.Fragment needs to be ignored before checking for Stack's children
var stackChildren = React.Children.toArray(props.children);
if (stackChildren.length === 1 &&
React.isValidElement(stackChildren[0]) &&
stackChildren[0].type === React.Fragment) {
stackChildren = stackChildren[0].props.children;
}
stackChildren = React.Children.map(stackChildren, function (child, index) {
if (!child) {
return null;
}
if (_isStackItem(child)) {
var defaultItemProps = {
shrink: !disableShrink,
};
return React.cloneElement(child, tslib_1.__assign(tslib_1.__assign({},
defaultItemProps), child.props));
}
return child;
});
var nativeProps = Utilities_1.getNativeProps(rest,
var Slots = foundation_legacy_1.getSlots(props, {
root: RootType,
inner: 'div',
});
if (wrap) {
return (foundation_legacy_1.withSlots(Slots.root, tslib_1.__assign({},
nativeProps),
foundation_legacy_1.withSlots(Slots.inner, null, stackChildren)));
}
return foundation_legacy_1.withSlots(Slots.root, tslib_1.__assign({},
nativeProps), stackChildren);
};
function _isStackItem(item) {
// In theory, we should be able to just check item.type === StackItem.
// However, under certain unclear circumstances (see
https://github.com/microsoft/fluentui/issues/10785),
// the object identity is different despite the function implementation being
the same.
return (!!item &&
typeof item === 'object' &&
!!item.type &&
// StackItem is generated by createComponent, so we need to check its
displayName instead of name
item.type.displayName === StackItem_1.StackItem.displayName);
}
var StackStatics = {
Item: StackItem_1.StackItem,
};
exports.Stack = foundation_legacy_1.createComponent(StackView, {
displayName: 'Stack',
styles: Stack_styles_1.styles,
statics: StackStatics,
});
exports["default"] = exports.Stack;
//# sourceMappingURL=Stack.js.map
/***/ }),
/***/ 23083:
"use strict";

var StackUtils_1 = __webpack_require__(13204);
var nameMap = {
start: 'flex-start',
end: 'flex-end',
};
root: 'ms-Stack',
inner: 'ms-Stack-inner',
};
var styles = function (props, theme, tokens) {
var _a, _b, _c, _d, _e, _f, _g;
var verticalFill = props.verticalFill, horizontal = props.horizontal, reversed
= props.reversed, grow = props.grow, wrap = props.wrap, horizontalAlign =
props.horizontalAlign, verticalAlign = props.verticalAlign, disableShrink =
props.disableShrink, className = props.className;
var childrenGap = tokens && tokens.childrenGap ? tokens.childrenGap :
props.gap;
var maxHeight = tokens && tokens.maxHeight ? tokens.maxHeight :
props.maxHeight;
var maxWidth = tokens && tokens.maxWidth ? tokens.maxWidth : props.maxWidth;
var padding = tokens && tokens.padding ? tokens.padding : props.padding;
var _h = StackUtils_1.parseGap(childrenGap, theme), rowGap = _h.rowGap,
columnGap = _h.columnGap;
var horizontalMargin = "" + -0.5 * columnGap.value + columnGap.unit;
var verticalMargin = "" + -0.5 * rowGap.value + rowGap.unit;
// styles to be applied to all direct children regardless of wrap or direction
var childStyles = {
};
// selectors to be applied regardless of wrap or direction
var commonSelectors = {
// flexShrink styles are applied by the StackItem
'> *:not(.ms-StackItem)': {
flexShrink: disableShrink ? 0 : 1,
},
};
if (wrap) {
return {
root: [
classNames.root,
{
flexWrap: 'wrap',
maxWidth: maxWidth,
maxHeight: maxHeight,
width: 'auto',
height: '100%',
},
horizontalAlign && (_a = {},
_a[horizontal ? 'justifyContent' : 'alignItems'] =
nameMap[horizontalAlign] || horizontalAlign,
_a),
verticalAlign && (_b = {},
_b[horizontal ? 'alignItems' : 'justifyContent'] =
nameMap[verticalAlign] || verticalAlign,
_b),
className,
{
// not allowed to be overridden by className
// since this is necessary in order to prevent collapsing
margins
display: 'flex',
},
horizontal && {
height: verticalFill ? '100%' : 'auto',
},
],
inner: [
classNames.inner,
{
display: 'flex',
flexWrap: 'wrap',
marginLeft: horizontalMargin,
marginRight: horizontalMargin,
marginTop: verticalMargin,
marginBottom: verticalMargin,
padding: StackUtils_1.parsePadding(padding, theme),
// avoid unnecessary calc() calls if horizontal gap is 0
width: columnGap.value === 0 ? '100%' : "calc(100% + " +
columnGap.value + columnGap.unit + ")",
maxWidth: '100vw',
selectors: tslib_1.__assign({ '> *': tslib_1.__assign({ margin:
"" + 0.5 * rowGap.value + rowGap.unit + " " + 0.5 * columnGap.value +
columnGap.unit }, childStyles) }, commonSelectors),
},
horizontalAlign && (_c = {},
_c[horizontal ? 'justifyContent' : 'alignItems'] =
_c),
verticalAlign && (_d = {},
_d[horizontal ? 'alignItems' : 'justifyContent'] =
_d),
horizontal && {
flexDirection: reversed ? 'row-reverse' : 'row',
// avoid unnecessary calc() calls if vertical gap is 0
height: rowGap.value === 0 ? '100%' : "calc(100% + " +
rowGap.value + rowGap.unit + ")",
selectors: {
'> *': {
maxWidth: columnGap.value === 0 ? '100%' : "calc(100% -
" + columnGap.value + columnGap.unit + ")",
},
},
},
!horizontal && {
flexDirection: reversed ? 'column-reverse' : 'column',
height: "calc(100% + " + rowGap.value + rowGap.unit + ")",
selectors: {
'> *': {
maxHeight: rowGap.value === 0 ? '100%' : "calc(100% - "
+ rowGap.value + rowGap.unit + ")",
},
},
},
],
};
}
return {
root: [
classNames.root,
{
display: 'flex',
flexDirection: horizontal ? (reversed ? 'row-reverse' : 'row') :
reversed ? 'column-reverse' : 'column',
flexWrap: 'nowrap',
width: 'auto',
maxWidth: maxWidth,
maxHeight: maxHeight,
padding: StackUtils_1.parsePadding(padding, theme),
selectors: tslib_1.__assign((_e = { '> *': childStyles },
_e[reversed ? '> *:not(:last-child)' : '> *:not(:first-child)'] = [
horizontal && {
marginLeft: "" + columnGap.value + columnGap.unit,
},
!horizontal && {
marginTop: "" + rowGap.value + rowGap.unit,
},
], _e), commonSelectors),
},
grow && {
flexGrow: grow === true ? 1 : grow,
},
horizontalAlign && (_f = {},
_f[horizontal ? 'justifyContent' : 'alignItems'] =
_f),
verticalAlign && (_g = {},
_g[horizontal ? 'alignItems' : 'justifyContent'] =
_g),
className,
],
// TODO: this cast may be hiding some potential issues with styling and
name
// lookups and should be removed
};
};
//# sourceMappingURL=Stack.styles.js.map
/***/ }),
/***/ 3822:
"use strict";

//# sourceMappingURL=Stack.types.js.map
/***/ }),
/***/ 72528:
"use strict";

exports.StackItem = void 0;
var StackItem_styles_1 = __webpack_require__(72444);
var StackItemView = function (props) {
var children = props.children;
if (children == null) {
return null;
}
root: 'div',
});
nativeProps), children);
};
exports.StackItem = foundation_legacy_1.createComponent(StackItemView, {
displayName: 'StackItem',
styles: StackItem_styles_1.StackItemStyles,
});
exports["default"] = exports.StackItem;
//# sourceMappingURL=StackItem.js.map
/***/ }),
/***/ 72444:
"use strict";

exports.StackItemStyles = void 0;
root: 'ms-StackItem',
};
var alignMap = {
start: 'flex-start',
end: 'flex-end',
};
var StackItemStyles = function (props, theme, tokens) {
var grow = props.grow, shrink = props.shrink, disableShrink =
props.disableShrink, align = props.align, verticalFill = props.verticalFill, order
= props.order, className = props.className, _a = props.basis, basis = _a === void 0
? 'auto' : _a;
return {
root: [
theme.fonts.medium,
classNames.root,
{
flexBasis: basis,
margin: tokens.margin,
padding: tokens.padding,
width: 'auto',
},
grow && {
flexGrow: grow === true ? 1 : grow,
},
(disableShrink || (!grow && !shrink)) && {
flexShrink: 0,
},
shrink &&
!disableShrink && {
flexShrink: 1,
},
align && {
alignSelf: alignMap[align] || align,
},
order && {
order: order,
},
className,
],
// TODO: this cast may be hiding some potential issues with styling and
name
// lookups and should be removed
};
};
exports.StackItemStyles = StackItemStyles;
//# sourceMappingURL=StackItem.styles.js.map
/***/ }),
/***/ 18942:
"use strict";

//# sourceMappingURL=StackItem.types.js.map
/***/ }),
/***/ 13204:
"use strict";

exports.parsePadding = exports.parseGap = void 0;
// Helper function that converts a themed spacing key (if given) to the
corresponding themed spacing value.
var _getThemedSpacing = function (space, theme) {
if (theme.spacing.hasOwnProperty(space)) {
return theme.spacing[space];
}
return space;
};
// Helper function that takes a gap as a string and converts it into a { value,
unit } representation.
var _getValueUnitGap = function (gap) {
var numericalPart = parseFloat(gap);
var numericalValue = isNaN(numericalPart) ? 0 : numericalPart;
var numericalString = isNaN(numericalPart) ? '' : numericalPart.toString();
var unitPart = gap.substring(numericalString.toString().length);
return {
value: numericalValue,
unit: unitPart || 'px',
};
};
/**
* Takes in a gap size in either a CSS-style format (e.g. 10 or "10px")
* or a key of a themed spacing value (e.g. "s1").
* Returns the separate numerical value of the padding (e.g. 10)
* and the CSS unit (e.g. "px").
*/
var parseGap = function (gap, theme) {
if (gap === undefined || gap === '') {
return {
rowGap: {
value: 0,
unit: 'px',
},
columnGap: {
value: 0,
unit: 'px',
},
};
}
if (typeof gap === 'number') {
return {
rowGap: {
value: gap,
unit: 'px',
},
columnGap: {
value: gap,
unit: 'px',
},
};
}
var splitGap = gap.split(' ');
// If the array has more than two values, then return 0px.
if (splitGap.length > 2) {
return {
rowGap: {
value: 0,
unit: 'px',
},
columnGap: {
value: 0,
unit: 'px',
},
};
}
// If the array has two values, then parse each one.
if (splitGap.length === 2) {
return {
rowGap: _getValueUnitGap(_getThemedSpacing(splitGap[0], theme)),
columnGap: _getValueUnitGap(_getThemedSpacing(splitGap[1], theme)),
};
}
// Else, parse the numerical value and pass it as both the vertical and
horizontal gap.
var calculatedGap = _getValueUnitGap(_getThemedSpacing(gap, theme));
return {
rowGap: calculatedGap,
columnGap: calculatedGap,
};
};
exports.parseGap = parseGap;
/**
* Takes in a padding in a CSS-style format (e.g. 10, "10px", "10px 10px", etc.)
* where the separate padding values can also be the key of a themed spacing value
* (e.g. "s1 m", "10px l1 20px l2", etc.).
* Returns a CSS-style padding.
*/
var parsePadding = function (padding, theme) {
if (padding === undefined || typeof padding === 'number' || padding === '') {
return padding;
}
var paddingValues = padding.split(' ');
if (paddingValues.length < 2) {
return _getThemedSpacing(padding, theme);
}
return paddingValues.reduce(function (padding1, padding2) {
return _getThemedSpacing(padding1, theme) + ' ' +
_getThemedSpacing(padding2, theme);
});
};
exports.parsePadding = parsePadding;
//# sourceMappingURL=StackUtils.js.map
/***/ }),
/***/ 62353:
"use strict";

/***/ }),
/***/ 50150:
"use strict";

exports.Sticky = void 0;
var ScrollablePane_types_1 = __webpack_require__(97407);
var Sticky_types_1 = __webpack_require__(90180);
var Sticky = /** @class */ (function (_super) {
tslib_1.__extends(Sticky, _super);
function Sticky(props) {
_this._stickyContentTop = React.createRef();
_this._stickyContentBottom = React.createRef();
_this._nonStickyContent = React.createRef();
_this._placeHolder = React.createRef();
_this.syncScroll = function (container) {
var nonStickyContent = _this.nonStickyContent;
if (nonStickyContent && _this.props.isScrollSynced) {
nonStickyContent.scrollLeft = container.scrollLeft;
}
};
_this._getContext = function () { return _this.context; };
_this._onScrollEvent = function (container, footerStickyContainer) {
if (_this.root && _this.nonStickyContent) {
var distanceFromTop =
_this._getNonStickyDistanceFromTop(container);
var isStickyTop = false;
var isStickyBottom = false;
if (_this.canStickyTop) {
var distanceToStickTop = distanceFromTop -
_this._getStickyDistanceFromTop();
isStickyTop = distanceToStickTop < container.scrollTop;
}
// Can sticky bottom if the scrollablePane - total sticky footer
height is smaller than the sticky's distance
// from the top of the pane
if (_this.canStickyBottom && container.clientHeight -
footerStickyContainer.offsetHeight <= distanceFromTop) {
isStickyBottom =
distanceFromTop - Math.floor(container.scrollTop) >=
_this._getStickyDistanceFromTopForFooter(container,
footerStickyContainer);
}
if (document.activeElement &&
_this.nonStickyContent.contains(document.activeElement) &&
(_this.state.isStickyTop !== isStickyTop ||
_this.state.isStickyBottom !== isStickyBottom)) {
_this._activeElement = document.activeElement;
}
else {
_this._activeElement = undefined;
}
_this.setState({
isStickyTop: _this.canStickyTop && isStickyTop,
isStickyBottom: isStickyBottom,
distanceFromTop: distanceFromTop,
});
}
};
_this._getStickyDistanceFromTop = function () {
var distance = 0;
if (_this.stickyContentTop) {
distance = _this.stickyContentTop.offsetTop;
}
return distance;
};
_this._getStickyDistanceFromTopForFooter = function (container,
footerStickyVisibleContainer) {
var distance = 0;
if (_this.stickyContentBottom) {
distance =
container.clientHeight -
footerStickyVisibleContainer.offsetHeight + _this.stickyContentBottom.offsetTop;
}
return distance;
};
_this._getNonStickyDistanceFromTop = function (container) {
var distance = 0;
var currElem = _this.root;
if (currElem) {
while (currElem && currElem.offsetParent !== container) {
distance += currElem.offsetTop;
currElem = currElem.offsetParent;
}
if (currElem && currElem.offsetParent === container) {
distance += currElem.offsetTop;
}
}
return distance;
};
_this.state = {
isStickyTop: false,
isStickyBottom: false,
distanceFromTop: undefined,
};
_this._activeElement = undefined;
return _this;
}
Object.defineProperty(Sticky.prototype, "root", {
get: function () {
return this._root.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "placeholder", {
get: function () {
return this._placeHolder.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "stickyContentTop", {
get: function () {
return this._stickyContentTop.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "stickyContentBottom", {
get: function () {
return this._stickyContentBottom.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "nonStickyContent", {
get: function () {
return this._nonStickyContent.current;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "canStickyTop", {
get: function () {
return (this.props.stickyPosition ===
Sticky_types_1.StickyPositionType.Both || this.props.stickyPosition ===
Sticky_types_1.StickyPositionType.Header);
},
enumerable: false,
configurable: true
});
Object.defineProperty(Sticky.prototype, "canStickyBottom", {
get: function () {
return (this.props.stickyPosition ===
Sticky_types_1.StickyPositionType.Both || this.props.stickyPosition ===
Sticky_types_1.StickyPositionType.Footer);
},
enumerable: false,
configurable: true
});
Sticky.prototype.componentDidMount = function () {
var scrollablePane = this._getContext().scrollablePane;
if (!scrollablePane) {
return;
}
scrollablePane.subscribe(this._onScrollEvent);
scrollablePane.addSticky(this);
};
Sticky.prototype.componentWillUnmount = function () {
return;
}
scrollablePane.unsubscribe(this._onScrollEvent);
scrollablePane.removeSticky(this);
};
Sticky.prototype.componentDidUpdate = function (prevProps, prevState) {
return;
}
var _a = this.state, isStickyBottom = _a.isStickyBottom, isStickyTop =
_a.isStickyTop, distanceFromTop = _a.distanceFromTop;
var syncScroll = false;
if (prevState.distanceFromTop !== distanceFromTop) {
scrollablePane.sortSticky(this, true /*sortAgain*/);
syncScroll = true;
}
if (prevState.isStickyTop !== isStickyTop || prevState.isStickyBottom !==
isStickyBottom) {
}
scrollablePane.updateStickyRefHeights();
syncScroll = true;
}
if (syncScroll) {
// Sync Sticky scroll position with content container on each update
scrollablePane.syncScrollSticky(this);
}
};
Sticky.prototype.shouldComponentUpdate = function (nextProps, nextState) {
if (!this.context.scrollablePane) {
return true;
}
var _a = this.state, isStickyTop = _a.isStickyTop, isStickyBottom =
_a.isStickyBottom, distanceFromTop = _a.distanceFromTop;
return (isStickyTop !== nextState.isStickyTop ||
isStickyBottom !== nextState.isStickyBottom ||
this.props.stickyPosition !== nextProps.stickyPosition ||
this.props.children !== nextProps.children ||
distanceFromTop !== nextState.distanceFromTop ||
_isOffsetHeightDifferent(this._nonStickyContent,
this._stickyContentTop) ||
_isOffsetHeightDifferent(this._nonStickyContent,
this._stickyContentBottom) ||
_isOffsetHeightDifferent(this._nonStickyContent, this._placeHolder));
};
Sticky.prototype.render = function () {
_a.isStickyBottom;
var _b = this.props, stickyClassName = _b.stickyClassName, children =
_b.children;
if (!this.context.scrollablePane) {
return React.createElement("div", null, this.props.children);
}
return (React.createElement("div", { ref: this._root },
this.canStickyTop && (React.createElement("div", { ref:
this._stickyContentTop, style: { pointerEvents: isStickyTop ? 'auto' : 'none' } },
React.createElement("div", { style:
this._getStickyPlaceholderHeight(isStickyTop) }))),
this.canStickyBottom && (React.createElement("div", { ref:
this._stickyContentBottom, style: { pointerEvents: isStickyBottom ? 'auto' : 'none'
} },
this._getStickyPlaceholderHeight(isStickyBottom) }))),
this._getNonStickyPlaceholderHeightAndWidth(), ref: this._placeHolder },
(isStickyTop || isStickyBottom) && React.createElement("span",
{ style: Styling_1.hiddenContentStyle }, children),
React.createElement("div", { ref: this._nonStickyContent,
className: isStickyTop || isStickyBottom ? stickyClassName : undefined, style:
this._getContentStyles(isStickyTop || isStickyBottom) }, children))));
};
Sticky.prototype.addSticky = function (stickyContent) {
if (this.nonStickyContent) {
stickyContent.appendChild(this.nonStickyContent);
}
};
Sticky.prototype.resetSticky = function () {
if (this.nonStickyContent && this.placeholder) {
this.placeholder.appendChild(this.nonStickyContent);
}
};
Sticky.prototype.setDistanceFromTop = function (container) {
var distanceFromTop = this._getNonStickyDistanceFromTop(container);
this.setState({ distanceFromTop: distanceFromTop });
};
Sticky.prototype._getContentStyles = function (isSticky) {
return {
backgroundColor: this.props.stickyBackgroundColor ||
this._getBackground(),
overflow: isSticky ? 'hidden' : '',
};
};
Sticky.prototype._getStickyPlaceholderHeight = function (isSticky) {
var height = this.nonStickyContent ? this.nonStickyContent.offsetHeight :
0;
return {
visibility: isSticky ? 'hidden' : 'visible',
height: isSticky ? 0 : height,
};
};
Sticky.prototype._getNonStickyPlaceholderHeightAndWidth = function () {
_a.isStickyBottom;
if (isStickyTop || isStickyBottom) {
var height = 0;
var width = 0;
// Why is placeholder width needed?
// ScrollablePane's content container is reponsible for providing
scrollbars depending on content overflow.
// - If the overflow is caused by content of sticky component when it
is in non-sticky state, the container will
// provide horizontal scrollbar.
// - If the component becomes sticky, i.e., when state.isStickyTop ||
state.isStickyBottom becomes true,
// its actual content is no longer inside the container, so the
container will see no need for horizontal
// scrollbar (assuming no other content is causing overflow). The
complete content of sticky component will
// not be viewable. So it is necessary to provide a placeholder of a
certain width (height is already being set)
// in the container, to get a horizontal scrollbar & be able to view
the complete content of sticky component.
if (this.nonStickyContent && this.nonStickyContent.firstElementChild) {
height = this.nonStickyContent.offsetHeight;
// What value should be substituted for placeholder width?
// Assumptions:
// 1. Content inside <Sticky> should always be wrapped in a
single div.
// <Sticky><div
id={'firstElementChild'}>{intended_content}</div><Sticky/>
// 2. -ve padding, margin, etc. are not be used.
// 3. scrollWidth of a parent is greater than or equal to max of
scrollWidths of its children, and same holds
// for children.
// placeholder width should be computed in the best possible way to
prevent overscroll/underscroll.
width =
this.nonStickyContent.firstElementChild.scrollWidth +
(this.nonStickyContent.firstElementChild.offsetWidth -
this.nonStickyContent.firstElementChild.clientWidth);
}
return {
height: height,
width: width,
};
}
else {
return {};
}
};
// Gets background of nearest parent element that has a declared background-
color attribute
Sticky.prototype._getBackground = function () {
if (!this.root) {
return undefined;
}
var curr = this.root;
while (window.getComputedStyle(curr).getPropertyValue('background-color')
=== 'rgba(0, 0, 0, 0)' ||
window.getComputedStyle(curr).getPropertyValue('background-color') ===
'transparent') {
if (curr.tagName === 'HTML') {
// Fallback color if no element has a declared background-color
attribute
return undefined;
}
if (curr.parentElement) {
curr = curr.parentElement;
}
}
return window.getComputedStyle(curr).getPropertyValue('background-color');
};
Sticky.defaultProps = {
stickyPosition: Sticky_types_1.StickyPositionType.Both,
isScrollSynced: true,
};
Sticky.contextType = ScrollablePane_types_1.ScrollablePaneContext;
return Sticky;
exports.Sticky = Sticky;
function _isOffsetHeightDifferent(a, b) {
return (a && b && a.current && b.current && a.current.offsetHeight !==
b.current.offsetHeight);
}
//# sourceMappingURL=Sticky.js.map
/***/ }),
/***/ 90180:
"use strict";

exports.StickyPositionType = void 0;
var StickyPositionType;
(function (StickyPositionType) {
StickyPositionType[StickyPositionType["Both"] = 0] = "Both";
StickyPositionType[StickyPositionType["Header"] = 1] = "Header";
StickyPositionType[StickyPositionType["Footer"] = 2] = "Footer";
})(StickyPositionType = exports.StickyPositionType || (exports.StickyPositionType =
{}));
//# sourceMappingURL=Sticky.types.js.map
/***/ }),
/***/ 15914:
"use strict";

/***/ }),
/***/ 13187:
"use strict";

exports.ColorPickerGridCellBase = void 0;
var Color_1 = __webpack_require__(43803);
var ButtonGridCell_1 = __webpack_require__(33477);
var ActionButton_styles_1 = __webpack_require__(40731);
/** Validate if the cell's color is white or not to apply whiteCell style */
var isWhiteCell = function (inputColor) {
var currentColor = Color_1.getColorFromString(inputColor);
return (currentColor === null || currentColor === void 0 ? void 0 :
currentColor.hex) === 'ffffff';
};
var getColorPickerGridCellButtonClassNames = Utilities_1.memoizeFunction(function
(theme, className, variantClassName, iconClassName, menuIconClassName, disabled,
checked, expanded, isSplit) {
var styles = ActionButton_styles_1.getStyles(theme);
root: [
'ms-Button',
styles.root,
variantClassName,
className,
!disabled &&
!checked && {
selectors: {
':focus': styles.rootFocused,
':active': styles.rootPressed,
},
},
disabled && checked && [styles.rootCheckedDisabled],
!disabled &&
checked && {
selectors: {
':hover': styles.rootCheckedHovered,
':active': styles.rootCheckedPressed,
},
},
],
flexContainer: ['ms-Button-flexContainer', styles.flexContainer],
});
});
var ColorPickerGridCellBase = function (props) {
var item = props.item,
_a = props.idPrefix,
idPrefix = _a === void 0 ? props.id : _a, isRadio = props.isRadio, _b =
props.selected, selected = _b === void 0 ? false : _b, _c = props.disabled,
disabled = _c === void 0 ? false : _c, styles = props.styles, _d = props.circle,
circle = _d === void 0 ? true : _d, color = props.color, onClick = props.onClick,
onHover = props.onHover, onFocus = props.onFocus, onMouseEnter =
props.onMouseEnter, onMouseMove = props.onMouseMove, onMouseLeave =
props.onMouseLeave, onWheel = props.onWheel, onKeyDown = props.onKeyDown, height =
props.height, width = props.width, borderWidth = props.borderWidth;
theme: props.theme,
disabled: disabled,
selected: selected,
circle: circle,
isWhite: isWhiteCell(color),
height: height,
width: width,
borderWidth: borderWidth,
});
// Render the core of a color cell
var onRenderColorOption = function (colorOption) {
var _a;
var svgClassName = classNames.svg;
// Build an SVG for the cell with the given shape and color properties
// Include role="img" and aria-label here for better virtual cursor
accessibility,
// and for a VoiceOver bug where it skips grid cells that lack inner
content
return (React.createElement("svg", { className: svgClassName, role: "img",
"aria-label": colorOption.label, viewBox: "0 0 20 20", fill: (_a =
Color_1.getColorFromString(colorOption.color)) === null || _a === void 0 ? void 0 :
_a.str }, circle ? React.createElement("circle", { cx: "50%", cy: "50%", r:
"50%" }) : React.createElement("rect", { width: "100%", height: "100%" })));
};
var cellSemantics = isRadio
? {
role: 'radio',
'aria-checked': selected,
selected: undefined,
}
: {
role: 'gridcell',
selected: selected,
};
return (React.createElement(ButtonGridCell_1.ButtonGridCell, tslib_1.__assign({
item: item, id: idPrefix + "-" + item.id + "-" + item.index, key: item.id,
disabled: disabled }, cellSemantics, {
onRenderItem: onRenderColorOption, onClick: onClick, onHover: onHover,
onFocus: onFocus, label: item.label, className: classNames.colorCell,
getClassNames: getColorPickerGridCellButtonClassNames, index: item.index,
onMouseEnter: onMouseEnter, onMouseMove: onMouseMove, onMouseLeave: onMouseLeave,
onWheel: onWheel, onKeyDown: onKeyDown })));
};
exports.ColorPickerGridCellBase = ColorPickerGridCellBase;
//# sourceMappingURL=ColorPickerGridCell.base.js.map
/***/ }),
/***/ 66252:
"use strict";

exports.ColorPickerGridCell = void 0;
var ColorPickerGridCell_base_1 = __webpack_require__(13187);
var ColorPickerGridCell_styles_1 = __webpack_require__(34805);
exports.ColorPickerGridCell =
Utilities_1.styled(ColorPickerGridCell_base_1.ColorPickerGridCellBase,
ColorPickerGridCell_styles_1.getStyles, undefined, { scope:
'ColorPickerGridCell' }, true);
//# sourceMappingURL=ColorPickerGridCell.js.map
/***/ }),
/***/ 34805:
"use strict";

// Size breakpoint when the default border width changes from 2px to 4px.
var CELL_BORDER_BREAKPOINT = 24;
var LARGE_BORDER = 4;
var SMALL_BORDER = 2;
var DIVIDING_PADDING = 2;
var DEFAULT_CELL_SIZE = 20;
var cellHighContrastFocus = {
left: -2,
top: -2,
bottom: -2,
right: -2,
border: 'none',
outlineColor: 'ButtonText',
};
var _a, _b, _c, _d, _e;
var theme = props.theme, disabled = props.disabled, selected = props.selected,
circle = props.circle, isWhite = props.isWhite, _f = props.height, height = _f ===
void 0 ? DEFAULT_CELL_SIZE : _f, _g = props.width, width = _g === void 0 ?
DEFAULT_CELL_SIZE : _g, borderWidth = props.borderWidth;
var buttonBorderHovered = palette.neutralLighter;
var buttonBorderChecked = palette.neutralLight;
var buttonBorderCheckedHovered = palette.neutralSecondary;
var buttonBorderIsWhite = palette.neutralTertiary;
// If user provided a value, use it. If not, then we decide depending on the
24px size breakpoint.
var calculatedBorderWidth = borderWidth
? borderWidth
: width < CELL_BORDER_BREAKPOINT
? SMALL_BORDER
: LARGE_BORDER;
return {
// this is a button that wraps the color
colorCell: [
Styling_1.getFocusStyle(theme, { inset: -1, position: 'relative',
highContrastStyle: cellHighContrastFocus }),
{
padding: 0,
cursor: 'pointer',
userSelect: 'none',
borderRadius: 0,
border: 'none',
height: height,
width: width,
},
!circle && {
_a["." + Utilities_1.IsFocusVisibleClassName + "
&:focus::after"] = {
// -1px so that we don't increase visually the size of the
cell.
outlineOffset: calculatedBorderWidth - 1 + "px",
},
_a),
},
// In focus state for circle we want a round border which is not
possible with outline.
circle && {
_b["." + Utilities_1.IsFocusVisibleClassName + "
&:focus::after"] = {
outline: 'none',
borderColor: semanticColors.focusBorder,
left: -calculatedBorderWidth,
right: -calculatedBorderWidth,
top: -calculatedBorderWidth,
bottom: -calculatedBorderWidth,
outline: "1px solid ButtonText",
},
_c),
},
_b),
},
selected && {
padding: DIVIDING_PADDING,
border: calculatedBorderWidth + "px solid " + buttonBorderChecked,
_d['&:hover::before'] = {
content: '""',
height: height,
width: width,
top: -calculatedBorderWidth,
left: -calculatedBorderWidth,
borderRadius: circle ? '50%' : 'default',
boxShadow: "inset 0 0 0 1px " + buttonBorderCheckedHovered,
},
_d),
},
!selected && {
_e['&:hover, &:active, &:focus'] = {
border: calculatedBorderWidth + "px solid " +
buttonBorderHovered,
},
_e['&:focus'] = {
padding: 0,
selectors: {
':hover': {
borderColor: theme.palette.neutralLight,
},
},
},
_e),
},
disabled && {
opacity: 0.3,
},
isWhite &&
!selected && {
// fake a border for white
backgroundColor: buttonBorderIsWhite,
padding: 1,
},
],
// the <svg> that holds the color
svg: [
{
width: '100%',
height: '100%',
},
circle && {
},
],
};
};
//# sourceMappingURL=ColorPickerGridCell.styles.js.map
/***/ }),
/***/ 98117:
"use strict";

//# sourceMappingURL=ColorPickerGridCell.types.js.map
/***/ }),
/***/ 95217:
"use strict";

exports.SwatchColorPickerBase = void 0;
var ButtonGrid_1 = __webpack_require__(90555);
var ColorPickerGridCell_1 = __webpack_require__(66252);
var COMPONENT_NAME = 'SwatchColorPicker';
if (false) {}
}
exports.SwatchColorPickerBase = React.forwardRef(function (props, ref) {
var defaultId = react_hooks_1.useId('swatchColorPicker');
var id = props.id || defaultId;
isNavigationIdle: true,
cellFocused: false,
navigationIdleTimeoutId: undefined,
navigationIdleDelay: 250,
});
var _a = react_hooks_1.useSetTimeout(), setTimeout = _a.setTimeout,
clearTimeout = _a.clearTimeout;
var colorCells = props.colorCells, _b = props.cellShape, cellShape = _b ===
void 0 ? 'circle' : _b, columnCount = props.columnCount, _c =
props.shouldFocusCircularNavigate, shouldFocusCircularNavigate = _c === void 0 ?
true : _c, className = props.className, _d = props.disabled, disabled = _d === void
0 ? false : _d, doNotContainWithinFocusZone = props.doNotContainWithinFocusZone,
styles = props.styles, _e = props.cellMargin, cellMargin = _e === void 0 ? 10 : _e,
defaultSelectedId = props.defaultSelectedId, focusOnHover = props.focusOnHover,
mouseLeaveParentSelector = props.mouseLeaveParentSelector, onChange =
props.onChange,
onColorChanged = props.onColorChanged, onCellHovered = props.onCellHovered,
onCellFocused = props.onCellFocused, getColorGridCellStyles =
props.getColorGridCellStyles, cellHeight = props.cellHeight, cellWidth =
props.cellWidth, cellBorderWidth = props.cellBorderWidth;
/**
* Add an index to each color cells. Memoizes this so that color cells do not
re-render on every update.
*/
var itemsWithIndex = React.useMemo(function () {
return colorCells.map(function (item, index) {
return tslib_1.__assign(tslib_1.__assign({}, item), { index: index });
});
}, [colorCells]);
var mergedOnChange = React.useCallback(function (ev, newSelectedId) {
var _a;
// Call both new and old change handlers, and add the extra `color`
parameter
var newColor = (_a = colorCells.filter(function (c) { return c.id ===
newSelectedId; })[0]) === null || _a === void 0 ? void 0 : _a.color;
onChange === null || onChange === void 0 ? void 0 : onChange(ev,
newSelectedId, newColor);
onColorChanged === null || onColorChanged === void 0 ? void 0 :
onColorChanged(newSelectedId, newColor);
}, [onChange, onColorChanged, colorCells]);
var _f = react_hooks_1.useControllableValue(props.selectedId,
defaultSelectedId, mergedOnChange), selectedId = _f[0], setSelectedId = _f[1];
theme: props.theme,
cellMargin: cellMargin,
});
var gridStyles = {
root: classNames.root,
tableCell: classNames.tableCell,
focusedContainer: classNames.focusedContainer,
};
/**
* If there is only one row of cells, they should use radio semantics,
* multi-row swatch cells should use grid semantics.
* There are two reasons for this:
* 1. Radios are a more simple and understandable control, and a better fit
for a single-dimensional picker.
* 2. Multiple browsers use heuristics to strip table and grid roles from
single-row tables with no column headers.
*/
var isSemanticRadio = colorCells.length <= columnCount;
/**
* When the whole swatchColorPicker is blurred,
* make sure to clear the pending focused stated
*/
var onSwatchColorPickerBlur = React.useCallback(function (event) {
if (onCellFocused) {
internalState.cellFocused = false;
onCellFocused(undefined, undefined, event);
}
}, [internalState, onCellFocused]);
/**
* Callback passed to the GridCell that will manage triggering the
onCellHovered callback for mouseEnter
*/
var onMouseEnter = React.useCallback(function (ev) {
if (!focusOnHover) {
return !internalState.isNavigationIdle || !!disabled;
}
if (internalState.isNavigationIdle && !disabled) {
ev.currentTarget.focus();
}
return true;
}, [focusOnHover, internalState, disabled]);
/**
* Callback passed to the GridCell that will manage Hover/Focus updates
*/
var onMouseMove = React.useCallback(function (ev) {
if (!focusOnHover) {
return !internalState.isNavigationIdle || !!disabled;
}
// If navigation is idle and the targetElement is the focused element bail
out
if (internalState.isNavigationIdle && !(document && targetElement ===
document.activeElement)) {
}
return true;
}, [focusOnHover, internalState, disabled]);
/**
* Callback passed to the GridCell that will manage Hover/Focus updates
*/
var onMouseLeave = React.useCallback(function (ev) {
var parentSelector = mouseLeaveParentSelector;
if (!focusOnHover || !parentSelector || !internalState.isNavigationIdle ||
disabled) {
return;
}
// Get the elements that math the given selector
var elements = document.querySelectorAll(parentSelector);
// iterate over the elements return to make sure it is a parent of the
target and focus it
for (var index = 0; index < elements.length; index += 1) {
if (elements[index].contains(ev.currentTarget)) {
/**
* Edge and IE expose a setActive() function for focusable divs
that
*/
if (elements[index].setActive) {
try {
elements[index].setActive();
}
catch (e) {
/* no-op */
}
}
else {
elements[index].focus();
}
break;
}
}
}, [disabled, focusOnHover, internalState, mouseLeaveParentSelector]);
/**
* Callback passed to the GridCell class that will trigger the onCellHovered
callback of the SwatchColorPicker
* NOTE: This will not be triggered if shouldFocusOnHover === true
*/
var onGridCellHovered = React.useCallback(function (item, event) {
if (onCellHovered) {
item ? onCellHovered(item.id, item.color, event) :
onCellHovered(undefined, undefined, event);
}
}, [onCellHovered]);
/**
* Callback passed to the GridCell class that will trigger the onCellFocus
callback of the SwatchColorPicker
*/
var onGridCellFocused = React.useCallback(function (item, event) {
if (onCellFocused) {
if (item) {
internalState.cellFocused = true;
return onCellFocused(item.id, item.color, event);
}
else {
return onCellFocused(undefined, undefined, event);
}
}
}, [internalState, onCellFocused]);
/**
* Handle the click on a cell
*/
var onCellClick = React.useCallback(function (item, event) {
if (disabled) {
return;
}
if (item.id !== selectedId) {
if (onCellFocused && internalState.cellFocused) {
onCellFocused(undefined, undefined, event);
}
setSelectedId(item.id, event);
}
}, [disabled, internalState, onCellFocused, selectedId, setSelectedId]);
/**
* Sets a timeout so we won't process any mouse "hover" events
* while navigating (via mouseWheel or arrowKeys)
*/
var setNavigationTimeout = React.useCallback(function () {
if (!internalState.isNavigationIdle &&
internalState.navigationIdleTimeoutId !== undefined) {
clearTimeout(internalState.navigationIdleTimeoutId);
internalState.navigationIdleTimeoutId = undefined;
}
else {
internalState.isNavigationIdle = false;
}
internalState.navigationIdleTimeoutId = setTimeout(function () {
internalState.isNavigationIdle = true;
}, internalState.navigationIdleDelay);
}, [clearTimeout, internalState, setTimeout]);
/**
* Callback used to handle KeyCode events
*/
if (
ev.which === Utilities_1.KeyCodes.up ||
ev.which === Utilities_1.KeyCodes.down ||
ev.which === Utilities_1.KeyCodes.left ||
ev.which === Utilities_1.KeyCodes.right) {
setNavigationTimeout();
}
}, [setNavigationTimeout]);
/**
* Render a color cell
* @param item - The item to render
* @returns - Element representing the item
*/
var renderOption = function (item) {
return (React.createElement(ColorPickerGridCell_1.ColorPickerGridCell,
{ item: item, idPrefix: id, color: item.color, styles: getColorGridCellStyles,
disabled: disabled, onClick: onCellClick, onHover: onGridCellHovered, onFocus:
onGridCellFocused, selected: selectedId === item.id, circle: cellShape ===
'circle', label: item.label, onMouseEnter: onMouseEnter, onMouseMove: onMouseMove,
onMouseLeave: onMouseLeave, onWheel: setNavigationTimeout, onKeyDown: onKeyDown,
height: cellHeight, width: cellWidth, borderWidth: cellBorderWidth, isRadio:
isSemanticRadio }));
};
if (colorCells.length < 1 || columnCount < 1) {
return null;
}
var onRenderItem = function (item, index) {
var _a = props.onRenderColorCell, onRenderColorCell = _a === void 0 ?
renderOption : _a;
return onRenderColorCell(item, renderOption);
};
return (React.createElement(ButtonGrid_1.ButtonGrid, tslib_1.__assign({},
props, { ref: ref, id: id, items: itemsWithIndex, columnCount: columnCount,
isSemanticRadio: isSemanticRadio,
onRenderItem: onRenderItem, shouldFocusCircularNavigate:
shouldFocusCircularNavigate, doNotContainWithinFocusZone:
doNotContainWithinFocusZone, onBlur: onSwatchColorPickerBlur, theme: props.theme,
styles: gridStyles })));
});
exports.SwatchColorPickerBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=SwatchColorPicker.base.js.map
/***/ }),
/***/ 17081:
"use strict";

exports.SwatchColorPicker = void 0;
var SwatchColorPicker_base_1 = __webpack_require__(95217);
var SwatchColorPicker_styles_1 = __webpack_require__(87320);
exports.SwatchColorPicker =
Utilities_1.styled(SwatchColorPicker_base_1.SwatchColorPickerBase,
SwatchColorPicker_styles_1.getStyles, undefined, { scope: 'SwatchColorPicker' });
//# sourceMappingURL=SwatchColorPicker.js.map
/***/ }),
/***/ 87320:
"use strict";

focusedContainer: 'ms-swatchColorPickerBodyContainer',
};
var className = props.className, theme = props.theme, cellMargin =
props.cellMargin;
return {
root: {
margin: '8px 0',
borderCollapse: 'collapse',
},
tableCell: {
padding: cellMargin / 2,
},
focusedContainer: [
classNames.focusedContainer,
{
clear: 'both',
display: 'block',
minWidth: '180px',
},
className,
],
};
};
//# sourceMappingURL=SwatchColorPicker.styles.js.map
/***/ }),
/***/ 81590:
"use strict";

//# sourceMappingURL=SwatchColorPicker.types.js.map
/***/ }),
/***/ 71074:
"use strict";

/***/ }),
/***/ 4299:
"use strict";

exports.TeachingBubbleBase = void 0;
var TeachingBubbleContent_1 = __webpack_require__(25901);
var COMPONENT_NAME = 'TeachingBubble';
var defaultCalloutProps = {
beakWidth: 16,
gapSpace: 0,
setInitialFocus: true,
doNotLayer: false,
directionalHint: DirectionalHint_1.DirectionalHint.rightCenter,
};
var useComponentRef = function (componentRef, rootElementRef) {
focus: function () { var _a; return (_a = rootElementRef.current) === null
}); }, [rootElementRef]);
};
exports.TeachingBubbleBase = React.forwardRef(function (props, forwardedRef) {
var setCalloutProps = props.calloutProps,
targetElement = props.targetElement, onDismiss = props.onDismiss,
_a = props.hasCloseButton,
hasCloseButton = _a === void 0 ? props.hasCloseIcon : _a, isWide =
props.isWide, styles = props.styles, theme = props.theme, target = props.target;
var calloutProps = React.useMemo(function () { return
(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, defaultCalloutProps),
setCalloutProps), { theme: theme })); }, [setCalloutProps, theme]);
var stylesProps = {
theme: theme,
isWide: isWide,
calloutProps: calloutProps,
};
var classNames = getClassNames(styles, stylesProps);
var calloutStyles = classNames.subComponentStyles
? classNames.subComponentStyles.callout
: undefined;
useComponentRef(props.componentRef, rootElementRef);
return (React.createElement(Callout_1.Callout, tslib_1.__assign({ target:
target || targetElement, onDismiss: onDismiss }, calloutProps, { className:
classNames.root, styles: calloutStyles, hideOverflow: true }),
React.createElement("div", { ref: mergedRootRef },
React.createElement(TeachingBubbleContent_1.TeachingBubbleContent,
tslib_1.__assign({}, props)))));
});
exports.TeachingBubbleBase.displayName = COMPONENT_NAME;
//# sourceMappingURL=TeachingBubble.base.js.map
/***/ }),
/***/ 37050:
"use strict";

exports.TeachingBubble = void 0;
var TeachingBubble_base_1 = __webpack_require__(4299);
var TeachingBubble_styles_1 = __webpack_require__(6288);
exports.TeachingBubble =
Utilities_1.styled(TeachingBubble_base_1.TeachingBubbleBase,
TeachingBubble_styles_1.getStyles, undefined, { scope: 'TeachingBubble' });
//# sourceMappingURL=TeachingBubble.js.map
/***/ }),
/***/ 6288:
"use strict";

root: 'ms-TeachingBubble',
body: 'ms-TeachingBubble-body',
bodyContent: 'ms-TeachingBubble-bodycontent',
closeButton: 'ms-TeachingBubble-closebutton',
content: 'ms-TeachingBubble-content',
footer: 'ms-TeachingBubble-footer',
header: 'ms-TeachingBubble-header',
headerIsCondensed: 'ms-TeachingBubble-header--condensed',
headerIsSmall: 'ms-TeachingBubble-header--small',
headerIsLarge: 'ms-TeachingBubble-header--large',
headline: 'ms-TeachingBubble-headline',
image: 'ms-TeachingBubble-image',
primaryButton: 'ms-TeachingBubble-primaryButton',
secondaryButton: 'ms-TeachingBubble-secondaryButton',
subText: 'ms-TeachingBubble-subText',
// TODO: Button global class name usage should be converted to a styles
function once
// Button supports JS styling, which means these button names can be
removed.
button: 'ms-Button',
buttonLabel: 'ms-Button-label',
};
var opacityFadeIn = Utilities_1.memoizeFunction(function () {
'0%': {
opacity: 0,
animationTimingFunction: Styling_1.AnimationVariables.easeFunction1,
transform: 'scale3d(.90,.90,.90)',
},
'100%': {
opacity: 1,
transform: 'scale3d(1,1,1)',
},
});
});
var rootStyle = function (isWide, calloutProps) {
var _a = calloutProps || {}, calloutWidth = _a.calloutWidth, calloutMaxWidth =
_a.calloutMaxWidth;
return [
{
display: 'block',
maxWidth: 364,
border: 0,
width: calloutWidth || 'calc(100% + 1px)',
animationName: "" + opacityFadeIn(),
animationDuration: '300ms',
animationFillMode: 'both',
},
isWide && {
maxWidth: calloutMaxWidth || 456,
},
];
};
var headerStyle = function (classNames, hasCondensedHeadline, hasSmallHeadline) {
if (hasCondensedHeadline) {
return [
classNames.headerIsCondensed,
{
marginBottom: 14,
},
];
}
return [
hasSmallHeadline && classNames.headerIsSmall,
!hasSmallHeadline && classNames.headerIsLarge,
{
selectors: {
':not(:last-child)': {
marginBottom: 14,
},
},
},
];
};
var _a, _b, _c;
var hasCondensedHeadline = props.hasCondensedHeadline, hasSmallHeadline =
props.hasSmallHeadline, hasCloseButton = props.hasCloseButton, hasHeadline =
props.hasHeadline, isWide = props.isWide, primaryButtonClassName =
props.primaryButtonClassName, secondaryButtonClassName =
props.secondaryButtonClassName, theme = props.theme, _d = props.calloutProps,
calloutProps = _d === void 0 ? { className: undefined, theme: theme } : _d;
var hasLargeHeadline = !hasCondensedHeadline && !hasSmallHeadline;
theme.fonts;
var hideDefaultFocusRing = Styling_1.getFocusStyle(theme, {
outlineColor: 'transparent',
});
return {
root: [classNames.root, fonts.medium, calloutProps.className],
body: [
classNames.body,
hasCloseButton && !hasHeadline && { marginRight: 24 },
{
selectors: {
':not(:last-child)': {
marginBottom: 20,
},
},
},
],
bodyContent: [
classNames.bodyContent,
{
},
],
closeButton: [
{
right: 0,
top: 0,
margin: '15px 15px 0 0',
borderRadius: 0,
selectors: {
':hover': {
background: palette.themeDarkAlt,
},
':active': {
background: palette.themeDark,
},
':focus': {
border: "1px solid " + semanticColors.variantBorder,
},
},
},
],
content: tslib_1.__spreadArray(tslib_1.__spreadArray([
classNames.content
], rootStyle(isWide)), [
isWide && {
display: 'flex',
},
]),
footer: [
classNames.footer,
{
display: 'flex',
flex: 'auto',
// TODO: global class name usage should be converted to a
styles function once Button supports JS styling
_a["." + classNames.button + ":not(:first-child)"] = {
marginLeft: 10,
},
_a),
},
],
header: tslib_1.__spreadArray(tslib_1.__spreadArray([
classNames.header
], headerStyle(classNames, hasCondensedHeadline, hasSmallHeadline)), [
hasCloseButton && { marginRight: 24 },
(hasCondensedHeadline || hasSmallHeadline) && [
fonts.medium,
{
},
],
]),
headline: [
classNames.headline,
{
margin: 0,
},
hasLargeHeadline && [
{
},
],
],
imageContent: [
classNames.header,
classNames.image,
isWide && {
display: 'flex',
maxWidth: 154,
},
],
primaryButton: [
classNames.primaryButton,
primaryButtonClassName,
hideDefaultFocusRing,
{
borderColor: palette.white,
_b["." + classNames.buttonLabel] = fonts.medium,
_b[':hover'] = {
backgroundColor: palette.themeLighter,
borderColor: palette.themeLighter,
},
_b[':focus'] = {
backgroundColor: palette.themeLighter,
border: "1px solid " + palette.black,
outline: "1px solid " + palette.white,
},
_b[':active'] = {
},
_b),
},
],
secondaryButton: [
classNames.secondaryButton,
secondaryButtonClassName,
hideDefaultFocusRing,
{
_c["." + classNames.buttonLabel] = [
fonts.medium,
{
},
],
_c[':hover'] = {
backgroundColor: palette.themeDarkAlt,
},
_c[':focus'] = {
border: "1px solid " + palette.black,
outline: "1px solid " + palette.white,
},
_c[':active'] = {
},
_c),
},
],
subText: [
classNames.subText,
{
margin: 0,
},
],
callout: {
root: tslib_1.__spreadArray(tslib_1.__spreadArray([],
rootStyle(isWide, calloutProps)), [fonts.medium]),
beak: [
{
},
],
calloutMain: [
{
},
],
},
},
};
};
//# sourceMappingURL=TeachingBubble.styles.js.map
/***/ }),
/***/ 59805:
"use strict";

//# sourceMappingURL=TeachingBubble.types.js.map
/***/ }),
/***/ 21882:
"use strict";

exports.TeachingBubbleContentBase = void 0;
var Stack_1 = __webpack_require__(54648);
var useComponentRef = function (componentRef, rootElementRef) {
focus: function () { var _a; return (_a = rootElementRef.current) === null
}); }, [rootElementRef]);
};
exports.TeachingBubbleContentBase = React.forwardRef(function (props, forwardedRef)
{
var _a, _b;
var documentRef = WindowProvider_1.useDocument();
var ariaDescribedById = react_hooks_1.useId('teaching-bubble-content-');
var ariaLabelledById = react_hooks_1.useId('teaching-bubble-title-');
var ariaDescribedBy = (_a = props.ariaDescribedBy) !== null && _a !== void 0 ?
_a : ariaDescribedById;
var ariaLabelledBy = (_b = props.ariaLabelledBy) !== null && _b !== void 0 ? _b
: ariaLabelledById;
var illustrationImage = props.illustrationImage, primaryButtonProps =
props.primaryButtonProps, secondaryButtonProps = props.secondaryButtonProps,
headline = props.headline, hasCondensedHeadline = props.hasCondensedHeadline,
_c = props.hasCloseButton,
hasCloseButton = _c === void 0 ? props.hasCloseIcon : _c, onDismiss =
props.onDismiss, closeButtonAriaLabel = props.closeButtonAriaLabel,
hasSmallHeadline = props.hasSmallHeadline, isWide = props.isWide, styles =
props.styles, theme = props.theme, customFooterContent = props.footerContent,
focusTrapZoneProps = props.focusTrapZoneProps;
theme: theme,
hasCondensedHeadline: hasCondensedHeadline,
hasSmallHeadline: hasSmallHeadline,
hasHeadline: !!headline,
isWide: isWide,
primaryButtonClassName: primaryButtonProps ? primaryButtonProps.className :
undefined,
secondaryButtonClassName: secondaryButtonProps ?
secondaryButtonProps.className : undefined,
});
if (onDismiss) {
onDismiss(ev);
}
}
}, [onDismiss]);
react_hooks_1.useOnEvent(documentRef, 'keydown', onKeyDown);
var imageContent;
var headerContent;
var bodyContent;
var footerContent;
var closeButton;
if (illustrationImage && illustrationImage.src) {
imageContent = (React.createElement("div", { className:
classNames.imageContent },
React.createElement(Image_1.Image, tslib_1.__assign({},
illustrationImage))));
}
if (headline) {
var HeaderWrapperAs = typeof headline === 'string' ? 'p' : 'div';
headerContent = (React.createElement("div", { className:
classNames.header },
React.createElement(HeaderWrapperAs, { role: "heading", "aria-level":
3, className: classNames.headline, id: ariaLabelledBy }, headline)));
}
if (props.children) {
var BodyContentWrapperAs = typeof props.children === 'string' ? 'p' :
'div';
bodyContent = (React.createElement("div", { className: classNames.body },
React.createElement(BodyContentWrapperAs, { className:
classNames.subText, id: ariaDescribedBy }, props.children)));
}
if (primaryButtonProps || secondaryButtonProps || customFooterContent) {
footerContent = (React.createElement(Stack_1.Stack, { className:
classNames.footer, horizontal: true, horizontalAlign: customFooterContent ? 'space-
between' : 'end' },
React.createElement(Stack_1.Stack.Item, { align: "center" },
React.createElement("span", null, customFooterContent)),
React.createElement(Stack_1.Stack.Item, null,
primaryButtonProps && React.createElement(Button_1.PrimaryButton,
tslib_1.__assign({}, primaryButtonProps, { className: classNames.primaryButton })),
secondaryButtonProps && React.createElement(Button_1.DefaultButton,
tslib_1.__assign({}, secondaryButtonProps, { className:
classNames.secondaryButton })))));
}
if (hasCloseButton) {
closeButton = (React.createElement(Button_1.IconButton, { className:
classNames.closeButton, iconProps: { iconName: 'Cancel' }, ariaLabel:
closeButtonAriaLabel, onClick: onDismiss }));
}
useComponentRef(props.componentRef, rootElementRef);
return (React.createElement("div", { className: classNames.content, ref:
mergedRootRef, role: 'dialog', tabIndex: -1, "aria-labelledby": ariaLabelledBy,
"aria-describedby": ariaDescribedBy, "data-is-focusable": true },
imageContent,
tslib_1.__assign({ isClickableOutsideFocusTrap: true }, focusTrapZoneProps),
React.createElement("div", { className: classNames.bodyContent },
headerContent,
bodyContent,
footerContent,
closeButton))));
});
//# sourceMappingURL=TeachingBubbleContent.base.js.map
/***/ }),
/***/ 25901:
"use strict";

exports.TeachingBubbleContent = void 0;
var TeachingBubbleContent_base_1 = __webpack_require__(21882);
var TeachingBubble_styles_1 = __webpack_require__(6288);
exports.TeachingBubbleContent =
Utilities_1.styled(TeachingBubbleContent_base_1.TeachingBubbleContentBase,
TeachingBubble_styles_1.getStyles, undefined, { scope: 'TeachingBubbleContent' });
//# sourceMappingURL=TeachingBubbleContent.js.map
/***/ }),
/***/ 70787:
"use strict";

/***/ }),
/***/ 28442:
"use strict";

exports.Text = void 0;
var Text_view_1 = __webpack_require__(66720);
var Text_styles_1 = __webpack_require__(65961);
exports.Text = foundation_legacy_1.createComponent(Text_view_1.TextView, {
displayName: 'Text',
styles: Text_styles_1.TextStyles,
});
exports["default"] = exports.Text;
//# sourceMappingURL=Text.js.map
/***/ }),
/***/ 65961:
"use strict";

exports.TextStyles = void 0;
var TextStyles = function (props, theme) {
var as = props.as, className = props.className, block = props.block, nowrap =
props.nowrap, variant = props.variant;
var fonts = theme.fonts, semanticColors = theme.semanticColors;
var variantObject = fonts[variant || 'medium'];
return {
root: [
variantObject,
{
color: variantObject.color || semanticColors.bodyText,
display: block ? (as === 'td' ? 'table-cell' : 'block') : 'inline',
mozOsxFontSmoothing: variantObject.MozOsxFontSmoothing,
webkitFontSmoothing: variantObject.WebkitFontSmoothing,
},
nowrap && {
overflow: 'hidden',
},
className,
],
};
};
exports.TextStyles = TextStyles;
//# sourceMappingURL=Text.styles.js.map
/***/ }),
/***/ 50129:
"use strict";

//# sourceMappingURL=Text.types.js.map
/***/ }),
/***/ 66720:
"use strict";

exports.TextView = void 0;
/** @jsxRuntime classic */
/** @jsx withSlots */
var TextView = function (props) {
if (props.children == null) {
return null;
}
var block = props.block, className = props.className, _a = props.as, RootType =
_a === void 0 ? 'span' : _a, variant = props.variant, nowrap = props.nowrap, rest =
tslib_1.__rest(props, ["block", "className", "as", "variant", "nowrap"]);
root: RootType,
});
Utilities_1.getNativeProps(rest, Utilities_1.htmlElementProperties)));
};
exports.TextView = TextView;
//# sourceMappingURL=Text.view.js.map
/***/ }),
/***/ 6853:
"use strict";

/***/ }),
/***/ 48636:
"use strict";
exports.MaskedTextField = exports.DEFAULT_MASK_CHAR = void 0;
var inputMask_1 = __webpack_require__(92549);
var COMPONENT_NAME = 'MaskedTextField';
var useComponentRef = function (componentRef, internalState, textField) {
get value() {
var value = '';
for (var i = 0; i < internalState.maskCharData.length; i++) {
if (!internalState.maskCharData[i].value) {
return undefined;
}
value += internalState.maskCharData[i].value;
}
return value;
},
get selectionStart() {
return textField.current && textField.current.selectionStart !== null ?
textField.current.selectionStart : -1;
},
get selectionEnd() {
return textField.current && textField.current.selectionEnd ?
textField.current.selectionEnd : -1;
},
textField.current && textField.current.focus();
},
blur: function () {
textField.current && textField.current.blur();
},
select: function () {
textField.current && textField.current.select();
},
setSelectionStart: function (value) {
textField.current && textField.current.setSelectionStart(value);
},
setSelectionEnd: function (value) {
textField.current && textField.current.setSelectionEnd(value);
},
setSelectionRange: function (start, end) {
textField.current && textField.current.setSelectionRange(start, end);
},
}); }, [internalState, textField]);
};
exports.DEFAULT_MASK_CHAR = '_';
exports.MaskedTextField = React.forwardRef(function (props, ref) {
var textField = React.useRef(null);
var componentRef = props.componentRef, onFocus = props.onFocus, onBlur =
props.onBlur, onMouseDown = props.onMouseDown, onMouseUp = props.onMouseUp,
onChange = props.onChange, onPaste = props.onPaste, onKeyDown = props.onKeyDown,
mask = props.mask, _a = props.maskChar, maskChar = _a === void 0 ?
exports.DEFAULT_MASK_CHAR : _a, _b = props.maskFormat, maskFormat = _b === void 0 ?
inputMask_1.DEFAULT_MASK_FORMAT_CHARS : _b, value = props.value;
var internalState = react_hooks_1.useConst(function () { return ({
maskCharData: inputMask_1.parseMask(mask, maskFormat),
isFocused: false,
moveCursorOnMouseUp: false,
changeSelectionData: null,
}); });
/** The index into the rendered value of the first unfilled format character */
var _c = React.useState(), maskCursorPosition = _c[0], setMaskCursorPosition =
_c[1];
/**
* The mask string formatted with the input value.
* This is what is displayed inside the TextField
* @example
* `Phone Number: 12_ - 4___`
*/
var _d = React.useState(function () {
return inputMask_1.getMaskDisplay(mask, internalState.maskCharData,
maskChar);
}), displayValue = _d[0], setDisplayValue = _d[1];
var setValue = React.useCallback(function (newValue) {
var valueIndex = 0;
var charDataIndex = 0;
while (valueIndex < newValue.length && charDataIndex <
internalState.maskCharData.length) {
// Test if the next character in the new value fits the next format
character
var testVal = newValue[valueIndex];
if (internalState.maskCharData[charDataIndex].format.test(testVal)) {
internalState.maskCharData[charDataIndex].value = testVal;
charDataIndex++;
}
valueIndex++;
}
}, [internalState]);
var handleFocus = React.useCallback(function (ev) {
onFocus === null || onFocus === void 0 ? void 0 : onFocus(ev);
internalState.isFocused = true;
// Move the cursor position to the leftmost unfilled position
setMaskCursorPosition(internalState.maskCharData[i].displayIndex);
break;
}
}
}, [internalState, onFocus]);
var handleBlur = React.useCallback(function (ev) {
onBlur === null || onBlur === void 0 ? void 0 : onBlur(ev);
internalState.isFocused = false;
internalState.moveCursorOnMouseUp = true;
}, [internalState, onBlur]);
var handleMouseDown = React.useCallback(function (ev) {
onMouseDown === null || onMouseDown === void 0 ? void 0 : onMouseDown(ev);
if (!internalState.isFocused) {
internalState.moveCursorOnMouseUp = true;
}
}, [internalState, onMouseDown]);
var handleMouseUp = React.useCallback(function (ev) {
onMouseUp === null || onMouseUp === void 0 ? void 0 : onMouseUp(ev);
// Move the cursor on mouseUp after focusing the textField
if (internalState.moveCursorOnMouseUp) {
internalState.moveCursorOnMouseUp = false;
// Move the cursor position to the rightmost unfilled position
setMaskCursorPosition(internalState.maskCharData[i].displayIndex);
break;
}
}
}
}, [internalState, onMouseUp]);
var handleInputChange = React.useCallback(function (ev, inputValue) {
if (internalState.changeSelectionData === null && textField.current) {
internalState.changeSelectionData = {
changeType: 'default',
selectionStart: textField.current.selectionStart !== null ?
textField.current.selectionStart : -1,
selectionEnd: textField.current.selectionEnd !== null ?
textField.current.selectionEnd : -1,
};
}
if (!internalState.changeSelectionData) {
return;
}
// The initial value of cursorPos does not matter
var cursorPos = 0;
var _a = internalState.changeSelectionData, changeType = _a.changeType,
selectionStart = _a.selectionStart, selectionEnd = _a.selectionEnd;
if (changeType === 'textPasted') {
var charsSelected = selectionEnd - selectionStart;
var charCount = inputValue.length + charsSelected -
displayValue.length;
var startPos = selectionStart;
var pastedString = inputValue.substr(startPos, charCount);
// Clear any selected characters
if (charsSelected) {
internalState.maskCharData =
inputMask_1.clearRange(internalState.maskCharData, selectionStart, charsSelected);
}
cursorPos = inputMask_1.insertString(internalState.maskCharData,
startPos, pastedString);
}
else if (changeType === 'delete' || changeType === 'backspace') {
// isDel is true If the characters are removed LTR, otherwise RTL
var isDel = changeType === 'delete';
var charCount = selectionEnd - selectionStart;
if (charCount) {
// charCount is > 0 if range was deleted
inputMask_1.clearRange(internalState.maskCharData, selectionStart, charCount);
cursorPos =
inputMask_1.getRightFormatIndex(internalState.maskCharData, selectionStart);
}
else {
// If charCount === 0, there was no selection and a single
character was deleted
if (isDel) {
inputMask_1.clearNext(internalState.maskCharData, selectionStart);
cursorPos =
inputMask_1.getRightFormatIndex(internalState.maskCharData, selectionStart);
}
else {
inputMask_1.clearPrev(internalState.maskCharData, selectionStart);
cursorPos =
inputMask_1.getLeftFormatIndex(internalState.maskCharData, selectionStart);
}
}
}
else if (inputValue.length > displayValue.length) {
// This case is if the user added characters
var charCount = inputValue.length - displayValue.length;
var startPos = selectionEnd - charCount;
var enteredString = inputValue.substr(startPos, charCount);
startPos, enteredString);
}
else if (inputValue.length <= displayValue.length) {
/**
* This case is reached only if the user has selected a block of 1 or
more
* characters and input a character replacing the characters they've
selected.
*/
var charCount = 1;
var selectCount = displayValue.length + charCount - inputValue.length;
var startPos = selectionEnd - charCount;
var enteredString = inputValue.substr(startPos, charCount);
// Clear the selected range
inputMask_1.clearRange(internalState.maskCharData, startPos, selectCount);
// Insert the printed character
startPos, enteredString);
}
internalState.changeSelectionData = null;
var newValue = inputMask_1.getMaskDisplay(mask, internalState.maskCharData,
maskChar);
setDisplayValue(newValue);
setMaskCursorPosition(cursorPos);
// Perform onChange after input has been processed. Return value is
expected to be the displayed text
onChange === null || onChange === void 0 ? void 0 : onChange(ev, newValue);
}, [displayValue.length, internalState, mask, maskChar, onChange]);
var handleKeyDown = React.useCallback(function (ev) {
onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(ev);
internalState.changeSelectionData = null;
if (textField.current && textField.current.value) {
var keyCode = ev.keyCode, ctrlKey = ev.ctrlKey, metaKey = ev.metaKey;
// Ignore ctrl and meta keydown
if (ctrlKey || metaKey) {
return;
}
// On backspace or delete, store the selection and the keyCode
if (keyCode === Utilities_1.KeyCodes.backspace || keyCode ===
Utilities_1.KeyCodes.del) {
var selectionStart = ev.target.selectionStart;
var selectionEnd = ev.target.selectionEnd;
// Check if backspace or delete press is valid.
if (!(keyCode === Utilities_1.KeyCodes.backspace && selectionEnd &&
selectionEnd > 0) &&
!(keyCode === Utilities_1.KeyCodes.del && selectionStart !==
null && selectionStart < textField.current.value.length)) {
return;
}
changeType: keyCode === Utilities_1.KeyCodes.backspace ?
'backspace' : 'delete',
selectionStart: selectionStart !== null ? selectionStart : -1,
selectionEnd: selectionEnd !== null ? selectionEnd : -1,
};
}
}
}, [internalState, onKeyDown]);
var handlePaste = React.useCallback(function (ev) {
onPaste === null || onPaste === void 0 ? void 0 : onPaste(ev);
var selectionStart = ev.target.selectionStart;
var selectionEnd = ev.target.selectionEnd;
// Store the paste selection range
changeType: 'textPasted',
selectionStart: selectionStart !== null ? selectionStart : -1,
selectionEnd: selectionEnd !== null ? selectionEnd : -1,
};
}, [internalState, onPaste]);
// Updates the display value if mask or value props change.
internalState.maskCharData = inputMask_1.parseMask(mask, maskFormat);
value !== undefined && setValue(value);
setDisplayValue(inputMask_1.getMaskDisplay(mask,
internalState.maskCharData, maskChar));
// eslint-disable-next-line react-hooks/exhaustive-deps -- Should only
update when mask or value changes.
}, [mask, value]);
// Run before browser paint to avoid flickering from selection reset.
// Move the cursor to position before paint.
if (maskCursorPosition !== undefined && textField.current) {
textField.current.setSelectionRange(maskCursorPosition,
maskCursorPosition);
}
}, [maskCursorPosition]);
// Run after browser paint.
// Move the cursor to the start of the mask format after values update.
if (internalState.isFocused && maskCursorPosition !== undefined &&
textField.current) {
textField.current.setSelectionRange(maskCursorPosition,
maskCursorPosition);
}
});
useComponentRef(componentRef, internalState, textField);
return (React.createElement(TextField_1.TextField, tslib_1.__assign({}, props,
{ elementRef: ref, onFocus: handleFocus, onBlur: handleBlur, onMouseDown:
handleMouseDown, onMouseUp: handleMouseUp, onChange: handleInputChange, onKeyDown:
handleKeyDown, onPaste: handlePaste, value: displayValue || '', componentRef:
textField })));
});
exports.MaskedTextField.displayName = COMPONENT_NAME;
//# sourceMappingURL=MaskedTextField.js.map
/***/ }),
/***/ 92549:
"use strict";

exports.insertString = exports.clearPrev = exports.clearNext = exports.clearRange =
exports.getLeftFormatIndex = exports.getRightFormatIndex = exports.getMaskDisplay =
exports.parseMask = exports.DEFAULT_MASK_FORMAT_CHARS = void 0;
exports.DEFAULT_MASK_FORMAT_CHARS = {
'9': /[0-9]/,
a: /[a-zA-Z]/,
'*': /[a-zA-Z0-9]/,
};
/**
* Takes in the mask string and the formatCharacters and returns an array of
MaskValues
* Example:
* mask = 'Phone Number: (999) - 9999'
* return = [
* { value: undefined, displayIndex: 16, format: /[0-9]/ },
* ]
*
* @param mask The string use to define the format of the displayed maskedValue.
* @param formatChars An object defining how certain characters in the mask should
accept input.
*/
function parseMask(mask, formatChars) {
if (formatChars === void 0) { formatChars =
exports.DEFAULT_MASK_FORMAT_CHARS; }
if (!mask) {
return [];
}
var maskCharData = [];
// Count the escape characters in the mask string.
var escapedChars = 0;
for (var i = 0; i + escapedChars < mask.length; i++) {
var maskChar = mask.charAt(i + escapedChars);
if (maskChar === '\\') {
escapedChars++;
}
else {
// Check if the maskChar is a format character.
var maskFormat = formatChars[maskChar];
if (maskFormat) {
maskCharData.push({
/**
* Do not add escapedChars to the displayIndex.
* The index refers to a position in the mask's displayValue.
* Since the backslashes don't appear in the displayValue,
* we do not add them to the charData displayIndex.
*/
displayIndex: i,
format: maskFormat,
});
}
}
}
return maskCharData;
}
exports.parseMask = parseMask;
/**
* Takes in the mask string, an array of MaskValues, and the maskCharacter
* returns the mask string formatted with the input values and maskCharacter.
* If the maskChar is undefined, the maskDisplay is truncated to the last filled
format character.
* Example:
* mask = 'Phone Number: (999) 999 - 9999'
* maskCharData = '12345'
* maskChar = '_'
* return = 'Phone Number: (123) 45_ - ___'
*
* Example:
* mask = 'Phone Number: (999) 999 - 9999'
* value = '12345'
* maskChar = undefined
* return = 'Phone Number: (123) 45'
*
* @param mask The string use to define the format of the displayed maskedValue.
* @param maskCharData The input values to insert into the mask string for
displaying.
* @param maskChar? A character to display in place of unfilled mask format
characters.
*/
function getMaskDisplay(mask, maskCharData, maskChar) {
var maskDisplay = mask;
if (!maskDisplay) {
return '';
}
// Remove all backslashes
maskDisplay = maskDisplay.replace(/\\/g, '');
// lastDisplayIndex is is used to truncate the string if necessary.
var lastDisplayIndex = 0;
if (maskCharData.length > 0) {
lastDisplayIndex = maskCharData[0].displayIndex - 1;
}
/**
* For each input value, replace the character in the maskDisplay with the
value.
* If there is no value set for the format character, use the maskChar.
*/
for (var _i = 0, maskCharData_1 = maskCharData; _i < maskCharData_1.length; _i+
+) {
var charData = maskCharData_1[_i];
var nextChar = ' ';
if (charData.value) {
nextChar = charData.value;
if (charData.displayIndex > lastDisplayIndex) {
lastDisplayIndex = charData.displayIndex;
}
}
else {
if (maskChar) {
nextChar = maskChar;
}
}
// Insert the character into the maskdisplay at its corresponding index
maskDisplay = maskDisplay.slice(0, charData.displayIndex) + nextChar +
maskDisplay.slice(charData.displayIndex + 1);
}
// Cut off all mask characters after the last filled format value
if (!maskChar) {
maskDisplay = maskDisplay.slice(0, lastDisplayIndex + 1);
}
return maskDisplay;
}
exports.getMaskDisplay = getMaskDisplay;
/**
* Get the next format index right of or at a specified index.
* If no index exists, returns the rightmost index.
* @param maskCharData
* @param index
*/
function getRightFormatIndex(maskCharData, index) {
for (var i = 0; i < maskCharData.length; i++) {
if (maskCharData[i].displayIndex >= index) {
return maskCharData[i].displayIndex;
}
}
return maskCharData[maskCharData.length - 1].displayIndex;
}
exports.getRightFormatIndex = getRightFormatIndex;
/**
* Get the next format index left of a specified index.
* If no index exists, returns the leftmost index.
* @param index
*/
function getLeftFormatIndex(maskCharData, index) {
for (var i = maskCharData.length - 1; i >= 0; i--) {
if (maskCharData[i].displayIndex < index) {
return maskCharData[i].displayIndex;
}
}
return maskCharData[0].displayIndex;
}
exports.getLeftFormatIndex = getLeftFormatIndex;
/**
* Deletes all values in maskCharData with a displayIndex that falls inside the
specified range.
* maskCharData is modified inline and also returned.
* @param selectionStart
* @param selectionCount
*/
function clearRange(maskCharData, selectionStart, selectionCount) {
if (maskCharData[i].displayIndex >= selectionStart) {
if (maskCharData[i].displayIndex >= selectionStart + selectionCount) {
break;
}
maskCharData[i].value = undefined;
}
}
}
exports.clearRange = clearRange;
/**
* Deletes the input character at or after a specified index and returns the new
array of charData
*/
function clearNext(maskCharData, selectionStart) {
break;
}
}
}
exports.clearNext = clearNext;
/**
* Deletes the input character before a specified index and returns the new array
of charData
*/
function clearPrev(maskCharData, selectionStart) {
for (var i = maskCharData.length - 1; i >= 0; i--) {
if (maskCharData[i].displayIndex < selectionStart) {
break;
}
}
}
exports.clearPrev = clearPrev;
/**
* Deletes all values in maskCharData with a displayIndex that falls inside the
specified range.
* Modifies the maskCharData inplace with the passed string and returns the display
index of the
* next format character after the inserted string.
* @param selectionCount
* @return The displayIndex of the next format character
*/
function insertString(maskCharData, selectionStart, newString) {
var stringIndex = 0;
var nextIndex = 0;
var isStringInserted = false;
// Iterate through _maskCharData finding values with a displayIndex after the
specified range start
for (var i = 0; i < maskCharData.length && stringIndex < newString.length; i++)
{
isStringInserted = true;
nextIndex = maskCharData[i].displayIndex;
// Find the next character in the newString that matches the format
while (stringIndex < newString.length) {
// If the character matches the format regexp, set the maskCharData
to the new character
if (maskCharData[i].format.test(newString.charAt(stringIndex))) {
maskCharData[i].value = newString.charAt(stringIndex++);
// Set the nextIndex to the display index of the next mask
format character.
if (i + 1 < maskCharData.length) {
nextIndex = maskCharData[i + 1].displayIndex;
}
else {
nextIndex++;
}
break;
}
stringIndex++;
}
}
}
return isStringInserted ? nextIndex : selectionStart;
}
exports.insertString = insertString;
//# sourceMappingURL=inputMask.js.map
/***/ }),
/***/ 75407:
"use strict";

exports.TextFieldBase = void 0;
var DEFAULT_STATE_VALUE = '';
var COMPONENT_NAME = 'TextField';
var REVEAL_ICON_NAME = 'RedEye';
var HIDE_ICON_NAME = 'Hide';
var TextFieldBase = /** @class */ (function (_super) {
tslib_1.__extends(TextFieldBase, _super);
function TextFieldBase(props) {
_this._textElement = React.createRef();
if (_this.props.onFocus) {
_this.props.onFocus(ev);
}
_this.setState({ isFocused: true }, function () {
if (_this.props.validateOnFocusIn) {
_this._validate(_this.value);
}
});
};
_this._onBlur = function (ev) {
}
_this.setState({ isFocused: false }, function () {
if (_this.props.validateOnFocusOut) {
_this._validate(_this.value);
}
});
};
_this._onRenderLabel = function (props) {
var label = props.label, required = props.required;
// IProcessedStyleSet definition requires casting for what Label
expects as its styles prop
var labelStyles = _this._classNames.subComponentStyles
? _this._classNames.subComponentStyles.label
: undefined;
if (label) {
return (React.createElement(Label_1.Label, { required: required,
htmlFor: _this._id, styles: labelStyles, disabled: props.disabled, id:
_this._labelId }, props.label));
}
return null;
};
_this._onRenderDescription = function (props) {
if (props.description) {
_this._classNames.description }, props.description);
}
return null;
};
_this._onRevealButtonClick = function (event) {
_this.setState(function (prevState) { return ({ isRevealingPassword: !
prevState.isRevealingPassword }); });
};
_this._onInputChange = function (event) {
// Previously, we needed to call both onInput and onChange due to some
weird IE/React issues,
// which have *probably* been fixed now:
// - https://github.com/microsoft/fluentui/issues/744 (likely fixed)
// - https://github.com/microsoft/fluentui/issues/824 (confirmed fixed)
var _a, _b;
// TODO (Fabric 8?) - Switch to calling only onChange. This switch is
pretty disruptive for
// tests (ours and maybe consumers' too), so it seemed best to do the
switch in a major bump.
var element = event.target;
var value = element.value;
// Ignore this event if any of the following are true:
// - the value is undefined (in case one of the IE bugs comes back)
// - it's a duplicate event (important since onInputChange is called
twice per actual user event)
// - it's the same as the previous value
var previousValue = _getValue(_this.props, _this.state) || '';
if (value === undefined || value === _this._lastChangeValue || value
=== previousValue) {
_this._lastChangeValue = undefined;
return;
}
_this._lastChangeValue = value;
(_b = (_a = _this.props).onChange) === null || _b === void 0 ? void 0 :
_b.call(_a, event, value);
if (!_this._isControlled) {
// ONLY if this is an uncontrolled component, update the displayed
value.
// (Controlled components must update the `value` prop from
ònChange`.)
_this.setState({ uncontrolledValue: value });
}
};
if (false) {}
_this._fallbackId = Utilities_1.getId(COMPONENT_NAME);
_this._descriptionId = Utilities_1.getId(COMPONENT_NAME + 'Description');
_this._labelId = Utilities_1.getId(COMPONENT_NAME + 'Label');
_this._prefixId = Utilities_1.getId(COMPONENT_NAME + 'Prefix');
_this._suffixId = Utilities_1.getId(COMPONENT_NAME + 'Suffix');
_this._warnControlledUsage();
var _a = props.defaultValue, defaultValue = _a === void 0 ?
DEFAULT_STATE_VALUE : _a;
if (typeof defaultValue === 'number') {
// This isn't allowed per the props, but happens anyway.
defaultValue = String(defaultValue);
}
_this.state = {
uncontrolledValue: _this._isControlled ? undefined : defaultValue,
isFocused: false,
errorMessage: '',
};
_this._delayedValidate = _this._async.debounce(_this._validate,
_this.props.deferredValidationTime);
_this._lastValidation = 0;
return _this;
}
Object.defineProperty(TextFieldBase.prototype, "value", {
/**
* Gets the current value of the text field.
*/
get: function () {
return _getValue(this.props, this.state);
},
enumerable: false,
configurable: true
});
TextFieldBase.prototype.componentDidMount = function () {
this._adjustInputHeight();
if (this.props.validateOnLoad) {
this._validate(this.value);
}
};
TextFieldBase.prototype.componentWillUnmount = function () {
};
TextFieldBase.prototype.getSnapshotBeforeUpdate = function (prevProps,
prevState) {
return {
selection: [this.selectionStart, this.selectionEnd],
};
};
TextFieldBase.prototype.componentDidUpdate = function (prevProps, prevState,
snapshot) {
var _a = (snapshot || {}).selection, selection = _a === void 0 ? [null,
null] : _a;
var start = selection[0], end = selection[1];
if (!!prevProps.multiline !== !!props.multiline && prevState.isFocused) {
// The text field has just changed between single- and multi-line, so
we need to reset focus
// and selection/cursor.
this.focus();
if (start !== null && end !== null && start >= 0 && end >= 0) {
this.setSelectionRange(start, end);
}
}
if (prevProps.value !== props.value) {
// Only if the value in props changed, reset the record of the last
value seen by a
// change/input event (don't do this if the value in state changed,
since at least in tests
// the state update may happen before the second event in a series)
this._lastChangeValue = undefined;
}
var prevValue = _getValue(prevProps, prevState);
var value = this.value;
if (prevValue !== value) {
// Handle controlled/uncontrolled warnings and status
this._warnControlledUsage(prevProps);
// Clear error message if needed
// TODO: is there any way to do this without an extra render?
if (this.state.errorMessage && !props.errorMessage) {
this.setState({ errorMessage: '' });
}
// Adjust height if needed based on new value
this._adjustInputHeight();
// TODO: #5875 added logic to trigger validation in
componentWillReceiveProps and other places.
// This seems a bit odd and hard to integrate with the new approach.
// (Starting to think we should just put the validation logic in a
separate wrapper component...?)
if (_shouldValidateAllChanges(props)) {
this._delayedValidate(value);
}
}
};
TextFieldBase.prototype.render = function () {
var _a = this.props, borderless = _a.borderless, className = _a.className,
disabled = _a.disabled, invalid = _a.invalid, iconProps = _a.iconProps,
inputClassName = _a.inputClassName, label = _a.label, multiline = _a.multiline,
required = _a.required, underlined = _a.underlined, prefix = _a.prefix, resizable =
_a.resizable, suffix = _a.suffix, theme = _a.theme, styles = _a.styles,
autoAdjustHeight = _a.autoAdjustHeight, canRevealPassword = _a.canRevealPassword,
revealPasswordAriaLabel = _a.revealPasswordAriaLabel, type = _a.type, _b =
_a.onRenderPrefix, onRenderPrefix = _b === void 0 ? this._onRenderPrefix : _b, _c =
_a.onRenderSuffix, onRenderSuffix = _c === void 0 ? this._onRenderSuffix : _c, _d =
_a.onRenderLabel, onRenderLabel = _d === void 0 ? this._onRenderLabel : _d, _e =
_a.onRenderDescription, onRenderDescription = _e === void 0 ?
this._onRenderDescription : _e;
var _f = this.state, isFocused = _f.isFocused, isRevealingPassword =
_f.isRevealingPassword;
var errorMessage = this._errorMessage;
var isInvalid = typeof invalid === 'boolean' ? invalid : !!errorMessage;
var hasRevealButton = !!canRevealPassword && type === 'password' &&
_browserNeedsRevealButton();
var classNames = (this._classNames = getClassNames(styles, {
theme: theme,
disabled: disabled,
focused: isFocused,
required: required,
multiline: multiline,
hasLabel: !!label,
hasErrorMessage: isInvalid,
borderless: borderless,
resizable: resizable,
hasIcon: !!iconProps,
inputClassName: inputClassName,
autoAdjustHeight: autoAdjustHeight,
hasRevealButton: hasRevealButton,
}));
return (
React.createElement("div", { ref: this.props.elementRef, className:
classNames.root },
React.createElement("div", { className: classNames.wrapper },
onRenderLabel(this.props, this._onRenderLabel),
React.createElement("div", { className: classNames.fieldGroup },
(prefix !== undefined || this.props.onRenderPrefix) &&
(React.createElement("div", { className: classNames.prefix, id: this._prefixId },
onRenderPrefix(this.props, this._onRenderPrefix))),
multiline ? this._renderTextArea() : this._renderInput(),
iconProps && React.createElement(Icon_1.Icon,
tslib_1.__assign({ className: classNames.icon }, iconProps)),
hasRevealButton && (
// Explicitly set type="button" since the default button type
within a form is "submit"
React.createElement("button", { "aria-label":
revealPasswordAriaLabel, className: classNames.revealButton, onClick:
this._onRevealButtonClick, "aria-pressed": !!isRevealingPassword, type: "button" },
classNames.revealSpan },
classNames.revealIcon, iconName: isRevealingPassword ? HIDE_ICON_NAME :
REVEAL_ICON_NAME })))),
(suffix !== undefined || this.props.onRenderSuffix) &&
(React.createElement("div", { className: classNames.suffix, id: this._suffixId },
onRenderSuffix(this.props, this._onRenderSuffix))))),
this._isDescriptionAvailable && (React.createElement("span", { id:
this._descriptionId },
onRenderDescription(this.props, this._onRenderDescription),
errorMessage && (React.createElement("div", { role: "alert" },
this._renderErrorMessage())))))));
};
/**
* Sets focus on the text field
*/
TextFieldBase.prototype.focus = function () {
if (this._textElement.current) {
this._textElement.current.focus();
}
};
/**
* Blurs the text field.
*/
TextFieldBase.prototype.blur = function () {
this._textElement.current.blur();
}
};
/**
* Selects the text field
*/
TextFieldBase.prototype.select = function () {
this._textElement.current.select();
}
};
/**
* Sets the selection start of the text field to a specified value
*/
TextFieldBase.prototype.setSelectionStart = function (value) {
this._textElement.current.selectionStart = value;
}
};
/**
* Sets the selection end of the text field to a specified value
*/
TextFieldBase.prototype.setSelectionEnd = function (value) {
this._textElement.current.selectionEnd = value;
}
};
Object.defineProperty(TextFieldBase.prototype, "selectionStart", {
/**
* Gets the selection start of the text field
*/
get: function () {
return this._textElement.current ?
this._textElement.current.selectionStart : -1;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TextFieldBase.prototype, "selectionEnd", {
/**
* Gets the selection end of the text field
*/
get: function () {
return this._textElement.current ?
this._textElement.current.selectionEnd : -1;
},
enumerable: false,
configurable: true
});
/**
* Sets the start and end positions of a selection in a text field.
* @param start - Index of the start of the selection.
* @param end - Index of the end of the selection.
*/
TextFieldBase.prototype.setSelectionRange = function (start, end) {
this._textElement.current.setSelectionRange(start, end);
}
};
TextFieldBase.prototype._warnControlledUsage = function (prevProps) {
// Show warnings if props are being used in an invalid way
Utilities_1.warnControlledUsage({
componentId: this._id,
componentName: COMPONENT_NAME,
props: this.props,
oldProps: prevProps,
valueProp: 'value',
defaultValueProp: 'defaultValue',
onChangeProp: 'onChange',
readOnlyProp: 'readOnly',
});
if (this.props.value === null && !this._hasWarnedNullValue) {
this._hasWarnedNullValue = true;
Utilities_1.warn("Warning: 'value' prop on '" + COMPONENT_NAME + "'
should not be null. Consider using an " +
'empty string to clear the component or undefined to indicate an
uncontrolled component.');
}
};
Object.defineProperty(TextFieldBase.prototype, "_id", {
/** Returns `props.id` if available, or a fallback if not. */
get: function () {
return this.props.id || this._fallbackId;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TextFieldBase.prototype, "_isControlled", {
get: function () {
return Utilities_1.isControlled(this.props, 'value');
},
enumerable: false,
configurable: true
});
TextFieldBase.prototype._onRenderPrefix = function (props) {
var prefix = props.prefix;
return React.createElement("span", { style: { paddingBottom: '1px' } },
prefix);
};
TextFieldBase.prototype._onRenderSuffix = function (props) {
var suffix = props.suffix;
return React.createElement("span", { style: { paddingBottom: '1px' } },
suffix);
};
Object.defineProperty(TextFieldBase.prototype, "_errorMessage", {
/**
* Current error message from either `props.errorMessage` or the result of
`props.onGetErrorMessage`.
*
* - If there is no validation error or we have not validated the input
value, errorMessage is an empty string.
* - If we have done the validation and there is validation error,
errorMessage is the validation error message.
*/
get: function () {
var _a = this.props.errorMessage, errorMessage = _a === void 0 ?
this.state.errorMessage : _a;
return errorMessage || '';
},
enumerable: false,
configurable: true
});
/**
* Renders error message based on the type of the message.
*
* - If error message is string, it will render using the built in styles.
* - If error message is an element, user has full control over how it's
rendered.
*/
TextFieldBase.prototype._renderErrorMessage = function () {
var errorMessage = this._errorMessage;
return errorMessage ? (typeof errorMessage === 'string' ?
(React.createElement("p", { className: this._classNames.errorMessage },
React.createElement("span", { "data-automation-id": "error-message" },
errorMessage))) : (React.createElement("div", { className:
this._classNames.errorMessage, "data-automation-id": "error-message" },
errorMessage))) : null;
};
Object.defineProperty(TextFieldBase.prototype, "_isDescriptionAvailable", {
/**
* If a custom description render function is supplied then treat
description as always available.
* Otherwise defer to the presence of description or error message text.
*/
get: function () {
return !!(props.onRenderDescription || props.description ||
this._errorMessage);
},
enumerable: false,
configurable: true
});
TextFieldBase.prototype._renderTextArea = function () {
var _a = this.props.invalid, invalid = _a === void 0 ? !!this._errorMessage
: _a;
var textAreaProps = Utilities_1.getNativeProps(this.props,
Utilities_1.textAreaProperties, ['defaultValue']);
var ariaLabelledBy = this.props['aria-labelledby'] || (this.props.label ?
this._labelId : undefined);
return (React.createElement("textarea", tslib_1.__assign({ id: this._id },
textAreaProps, { ref: this._textElement, value: this.value || '', onInput:
this._onInputChange, onChange: this._onInputChange, className:
this._classNames.field, "aria-labelledby": ariaLabelledBy, "aria-describedby":
this._isDescriptionAvailable ? this._descriptionId : this.props['aria-
describedby'], "aria-invalid": invalid, "aria-label": this.props.ariaLabel,
readOnly: this.props.readOnly, onFocus: this._onFocus, onBlur: this._onBlur })));
};
TextFieldBase.prototype._renderInput = function () {
var _a = this.props, ariaLabel = _a.ariaLabel, _b = _a.invalid, invalid =
_b === void 0 ? !!this._errorMessage : _b, onRenderPrefix = _a.onRenderPrefix,
onRenderSuffix = _a.onRenderSuffix, prefix = _a.prefix, suffix = _a.suffix, _c =
_a.type, type = _c === void 0 ? 'text' : _c, label = _a.label;
// build aria-labelledby list from label, prefix, and suffix
var labelIds = [];
label && labelIds.push(this._labelId);
(prefix !== undefined || onRenderPrefix) && labelIds.push(this._prefixId);
(suffix !== undefined || onRenderSuffix) && labelIds.push(this._suffixId);
var inputProps = tslib_1.__assign(tslib_1.__assign({ type:
this.state.isRevealingPassword ? 'text' : type, id: this._id },
Utilities_1.getNativeProps(this.props, Utilities_1.inputProperties,
['defaultValue', 'type'])), { 'aria-labelledby': this.props['aria-labelledby'] ||
(labelIds.length > 0 ? labelIds.join(' ') : undefined), ref: this._textElement,
value: this.value || '', onInput: this._onInputChange, onChange:
this._onInputChange, className: this._classNames.field, 'aria-label': ariaLabel,
'aria-describedby': this._isDescriptionAvailable ? this._descriptionId :
this.props['aria-describedby'], 'aria-invalid': invalid, onFocus: this._onFocus,
onBlur: this._onBlur });
var defaultRender = function (updatedInputProps) {
return React.createElement("input", tslib_1.__assign({},
updatedInputProps));
};
var onRenderInput = this.props.onRenderInput || defaultRender;
return onRenderInput(inputProps, defaultRender);
};
TextFieldBase.prototype._validate = function (value) {
var _this = this;
// In case _validate is called again while validation promise is executing
if (this._latestValidateValue === value &&
_shouldValidateAllChanges(this.props)) {
return;
}
this._latestValidateValue = value;
var onGetErrorMessage = this.props.onGetErrorMessage;
var result = onGetErrorMessage && onGetErrorMessage(value || '');
if (result !== undefined) {
if (typeof result === 'string' || !('then' in result)) {
this.setState({ errorMessage: result });
this._notifyAfterValidate(value, result);
}
else {
var currentValidation_1 = ++this._lastValidation;
result.then(function (errorMessage) {
if (currentValidation_1 === _this._lastValidation) {
_this.setState({ errorMessage: errorMessage });
}
_this._notifyAfterValidate(value, errorMessage);
});
}
}
else {
this._notifyAfterValidate(value, '');
}
};
TextFieldBase.prototype._notifyAfterValidate = function (value, errorMessage) {
if (value === this.value && this.props.onNotifyValidationResult) {
this.props.onNotifyValidationResult(errorMessage, value);
}
};
TextFieldBase.prototype._adjustInputHeight = function () {
if (this._textElement.current && this.props.autoAdjustHeight &&
this.props.multiline) {
var textField = this._textElement.current;
textField.style.height = '';
textField.style.height = textField.scrollHeight + 'px';
}
};
TextFieldBase.defaultProps = {
resizable: true,
deferredValidationTime: 200,
validateOnLoad: true,
};
return TextFieldBase;
exports.TextFieldBase = TextFieldBase;
/** Get the value from the given state and props (converting from number to string
if needed) */
function _getValue(props, state) {
var _a = props.value, value = _a === void 0 ? state.uncontrolledValue : _a;
// not allowed per typings, but happens anyway
return String(value);
}
return value;
}
/**
* If `validateOnFocusIn` or `validateOnFocusOut` is true, validation should run
**only** on that event.
* Otherwise, validation should run on every change.
*/
function _shouldValidateAllChanges(props) {
return !(props.validateOnFocusIn || props.validateOnFocusOut);
}
// Only calculate this once across all TextFields, since will stay the same
var __browserNeedsRevealButton;
function _browserNeedsRevealButton() {
if (typeof __browserNeedsRevealButton !== 'boolean') {
var win = Utilities_1.getWindow();
if (win === null || win === void 0 ? void 0 : win.navigator) {
// Edge, Chromium Edge
var isEdge = /Êdg/.test(win.navigator.userAgent || '');
__browserNeedsRevealButton = !(Utilities_1.isIE11() || isEdge);
}
else {
__browserNeedsRevealButton = true;
}
}
return __browserNeedsRevealButton;
}
//# sourceMappingURL=TextField.base.js.map
/***/ }),
/***/ 86675:
"use strict";

exports.TextField = void 0;
var TextField_base_1 = __webpack_require__(75407);
var TextField_styles_1 = __webpack_require__(42494);
exports.TextField = Utilities_1.styled(TextField_base_1.TextFieldBase,
TextField_styles_1.getStyles, undefined, {
scope: 'TextField',
});
//# sourceMappingURL=TextField.js.map
/***/ }),
/***/ 42494:
"use strict";

root: 'ms-TextField',
description: 'ms-TextField-description',
errorMessage: 'ms-TextField-errorMessage',
field: 'ms-TextField-field',
fieldGroup: 'ms-TextField-fieldGroup',
prefix: 'ms-TextField-prefix',
suffix: 'ms-TextField-suffix',
wrapper: 'ms-TextField-wrapper',
revealButton: 'ms-TextField-reveal',
multiline: 'ms-TextField--multiline',
borderless: 'ms-TextField--borderless',
underlined: 'ms-TextField--underlined',
unresizable: 'ms-TextField--unresizable',
required: 'is-required',
disabled: 'is-disabled',
active: 'is-active',
};
function getLabelStyles(props) {
var underlined = props.underlined, disabled = props.disabled, focused =
props.focused, theme = props.theme;
var _a;
return ({
root: [
underlined &&
disabled && {
color: palette.neutralTertiary,
},
underlined && {
marginRight: 8,
paddingLeft: 12,
paddingRight: 0,
lineHeight: '22px',
height: 32,
},
underlined &&
focused && {
height: 31, // -1px to prevent jumpiness in HC with the
increased border-width to 2px
},
_a),
},
],
});
};
}
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
props.disabled, focused = props.focused, required = props.required, multiline =
props.multiline, hasLabel = props.hasLabel, borderless = props.borderless,
underlined = props.underlined, hasIcon = props.hasIcon, resizable =
props.resizable, hasErrorMessage = props.hasErrorMessage, inputClassName =
props.inputClassName, autoAdjustHeight = props.autoAdjustHeight, hasRevealButton =
props.hasRevealButton;
theme.fonts;
var fieldPrefixSuffix = {
// Suffix/Prefix are not editable so the disabled slot perfectly fits.
background: semanticColors.disabledBackground,
color: !disabled ? semanticColors.inputPlaceholderText :
semanticColors.disabledText,
display: 'flex',
padding: '0 10px',
lineHeight: 1,
flexShrink: 0,
},
_a),
};
{
opacity: 1,
color: 'GrayText',
},
_b),
},
];
var disabledPlaceholderStyles = {
color: 'GrayText',
},
_c),
};
return {
root: [
classNames.root,
fonts.medium,
required && classNames.required,
disabled && classNames.disabled,
focused && classNames.active,
multiline && classNames.multiline,
borderless && classNames.borderless,
underlined && classNames.underlined,
{
},
className,
],
wrapper: [
classNames.wrapper,
underlined && [
{
display: 'flex',
borderBottom: "1px solid " + (!hasErrorMessage ?
semanticColors.inputBorder : semanticColors.errorText),
width: '100%',
},
disabled && {
borderBottomColor: semanticColors.disabledBackground,
tslib_1.__assign({ borderColor: 'GrayText' },
_d),
},
!disabled && {
selectors: {
':hover': {
borderBottomColor: !hasErrorMessage ?
semanticColors.inputBorderHovered : semanticColors.errorText,
tslib_1.__assign({ borderBottomColor: 'Highlight' },
_e),
},
},
},
focused && [
{
},
Styling_1.getInputFocusStyle(!hasErrorMessage ?
semanticColors.inputFocusBorderAlt : semanticColors.errorText, 0, 'borderBottom'),
],
],
],
fieldGroup: [
classNames.fieldGroup,
{
border: "1px solid " + semanticColors.inputBorder,
background: semanticColors.inputBackground,
cursor: 'text',
height: 32,
display: 'flex',
},
multiline && {
minHeight: '60px',
height: 'auto',
display: 'flex',
},
!focused &&
!disabled && {
selectors: {
':hover': {
_f[Styling_1.HighContrastSelector] = tslib_1.__assign({
borderColor: 'Highlight' }, Styling_1.getHighContrastNoAdjustStyle()),
_f),
},
},
},
focused &&
!underlined &&
Styling_1.getInputFocusStyle(!hasErrorMessage ?
semanticColors.inputFocusBorderAlt : semanticColors.errorText,
effects.roundedCorner2),
disabled && {
_g[Styling_1.HighContrastSelector] =
tslib_1.__assign({ borderColor: 'GrayText' },
_g),
cursor: 'default',
},
borderless && {
border: 'none',
},
borderless &&
focused && {
border: 'none',
selectors: {
':after': {
border: 'none',
},
},
},
underlined && {
flex: '1 1 0px',
border: 'none',
textAlign: 'left',
},
underlined &&
disabled && {
},
hasErrorMessage &&
!underlined && {
selectors: {
'&:hover': {
},
},
},
!hasLabel &&
required && {
selectors: (_h = {
':before': {
content: "'*'",
top: -5,
right: -10,
}
},
selectors: {
':before': {
right: -14, // moving the * 4 pixel to right to
alleviate border clipping in HC mode.
},
},
},
_h),
},
],
field: [
fonts.medium,
classNames.field,
{
borderRadius: 0,
border: 'none',
background: 'none',
padding: '0 8px',
width: '100%',
minWidth: 0,
outline: 0,
selectors: (_j = {
'&:active, &:focus, &:hover': { outline: 0 },
'::-ms-clear': {
display: 'none',
}
},
},
_j),
},
multiline &&
!resizable && [
classNames.unresizable,
{
resize: 'none',
},
],
multiline && {
minHeight: 'inherit',
lineHeight: 17,
flexGrow: 1,
paddingTop: 6,
paddingBottom: 6,
overflow: 'auto',
width: '100%',
},
multiline &&
autoAdjustHeight && {
overflow: 'hidden',
},
hasIcon &&
!hasRevealButton && {
paddingRight: 24,
},
multiline &&
hasIcon && {
paddingRight: 40,
},
disabled && [
{
},
Styling_1.getPlaceholderStyles(disabledPlaceholderStyles),
],
underlined && {
textAlign: 'left',
},
focused &&
!borderless && {
paddingLeft: 11,
paddingRight: 11,
},
_k),
},
focused &&
multiline &&
!borderless && {
paddingTop: 4, // take into consideration the 2px increased
border-width (not when borderless).
},
_l),
},
inputClassName,
],
icon: [
multiline && {
paddingRight: 24,
alignItems: 'flex-end',
},
{
bottom: 6,
right: 8,
top: 'auto',
lineHeight: 18,
},
disabled && {
},
],
description: [
classNames.description,
{
},
],
errorMessage: [
classNames.errorMessage,
fonts.small,
{
margin: 0,
paddingTop: 5,
display: 'flex',
},
],
prefix: [classNames.prefix, fieldPrefixSuffix],
suffix: [classNames.suffix, fieldPrefixSuffix],
revealButton: [
classNames.revealButton,
'ms-Button',
'ms-Button--icon',
Styling_1.getFocusStyle(theme, { inset: 1 }),
{
height: 30,
width: 32,
border: 'none',
padding: '0px 4px',
selectors: {
':hover': {
outline: 0,
color: semanticColors.primaryButtonBackgroundHovered,
backgroundColor: semanticColors.buttonBackgroundHovered,
_m[Styling_1.HighContrastSelector] = {
color: 'Highlight',
},
_m),
},
':focus': { outline: 0 },
},
},
hasIcon && {
marginRight: 28,
},
],
revealSpan: {
display: 'flex',
height: '100%',
},
revealIcon: {
margin: '0px 4px',
bottom: 6,
right: 8,
top: 'auto',
lineHeight: 18,
},
label: getLabelStyles(props),
},
};
}
//# sourceMappingURL=TextField.styles.js.map
/***/ }),
/***/ 98634:
"use strict";

//# sourceMappingURL=TextField.types.js.map
/***/ }),
/***/ 25893:
"use strict";

/***/ }),
/***/ 54147:
"use strict";

//# sourceMappingURL=IThemeRules.js.map
/***/ }),
/***/ 84908:
"use strict";

//# sourceMappingURL=IThemeSlotRule.js.map
/***/ }),
/***/ 14844:
"use strict";

exports.ThemeGenerator = void 0;
var shades_1 = __webpack_require__(48032);
var ThemeGenerator = /** @class */ (function () {
function ThemeGenerator() {
}
/**
* Sets an IThemeSlotRule to the given color and cascades it to the rest of the
theme, updating other IThemeSlotRules
* in the theme that inherit from that color.
* @param isInverted - whether it's a dark theme or not, which affects the
algorithm used to generate shades
* @param isCustomization - should be true only if it's a user action, and
indicates overwriting the slot's
* inheritance (if any)
* @param overwriteCustomColor - A slot could have a generated color based on
its inheritance rules (isCustomized
* is false), or a custom color based on user input (isCustomized is true).
This bool tells us whether to override
* existing customized colors.
*/
ThemeGenerator.setSlot = function (rule, color, isInverted, isCustomization,
overwriteCustomColor) {
if (isInverted === void 0) { isInverted = false; }
if (isCustomization === void 0) { isCustomization = false; }
if (overwriteCustomColor === void 0) { overwriteCustomColor = true; }
if (!rule.color && rule.value) {
// not a color rule
return;
}
if (overwriteCustomColor) {
var colorAsIColor = void 0;
if (typeof color === 'string') {
colorAsIColor = getColorFromString_1.getColorFromString(color); //
the ! is a lie here but we'll verify it in the next line
if (!colorAsIColor) {
throw new Error('color is invalid in setSlot(): ' + color);
}
}
else {
colorAsIColor = color;
}
ThemeGenerator._setSlot(rule, colorAsIColor, isInverted,
isCustomization, overwriteCustomColor);
}
else if (rule.color) {
ThemeGenerator._setSlot(rule, rule.color, isInverted, isCustomization,
overwriteCustomColor);
}
};
/**
* Sets the color of each slot based on its rule. Slots that don't inherit must
have a color already.
* If this completes without error, then the theme is ready to use. (All slots
will have a color.)
* setSlot() can be called before this, but this must be called before
getThemeAs*().
* Does not override colors of rules where isCustomized is true (i.e. doesn't
override existing customizations).
*/
ThemeGenerator.insureSlots = function (slotRules, isInverted) {
// Get all the "root" rules, the ones which don't inherit. Then "set" them
to trigger updating dependent slots.
for (var ruleName in slotRules) {
if (slotRules.hasOwnProperty(ruleName)) {
var rule = slotRules[ruleName];
if (!rule.inherits && !rule.value) {
if (!rule.color) {
throw new Error('A color slot rule that does not inherit
must provide its own color.');
}
ThemeGenerator._setSlot(rule, rule.color, isInverted, false,
false);
}
}
}
};
/**
* Gets the JSON-formatted blob that describes the theme, usable with the REST
request endpoints:
* ```
* { [theme slot name as string] : [color as string],
* "tokenName": "#f00f00",
* "tokenName2": "#ba2ba2",
* ... }
* ```
*/
ThemeGenerator.getThemeAsJson = function (slotRules) {
var theme = {};
theme[rule.name] = rule.color ? rule.color.str : rule.value || '';
}
}
return theme;
};
/**
* Gets code-formatted load theme blob that can be copy and pasted.
* Only used for the old theme designer, where loadTheme usage is acceptable,
* unlike in the new theme designer.
*/
ThemeGenerator.getThemeAsCode = function (slotRules) {
var output = 'loadTheme({\n palette: {\n';
return ThemeGenerator._makeRemainingCode(output, slotRules);
};
/**
* Gets code-formatted load theme blob, specifically for the new theme
designer,
* aka.ms/themedesigner. Shouldn't use loadTheme like the old theme designer
since it's deprecated.
* We want to use the theme object from createTheme and use the
Customizations.applySettings API instead.
*/
ThemeGenerator.getThemeAsCodeWithCreateTheme = function (slotRules) {
var output = 'const myTheme = createTheme({\n palette: {\n';
return ThemeGenerator._makeRemainingCode(output, slotRules);
};
/**
* Gets the theme as a list of SASS variables that can be used in code
* ```
* $tokenName: "[theme:tokenName, default:#f00f00]";
* $tokenName2: "[theme:tokenName2, default:#ba2ba2]";
* ...
* ```
*/
ThemeGenerator.getThemeAsSass = function (slotRules) {
var sassVarTemplate = '${0}Color: "[theme: {1}, default: {2}]";\n';
var output = '';
var camelCasedName = rule.name.charAt(0).toLowerCase() +
rule.name.slice(1);
output += Utilities_1.format(sassVarTemplate, camelCasedName,
camelCasedName, rule.color ? rule.color.str : rule.value || '');
}
}
return output;
};
/**
* Gets the theme formatted for PowerShell scripts
* ```
* @{
* "tokenName" = "#f00f00";
* "tokenName2" = "#ba2ba2";
* ...
* }
* ```
*/
ThemeGenerator.getThemeForPowerShell = function (slotRules) {
var psVarTemplate = '"{0}" = "{1}";\n';
var output = '';
if (rule.value) {
// skip this one, it's not a color
continue;
}
rule.name.slice(1);
var outputColor = rule.color ? '#' + rule.color.hex : rule.value ||
'';
// powershell endpoint uses the RGBA format
if (rule.color && rule.color.a && rule.color.a !== 100) {
outputColor += String(rule.color.a.toString(16));
}
output += Utilities_1.format(psVarTemplate, camelCasedName,
outputColor);
}
}
return '@{\n' + output + '}';
};
/**
* Sets the given slot's color to the appropriate color, shading it if
necessary.
* Then, iterates through all other rules (that are this rule's dependents) to
update them accordingly.
* @param isCustomization - If true, it's a user-provided color, which should
be to that raw color.
* If false, the rule it's inheriting from changed, so updated using asShade.
*/
ThemeGenerator._setSlot = function (rule, color, isInverted, isCustomization,
overwriteCustomColor) {
if (overwriteCustomColor === void 0) { overwriteCustomColor = true; }
if (!rule.color && rule.value) {
// not a color rule
return;
}
if (overwriteCustomColor || !rule.color || !rule.isCustomized || !
rule.inherits) {
// set the rule's color under these conditions
if ((overwriteCustomColor || !rule.isCustomized) &&
!isCustomization &&
rule.inherits &&
shades_1.isValidShade(rule.asShade)) {
// it's inheriting by shade
if (rule.isBackgroundShade) {
rule.color = shades_1.getBackgroundShade(color, rule.asShade,
isInverted);
}
else {
rule.color = shades_1.getShade(color, rule.asShade,
isInverted);
}
rule.isCustomized = false;
}
else {
rule.color = color;
rule.isCustomized = true;
}
// then update dependent colors
for (var _i = 0, _a = rule.dependentRules; _i < _a.length; _i++) {
var ruleToUpdate = _a[_i];
ThemeGenerator._setSlot(ruleToUpdate, rule.color, isInverted,
false, overwriteCustomColor);
}
}
};
/**
* Makes the rest of the code that's used for the load theme blob in the
exported codepens of
* both the older sharepoint-specific theme designer and the new theme
designer. Takes in
* theme rules and converts them to format fitting a list of palette colors and
their values.
* Resulting output looks like:
* ```
* const _theme = createTheme({
* palette: {
* themePrimary: '#0078d4',
* themeLighterAlt: '#f3f9fd',
* ...
* }});
* ```
* The first line is loadTheme instead of createTheme for the old sharepoint
theme designer.
*/
ThemeGenerator._makeRemainingCode = function (output, slotRules) {
var attributeTemplate = " {0}: '{1}',\n";
rule.name.slice(1);
var outputColor = rule.color ? '#' + rule.color.hex : rule.value ||
'';
output += Utilities_1.format(attributeTemplate, camelCasedName,
outputColor);
}
}
output += ' }});';
return output;
};
return ThemeGenerator;
}());
exports.ThemeGenerator = ThemeGenerator;
//# sourceMappingURL=ThemeGenerator.js.map
/***/ }),
/***/ 61019:
"use strict";

exports.themeRulesStandardCreator = exports.SemanticColorSlots =
exports.FabricSlots = exports.BaseSlots = void 0;
var shades_1 = __webpack_require__(48032);
/* This is the set of rules for our default theme.
We start with three base slots, defining the background, foreground (text), and
primary color (sometimes called theme color). Each Fabric slot is generated from
shades (or tints) of one of those three, creating the Fabric palette.
Then, we have semantic slots, the new thing intended to eventually replace the
Fabric palette. The semantic slots inherit from the Fabric palette. */
/* The most minimal set of slots we start with. All other ones can be generated
based on rules.
* This is not so much an enum as it is a list. The enum is used to insure "type"-
safety.
* For now, we are only dealing with color. */
var BaseSlots;
(function (BaseSlots) {
BaseSlots[BaseSlots["primaryColor"] = 0] = "primaryColor";
BaseSlots[BaseSlots["backgroundColor"] = 1] = "backgroundColor";
BaseSlots[BaseSlots["foregroundColor"] = 2] = "foregroundColor";
})(BaseSlots = exports.BaseSlots || (exports.BaseSlots = {}));
/* The original Fabric palette, only for back-compat. */
var FabricSlots;
(function (FabricSlots) {
FabricSlots[FabricSlots["themePrimary"] = 0] = "themePrimary";
FabricSlots[FabricSlots["themeLighterAlt"] = 1] = "themeLighterAlt";
FabricSlots[FabricSlots["themeLighter"] = 2] = "themeLighter";
FabricSlots[FabricSlots["themeLight"] = 3] = "themeLight";
FabricSlots[FabricSlots["themeTertiary"] = 4] = "themeTertiary";
FabricSlots[FabricSlots["themeSecondary"] = 5] = "themeSecondary";
FabricSlots[FabricSlots["themeDarkAlt"] = 6] = "themeDarkAlt";
FabricSlots[FabricSlots["themeDark"] = 7] = "themeDark";
FabricSlots[FabricSlots["themeDarker"] = 8] = "themeDarker";
FabricSlots[FabricSlots["neutralLighterAlt"] = 9] = "neutralLighterAlt";
FabricSlots[FabricSlots["neutralLighter"] = 10] = "neutralLighter";
FabricSlots[FabricSlots["neutralLight"] = 11] = "neutralLight";
FabricSlots[FabricSlots["neutralQuaternaryAlt"] = 12] = "neutralQuaternaryAlt";
FabricSlots[FabricSlots["neutralQuaternary"] = 13] = "neutralQuaternary";
FabricSlots[FabricSlots["neutralTertiaryAlt"] = 14] = "neutralTertiaryAlt";
FabricSlots[FabricSlots["neutralTertiary"] = 15] = "neutralTertiary";
FabricSlots[FabricSlots["neutralSecondaryAlt"] = 16] = "neutralSecondaryAlt";
FabricSlots[FabricSlots["neutralSecondary"] = 17] = "neutralSecondary";
FabricSlots[FabricSlots["neutralPrimaryAlt"] = 18] = "neutralPrimaryAlt";
FabricSlots[FabricSlots["neutralPrimary"] = 19] = "neutralPrimary";
FabricSlots[FabricSlots["neutralDark"] = 20] = "neutralDark";
FabricSlots[FabricSlots["black"] = 21] = "black";
FabricSlots[FabricSlots["white"] = 22] = "white";
})(FabricSlots = exports.FabricSlots || (exports.FabricSlots = {}));
/* List of all the semantic color slots for this theme.
* This is not so much an enum as it is a list. The enum is used to insure "type"-
safety. */
var SemanticColorSlots;
(function (SemanticColorSlots) {
SemanticColorSlots[SemanticColorSlots["bodyBackground"] = 0] =
"bodyBackground";
SemanticColorSlots[SemanticColorSlots["bodyText"] = 1] = "bodyText";
SemanticColorSlots[SemanticColorSlots["disabledBackground"] = 2] =
"disabledBackground";
SemanticColorSlots[SemanticColorSlots["disabledText"] = 3] = "disabledText";
})(SemanticColorSlots = exports.SemanticColorSlots || (exports.SemanticColorSlots =
{}));
function themeRulesStandardCreator() {
var slotRules = {};
/*** BASE COLORS and their SHADES */
// iterate through each base slot and make the SlotRules for those
Utilities_1.mapEnumByName(BaseSlots, function (baseSlot) {
// first make the SlotRule for the unshaded base Color
slotRules[baseSlot] = {
name: baseSlot,
isCustomized: true,
dependentRules: [],
};
// then make a rule for each shade of this base color, but skip unshaded
Utilities_1.mapEnumByName(shades_1.Shade, function (shadeName, shadeValue)
{
if (shadeName === shades_1.Shade[shades_1.Shade.Unshaded]) {
return;
}
var inherits = slotRules[baseSlot];
var thisSlotRule = {
name: baseSlot + shadeName,
inherits: slotRules[baseSlot],
asShade: shadeValue,
isCustomized: false,
isBackgroundShade: baseSlot ===
BaseSlots[BaseSlots.backgroundColor] ? true : false,
dependentRules: [],
};
slotRules[baseSlot + shadeName] = thisSlotRule;
inherits.dependentRules.push(thisSlotRule);
return undefined;
});
return undefined;
});
// set default colors for the base colors
slotRules[BaseSlots[BaseSlots.primaryColor]].color =
getColorFromString_1.getColorFromString('#0078d4');
slotRules[BaseSlots[BaseSlots.backgroundColor]].color =
getColorFromString_1.getColorFromString('#ffffff');
slotRules[BaseSlots[BaseSlots.foregroundColor]].color =
getColorFromString_1.getColorFromString('#323130');
function _makeFabricSlotRule(slotName, inheritedBase, inheritedShade,
isBackgroundShade) {
if (isBackgroundShade === void 0) { isBackgroundShade = false; }
var inherits = slotRules[BaseSlots[inheritedBase]];
var thisSlotRule = {
name: slotName,
inherits: inherits,
asShade: inheritedShade,
isCustomized: false,
isBackgroundShade: isBackgroundShade,
dependentRules: [],
};
slotRules[slotName] = thisSlotRule;
inherits.dependentRules.push(thisSlotRule);
}
_makeFabricSlotRule(FabricSlots[FabricSlots.themePrimary],
BaseSlots.primaryColor, shades_1.Shade.Unshaded);
_makeFabricSlotRule(FabricSlots[FabricSlots.themeLighterAlt],
BaseSlots.primaryColor, shades_1.Shade.Shade1);
_makeFabricSlotRule(FabricSlots[FabricSlots.themeLighter],
_makeFabricSlotRule(FabricSlots[FabricSlots.themeLight],
_makeFabricSlotRule(FabricSlots[FabricSlots.themeTertiary],
_makeFabricSlotRule(FabricSlots[FabricSlots.themeSecondary],
_makeFabricSlotRule(FabricSlots[FabricSlots.themeDarkAlt],
_makeFabricSlotRule(FabricSlots[FabricSlots.themeDark], BaseSlots.primaryColor,
shades_1.Shade.Shade7);
_makeFabricSlotRule(FabricSlots[FabricSlots.themeDarker],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralLighterAlt],
BaseSlots.backgroundColor, shades_1.Shade.Shade1, true);
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralLighter],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralLight],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralQuaternaryAlt],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralQuaternary],
// bg6 or fg2
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralTertiaryAlt],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralTertiary],
BaseSlots.foregroundColor, shades_1.Shade.Shade3);
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralSecondary],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralSecondaryAlt],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralPrimaryAlt],
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralPrimary],
BaseSlots.foregroundColor, shades_1.Shade.Unshaded);
_makeFabricSlotRule(FabricSlots[FabricSlots.neutralDark],
_makeFabricSlotRule(FabricSlots[FabricSlots.black], BaseSlots.foregroundColor,
shades_1.Shade.Shade8);
_makeFabricSlotRule(FabricSlots[FabricSlots.white], BaseSlots.backgroundColor,
shades_1.Shade.Unshaded, true);
slotRules[FabricSlots[FabricSlots.neutralLighterAlt]].color =
getColorFromString_1.getColorFromString('#faf9f8');
slotRules[FabricSlots[FabricSlots.neutralLighter]].color =
getColorFromString_1.getColorFromString('#f3f2f1');
slotRules[FabricSlots[FabricSlots.neutralLight]].color =
getColorFromString_1.getColorFromString('#edebe9');
slotRules[FabricSlots[FabricSlots.neutralQuaternaryAlt]].color =
getColorFromString_1.getColorFromString('#e1dfdd');
slotRules[FabricSlots[FabricSlots.neutralDark]].color =
getColorFromString_1.getColorFromString('#201f1e');
slotRules[FabricSlots[FabricSlots.neutralTertiaryAlt]].color =
getColorFromString_1.getColorFromString('#c8c6c4');
slotRules[FabricSlots[FabricSlots.black]].color =
slotRules[FabricSlots[FabricSlots.neutralDark]].color =
getColorFromString_1.getColorFromString('#201f1e');
slotRules[FabricSlots[FabricSlots.neutralPrimaryAlt]].color =
getColorFromString_1.getColorFromString('#3b3a39');
slotRules[FabricSlots[FabricSlots.neutralSecondary]].color =
getColorFromString_1.getColorFromString('#605e5c');
slotRules[FabricSlots[FabricSlots.neutralSecondaryAlt]].color =
getColorFromString_1.getColorFromString('#8a8886');
slotRules[FabricSlots[FabricSlots.neutralTertiary]].color =
getColorFromString_1.getColorFromString('#a19f9d');
slotRules[FabricSlots[FabricSlots.white]].color =
getColorFromString_1.getColorFromString('#ffffff');
slotRules[FabricSlots[FabricSlots.themeDarker]].color =
slotRules[FabricSlots[FabricSlots.themeDark]].color =
getColorFromString_1.getColorFromString('#005a9e');
slotRules[FabricSlots[FabricSlots.themeDarkAlt]].color =
getColorFromString_1.getColorFromString('#106ebe');
slotRules[FabricSlots[FabricSlots.themeSecondary]].color =
getColorFromString_1.getColorFromString('#2b88d8');
slotRules[FabricSlots[FabricSlots.themeTertiary]].color =
getColorFromString_1.getColorFromString('#71afe5');
slotRules[FabricSlots[FabricSlots.themeLight]].color =
getColorFromString_1.getColorFromString('#c7e0f4');
slotRules[FabricSlots[FabricSlots.themeLighter]].color =
getColorFromString_1.getColorFromString('#deecf9');
slotRules[FabricSlots[FabricSlots.themeLighterAlt]].color =
getColorFromString_1.getColorFromString('#eff6fc');
slotRules[FabricSlots[FabricSlots.neutralLighterAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralLighter]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralLight]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralQuaternaryAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralDark]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralTertiaryAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.black]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralDark]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralPrimaryAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralSecondary]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralSecondaryAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.neutralTertiary]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.white]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeDarker]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeDark]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeDarkAlt]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themePrimary]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeSecondary]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeTertiary]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeLight]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeLighter]].isCustomized = true;
slotRules[FabricSlots[FabricSlots.themeLighterAlt]].isCustomized = true;
return slotRules;
}
exports.themeRulesStandardCreator = themeRulesStandardCreator;
//# sourceMappingURL=ThemeRulesStandard.js.map
/***/ }),
/***/ 43339:
"use strict";

/***/ }),
/***/ 31420:
"use strict";

exports.TimePicker = void 0;
var ComboBox_1 = __webpack_require__(20862);
var REGEX_SHOW_SECONDS_HOUR_12 = /^((1[0-2]|0?[1-9]):([0-5][0-9]):([0-5][0-9])\
s([AaPp][Mm]))$/;
var REGEX_HIDE_SECONDS_HOUR_12 = /^((1[0-2]|0?[1-9]):[0-5][0-9]\s([AaPp][Mm]))$/;
var REGEX_SHOW_SECONDS_HOUR_24 = /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/;
var REGEX_HIDE_SECONDS_HOUR_24 = /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/;
var TIME_LOWER_BOUND = 0;
var TIME_UPPER_BOUND = 23;
var getDefaultStrings = function (useHour12, showSeconds) {
var hourUnits = useHour12 ? '12-hour' : '24-hour';
var timeFormat = "hh:mm" + (showSeconds ? ':ss' : '') + (useHour12 ? ' AP' :
'');
var errorMessageToDisplay = "Enter a valid time in the " + hourUnits + "
format: " + timeFormat;
return {
invalidInputErrorMessage: errorMessageToDisplay,
};
};
var TimePicker = function (_a) {
var label = _a.label, _b = _a.increments, increments = _b === void 0 ? 30 : _b,
_c = _a.showSeconds, showSeconds = _c === void 0 ? false : _c, _d =
_a.allowFreeform, allowFreeform = _d === void 0 ? true : _d, _e = _a.useHour12,
useHour12 = _e === void 0 ? false : _e, timeRange = _a.timeRange, _f = _a.strings,
strings = _f === void 0 ? getDefaultStrings(useHour12, showSeconds) : _f,
defaultValue = _a.defaultValue, onChange = _a.onChange, onFormatDate =
_a.onFormatDate, onValidateUserInput = _a.onValidateUserInput, rest =
tslib_1.__rest(_a, ["label", "increments", "showSeconds", "allowFreeform",
"useHour12", "timeRange", "strings", "defaultValue", "onChange", "onFormatDate",
"onValidateUserInput"]);
var _g = React.useState(''), userText = _g[0], setUserText = _g[1];
var _h = React.useState(''), errorMessage = _h[0], setErrorMessage = _h[1];
var optionsCount = getDropdownOptionsCount(increments, timeRange);
var initialValue = react_hooks_1.useConst(defaultValue || new Date());
var baseDate = React.useMemo(function () { return generateBaseDate(increments,
timeRange, initialValue); }, [
increments,
timeRange,
initialValue,
]);
var timePickerOptions = React.useMemo(function () {
var optionsList = Array(optionsCount);
for (var i = 0; i < optionsCount; i++) {
optionsList[i] = 0;
}
return optionsList.map(function (_, index) {
var option = date_time_utilities_1.addMinutes(baseDate, increments *
index);
option.setSeconds(0);
var optionText = onFormatDate ? onFormatDate(option) :
date_time_utilities_1.formatTimeString(option, showSeconds, useHour12);
return {
key: optionText,
text: optionText,
};
});
}, [baseDate, increments, optionsCount, showSeconds, onFormatDate, useHour12]);
var _j = React.useState(timePickerOptions[0].key), selectedKey = _j[0],
setSelectedKey = _j[1];
var onInputChange = React.useCallback(function (event, option, index, value) {
var validateUserInput = function (userInput) {
var errorMessageToDisplay = '';
var regex;
if (useHour12) {
regex = showSeconds ? REGEX_SHOW_SECONDS_HOUR_12 :
REGEX_HIDE_SECONDS_HOUR_12;
}
else {
regex = showSeconds ? REGEX_SHOW_SECONDS_HOUR_24 :
REGEX_HIDE_SECONDS_HOUR_24;
}
if (!regex.test(userInput)) {
errorMessageToDisplay = strings.invalidInputErrorMessage;
}
return errorMessageToDisplay;
};
var key = option === null || option === void 0 ? void 0 : option.key;
var updatedUserText = '';
var errorMessageToDisplay = '';
if (value) {
if (allowFreeform && !option) {
if (!onFormatDate) {
// Validate only if user did not add onFormatDate
errorMessageToDisplay = validateUserInput(value);
}
else {
// Use user provided validation if onFormatDate is provided
if (onValidateUserInput) {
errorMessageToDisplay = onValidateUserInput(value);
}
}
}
updatedUserText = value;
}
else if (option) {
updatedUserText = option.text;
}
if (onChange && !errorMessageToDisplay) {
var selectedTime = value || (option === null || option === void 0 ?
void 0 : option.text) || '';
var date = date_time_utilities_1.getDateFromTimeSelection(useHour12,
baseDate, selectedTime);
onChange(event, date);
}
setErrorMessage(errorMessageToDisplay);
setUserText(updatedUserText);
setSelectedKey(key);
}, [
baseDate,
allowFreeform,
onChange,
onFormatDate,
onValidateUserInput,
showSeconds,
useHour12,
strings.invalidInputErrorMessage,
]);
var evaluatePressedKey = function (event) {
var charCode = event.charCode;
if (!onFormatDate &&
// Only permit input of digits, space, colon, A/P/M characters
!((charCode >= Utilities_1.KeyCodes.zero && charCode <=
Utilities_1.KeyCodes.colon) ||
charCode === Utilities_1.KeyCodes.space ||
charCode === Utilities_1.KeyCodes.a ||
charCode === Utilities_1.KeyCodes.m ||
charCode === Utilities_1.KeyCodes.p)) {
}
};
return (React.createElement(ComboBox_1.ComboBox, tslib_1.__assign({}, rest,
{ allowFreeform: allowFreeform, selectedKey: selectedKey, label: label,
errorMessage: errorMessage, options: timePickerOptions, onChange: onInputChange,
text: userText,
//eslint-disable-next-line
onKeyPress: evaluatePressedKey })));
};
exports.TimePicker = TimePicker;
exports.TimePicker.displayName = 'TimePicker';
var clampTimeRange = function (timeRange) {
return {
start: Math.min(Math.max(timeRange.start, TIME_LOWER_BOUND),
TIME_UPPER_BOUND),
end: Math.min(Math.max(timeRange.end, TIME_LOWER_BOUND), TIME_UPPER_BOUND),
};
};
var generateBaseDate = function (increments, timeRange, baseDate) {
if (timeRange) {
var clampedTimeRange = clampTimeRange(timeRange);
baseDate.setHours(clampedTimeRange.start);
}
return date_time_utilities_1.ceilMinuteToIncrement(baseDate, increments);
};
var getDropdownOptionsCount = function (increments, timeRange) {
var hoursInRange = date_time_utilities_1.TimeConstants.HoursInOneDay;
if (timeRange) {
var clampedTimeRange = clampTimeRange(timeRange);
if (clampedTimeRange.start > clampedTimeRange.end) {
hoursInRange = date_time_utilities_1.TimeConstants.HoursInOneDay -
timeRange.start - timeRange.end;
}
else if (timeRange.end > timeRange.start) {
hoursInRange = timeRange.end - timeRange.start;
}
}
return Math.floor((date_time_utilities_1.TimeConstants.MinutesInOneHour *
hoursInRange) / increments);
};
//# sourceMappingURL=TimePicker.js.map
/***/ }),
/***/ 75883:
"use strict";

//# sourceMappingURL=TimePicker.types.js.map
/***/ }),
/***/ 11555:
"use strict";
/***/ }),
/***/ 34700:
"use strict";

exports.ToggleBase = void 0;
var COMPONENT_NAME = 'Toggle';
exports.ToggleBase = React.forwardRef(function (props, forwardedRef) {
var _a = props.as, RootType = _a === void 0 ? 'div' : _a, ariaLabel =
props.ariaLabel, controlledChecked = props.checked, className = props.className, _b
= props.defaultChecked, defaultChecked = _b === void 0 ? false : _b, disabled =
props.disabled, inlineLabel = props.inlineLabel, label = props.label,
offAriaLabel = props.offAriaLabel, offText = props.offText,
onAriaLabel = props.onAriaLabel, onChange = props.onChange,
onChanged = props.onChanged, onToggleClick = props.onClick, onText =
props.onText, role = props.role, styles = props.styles, theme = props.theme;
var _c = react_hooks_1.useControllableValue(controlledChecked, defaultChecked,
React.useCallback(function (ev, isChecked) {
onChange === null || onChange === void 0 ? void 0 : onChange(ev,
isChecked);
onChanged === null || onChanged === void 0 ? void 0 : onChanged(isChecked);
}, [onChange, onChanged])), checked = _c[0], setChecked = _c[1];
theme: theme,
disabled: disabled,
checked: checked,
inlineLabel: inlineLabel,
onOffMissing: !onText && !offText,
});
var badAriaLabel = checked ? onAriaLabel : offAriaLabel;
var id = react_hooks_1.useId(COMPONENT_NAME, props.id);
var labelId = id + "-label";
var stateTextId = id + "-stateText";
var stateText = checked ? onText : offText;
var toggleNativeProps = utilities_1.getNativeProps(props,
utilities_1.inputProperties, [
'defaultChecked',
]);
// The following properties take priority for what Narrator should read:
// 1. ariaLabel
// 2. onAriaLabel (if checked) or offAriaLabel (if not checked)
// 3. label, if existent
var labelledById = undefined;
if (!ariaLabel && !badAriaLabel) {
if (label) {
labelledById = labelId;
}
if (stateText && !labelledById) {
labelledById = stateTextId;
}
}
var toggleButton = React.useRef(null);
utilities_1.useFocusRects(toggleButton);
useComponentRef(props, checked, toggleButton);
if (false) {}
var onClick = function (ev) {
if (!disabled) {
setChecked(!checked, ev);
if (onToggleClick) {
onToggleClick(ev);
}
}
};
var slotProps = {
root: {
hidden: toggleNativeProps.hidden,
},
label: {
children: label,
className: classNames.label,
htmlFor: id,
id: labelId,
},
container: {
className: classNames.container,
},
pill: tslib_1.__assign(tslib_1.__assign({}, toggleNativeProps), { 'aria-
disabled': disabled, 'aria-checked': checked, 'aria-label': ariaLabel ? ariaLabel :
badAriaLabel, 'aria-labelledby': labelledById, className: classNames.pill, 'data-
is-focusable': true, 'data-ktp-target': true, disabled: disabled, id: id, onClick:
onClick, ref: toggleButton, role: role ? role : 'switch', type: 'button' }),
thumb: {
className: classNames.thumb,
},
stateText: {
children: stateText,
className: classNames.text,
htmlFor: id,
id: stateTextId,
},
};
return (React.createElement(RootType, tslib_1.__assign({ ref: forwardedRef },
slotProps.root),
label && React.createElement(Label_1.Label, tslib_1.__assign({},
slotProps.label)),
React.createElement("div", tslib_1.__assign({}, slotProps.container),
React.createElement("button", tslib_1.__assign({}, slotProps.pill),
slotProps.thumb))),
((checked && onText) || offText) && React.createElement(Label_1.Label,
tslib_1.__assign({}, slotProps.stateText)))));
});
exports.ToggleBase.displayName = COMPONENT_NAME + 'Base';
var useComponentRef = function (props, isChecked, toggleButtonRef) {
get checked() {
return !!isChecked;
},
if (toggleButtonRef.current) {
toggleButtonRef.current.focus();
}
},
}); }, [isChecked, toggleButtonRef]);
};
//# sourceMappingURL=Toggle.base.js.map
/***/ }),
/***/ 96029:
"use strict";

exports.Toggle = void 0;
var Toggle_base_1 = __webpack_require__(34700);
var Toggle_styles_1 = __webpack_require__(3623);
exports.Toggle = utilities_1.styled(Toggle_base_1.ToggleBase,
Toggle_styles_1.getStyles, undefined, {
scope: 'Toggle',
});
//# sourceMappingURL=Toggle.js.map
/***/ }),
/***/ 3623:
"use strict";

var DEFAULT_PILL_WIDTH = 40;
var DEFAULT_PILL_HEIGHT = 20;
var DEFAULT_THUMB_SIZE = 12;
var _a, _b, _c, _d, _e, _f, _g;
props.disabled, checked = props.checked, inlineLabel = props.inlineLabel,
onOffMissing = props.onOffMissing;
// Tokens
var pillUncheckedBackground = semanticColors.bodyBackground;
var pillCheckedBackground = semanticColors.inputBackgroundChecked;
var pillCheckedHoveredBackground =
var thumbUncheckedHoveredBackground = palette.neutralDark;
var pillCheckedDisabledBackground = semanticColors.disabledBodySubtext;
var thumbBackground = semanticColors.smallInputBorder;
var thumbCheckedBackground = semanticColors.inputForegroundChecked;
var thumbDisabledBackground = semanticColors.disabledBodySubtext;
var thumbCheckedDisabledBackground = semanticColors.disabledBackground;
var pillBorderColor = semanticColors.smallInputBorder;
var pillBorderHoveredColor = semanticColors.inputBorderHovered;
var pillBorderDisabledColor = semanticColors.disabledBodySubtext;
var textDisabledColor = semanticColors.disabledText;
return {
root: [
'ms-Toggle',
checked && 'is-checked',
!disabled && 'is-enabled',
theme.fonts.medium,
{
},
inlineLabel && {
display: 'flex',
},
className,
],
label: [
'ms-Toggle-label',
{ display: 'inline-block' },
disabled && {
color: textDisabledColor,
color: 'GrayText',
},
_a),
},
inlineLabel &&
!onOffMissing && {
marginRight: 16,
},
onOffMissing &&
inlineLabel && {
order: 1,
marginLeft: 16,
},
inlineLabel && { wordBreak: 'break-word' },
],
container: [
'ms-Toggle-innerContainer',
{
display: 'flex',
},
],
pill: [
'ms-Toggle-background',
{
fontSize: '20px',
width: DEFAULT_PILL_WIDTH,
height: DEFAULT_PILL_HEIGHT,
borderRadius: DEFAULT_PILL_HEIGHT / 2,
transition: 'all 0.1s ease',
border: "1px solid " + pillBorderColor,
background: pillUncheckedBackground,
cursor: 'pointer',
display: 'flex',
padding: '0 3px',
},
!disabled && [
!checked && {
selectors: {
':hover': [
{
borderColor: pillBorderHoveredColor,
},
],
':hover .ms-Toggle-thumb': [
{
backgroundColor: thumbUncheckedHoveredBackground,
},
_b),
},
],
},
},
checked && [
{
background: pillCheckedBackground,
},
{
selectors: (_c = {
':hover': [
{
backgroundColor:
pillCheckedHoveredBackground,
},
_d),
},
]
},
_c[style_utilities_1.HighContrastSelector] =
tslib_1.__assign({ backgroundColor: 'Highlight' },
_c),
},
],
],
disabled && [
{
cursor: 'default',
},
!checked && [
{
borderColor: pillBorderDisabledColor,
},
],
checked && [
{
backgroundColor: pillCheckedDisabledBackground,
},
],
],
!disabled && {
selectors: {
'&:hover': {
},
_e),
},
},
},
],
thumb: [
'ms-Toggle-thumb',
{
display: 'block',
width: DEFAULT_THUMB_SIZE,
height: DEFAULT_THUMB_SIZE,
transition: 'all 0.1s ease',
backgroundColor: thumbBackground,
/* Border is added to handle high contrast mode for Firefox */
borderWidth: DEFAULT_THUMB_SIZE / 2,
},
!disabled &&
checked && [
{
backgroundColor: thumbCheckedBackground,
},
_f),
},
],
disabled && [
!checked && [
{
backgroundColor: thumbDisabledBackground,
},
],
checked && [
{
backgroundColor: thumbCheckedDisabledBackground,
},
],
],
],
text: [
'ms-Toggle-stateText',
{
selectors: {
// Workaround: make rules more specific than Label rules.
'&&': {
padding: '0',
margin: '0 8px',
userSelect: 'none',
},
},
},
disabled && {
selectors: {
'&&': {
color: textDisabledColor,
color: 'GrayText',
},
_g),
},
},
},
],
};
};
//# sourceMappingURL=Toggle.styles.js.map
/***/ }),
/***/ 86042:
"use strict";

//# sourceMappingURL=Toggle.types.js.map
/***/ }),
/***/ 7941:
"use strict";

/***/ }),
/***/ 40150:
"use strict";

exports.TooltipBase = void 0;
var TooltipBase = /** @class */ (function (_super) {
tslib_1.__extends(TooltipBase, _super);
function TooltipBase() {
_this._onRenderContent = function (props) {
if (typeof props.content === 'string') {
return React.createElement("p", { className:
_this._classNames.subText }, props.content);
}
else {
_this._classNames.subText }, props.content);
}
};
return _this;
}
TooltipBase.prototype.render = function () {
var _a = this.props, className = _a.className, calloutProps =
_a.calloutProps, directionalHint = _a.directionalHint, directionalHintForRTL =
_a.directionalHintForRTL, styles = _a.styles, id = _a.id, maxWidth = _a.maxWidth,
_b = _a.onRenderContent, onRenderContent = _b === void 0 ? this._onRenderContent :
_b, targetElement = _a.targetElement, theme = _a.theme;
theme: theme,
className: className || (calloutProps && calloutProps.className),
beakWidth: calloutProps && calloutProps.beakWidth,
gapSpace: calloutProps && calloutProps.gapSpace,
maxWidth: maxWidth,
});
return (React.createElement(Callout_1.Callout, tslib_1.__assign({ target:
targetElement, directionalHint: directionalHint, directionalHintForRTL:
directionalHintForRTL }, calloutProps, Utilities_1.getNativeProps(this.props,
Utilities_1.divProperties, ['id']), { className: this._classNames.root }),
React.createElement("div", { className: this._classNames.content, id:
id, onMouseEnter: this.props.onMouseEnter, onMouseLeave: this.props.onMouseLeave },
onRenderContent(this.props, this._onRenderContent))));
};
// Specify default props values
TooltipBase.defaultProps = {
directionalHint: DirectionalHint_1.DirectionalHint.topCenter,
maxWidth: '364px',
calloutProps: {
isBeakVisible: true,
beakWidth: 16,
gapSpace: 0,
setInitialFocus: true,
doNotLayer: false,
},
};
return TooltipBase;
exports.TooltipBase = TooltipBase;
//# sourceMappingURL=Tooltip.base.js.map
/***/ }),
/***/ 51966:
"use strict";

exports.Tooltip = void 0;
var Tooltip_base_1 = __webpack_require__(40150);
var Tooltip_styles_1 = __webpack_require__(99017);
exports.Tooltip = Utilities_1.styled(Tooltip_base_1.TooltipBase,
Tooltip_styles_1.getStyles, undefined, {
scope: 'Tooltip',
});
//# sourceMappingURL=Tooltip.js.map
/***/ }),
/***/ 99017:
"use strict";

var className = props.className, _a = props.beakWidth, beakWidth = _a === void
0 ? 16 : _a, _b = props.gapSpace, gapSpace = _b === void 0 ? 0 : _b, maxWidth =
props.maxWidth, theme = props.theme;
var semanticColors = theme.semanticColors, fonts = theme.fonts, effects =
theme.effects;
// The math here is done to account for the 45 degree rotation of the beak
// and sub-pixel rounding that differs across browsers, which is more
noticeable when
// the device pixel ratio is larger
var tooltipGapSpace = -(Math.sqrt((beakWidth * beakWidth) / 2) + gapSpace) +
1 / window.devicePixelRatio;
return {
root: [
'ms-Tooltip',
theme.fonts.medium,
{
background: semanticColors.menuBackground,
padding: '8px',
maxWidth: maxWidth,
selectors: {
':after': {
content: "''",
bottom: tooltipGapSpace,
left: tooltipGapSpace,
right: tooltipGapSpace,
top: tooltipGapSpace,
zIndex: 0,
},
},
},
className,
],
content: [
'ms-Tooltip-content',
fonts.small,
{
zIndex: 1,
overflow: 'hidden',
},
],
subText: [
'ms-Tooltip-subtext',
{
// Using inherit here to avoid unintentional global overrides of
the <p> tag.
color: 'inherit',
margin: 0,
},
],
};
};
//# sourceMappingURL=Tooltip.styles.js.map
/***/ }),
/***/ 5255:
"use strict";

exports.TooltipDelay = void 0;
/**
* {@docCategory Tooltip}
*/
var TooltipDelay;
(function (TooltipDelay) {
TooltipDelay[TooltipDelay["zero"] = 0] = "zero";
/** 300 ms delay before showing the tooltip */
TooltipDelay[TooltipDelay["medium"] = 1] = "medium";
/** 500 ms delay before showing the tooltip */
TooltipDelay[TooltipDelay["long"] = 2] = "long";
})(TooltipDelay = exports.TooltipDelay || (exports.TooltipDelay = {}));
//# sourceMappingURL=Tooltip.types.js.map
/***/ }),
/***/ 94075:
"use strict";

exports.TooltipHostBase = void 0;
var TooltipHost_types_1 = __webpack_require__(14308);
var Tooltip_types_1 = __webpack_require__(5255);
var TooltipHostBase = /** @class */ (function (_super) {
tslib_1.__extends(TooltipHostBase, _super);
// Constructor
function TooltipHostBase(props) {
// The wrapping div that gets the hover events
_this._tooltipHost = React.createRef();
_this._defaultTooltipId = Utilities_1.getId('tooltip');
_this.show = function () {
_this._toggleTooltip(true);
};
_this.dismiss = function () {
_this._hideTooltip();
};
_this._getTargetElement = function () {
if (!_this._tooltipHost.current) {
return undefined;
}
var overflowMode = _this.props.overflowMode;
// Select target element based on overflow mode. For parent mode, you
want to position the tooltip relative
// to the parent element, otherwise it might look off.
if (overflowMode !== undefined) {
switch (overflowMode) {
case TooltipHost_types_1.TooltipOverflowMode.Parent:
return _this._tooltipHost.current.parentElement;
case TooltipHost_types_1.TooltipOverflowMode.Self:
return _this._tooltipHost.current;
}
}
return _this._tooltipHost.current;
};
_this._onTooltipFocus = function (ev) {
if (_this._ignoreNextFocusEvent) {
_this._ignoreNextFocusEvent = false;
return;
}
_this._onTooltipMouseEnter(ev);
};
_this._onTooltipBlur = function (ev) {
// The focused element gets a blur event when the document loses focus
// (e.g. switching tabs in the browser), but we don't want to show the
// tooltip again when the document gets focus back. Handle this case by
// checking if the blurred element is still the document's
activeElement,
// and ignoring when it next gets focus back.
// See https://github.com/microsoft/fluentui/issues/13541
_this._ignoreNextFocusEvent = (document === null || document === void 0
? void 0 : document.activeElement) === ev.target;
};
// Show Tooltip
_this._onTooltipMouseEnter = function (ev) {
var _a = _this.props, overflowMode = _a.overflowMode, delay = _a.delay;
if (TooltipHostBase._currentVisibleTooltip &&
TooltipHostBase._currentVisibleTooltip !== _this) {
TooltipHostBase._currentVisibleTooltip.dismiss();
}
TooltipHostBase._currentVisibleTooltip = _this;
if (overflowMode !== undefined) {
var overflowElement = _this._getTargetElement();
if (overflowElement && !Utilities_1.hasOverflow(overflowElement)) {
return;
}
}
if (ev.target && Utilities_1.portalContainsElement(ev.target,
_this._getTargetElement())) {
// Do not show tooltip when target is inside a portal relative to
TooltipHost.
return;
}
_this._clearDismissTimer();
_this._clearOpenTimer();
if (delay !== Tooltip_types_1.TooltipDelay.zero) {
var delayTime = _this._getDelayTime(delay); // non-null assertion
because we set it in `defaultProps`
_this._openTimerId = _this._async.setTimeout(function () {
}, delayTime);
}
else {
}
};
// Hide Tooltip
_this._onTooltipMouseLeave = function (ev) {
var closeDelay = _this.props.closeDelay;
if (closeDelay) {
_this._dismissTimerId = _this._async.setTimeout(function () {
_this._toggleTooltip(false);
}, closeDelay);
}
else {
}
if (TooltipHostBase._currentVisibleTooltip === _this) {
TooltipHostBase._currentVisibleTooltip = undefined;
}
};
_this._onTooltipKeyDown = function (ev) {
if ((ev.which === Utilities_1.KeyCodes.escape || ev.ctrlKey) &&
_this.state.isTooltipVisible) {
}
};
_this._clearDismissTimer = function () {
};
_this._clearOpenTimer = function () {
};
// Hide Tooltip
_this._hideTooltip = function () {
};
_this._toggleTooltip = function (isTooltipVisible) {
if (_this.state.isTooltipVisible !== isTooltipVisible) {
_this.setState({ isTooltipVisible: isTooltipVisible }, function ()
{ return _this.props.onTooltipToggle &&
_this.props.onTooltipToggle(isTooltipVisible); });
}
};
_this._getDelayTime = function (delay) {
switch (delay) {
case Tooltip_types_1.TooltipDelay.medium:
return 300;
case Tooltip_types_1.TooltipDelay.long:
return 500;
default:
return 0;
}
};
_this.state = {
isAriaPlaceholderRendered: false,
isTooltipVisible: false,
};
return _this;
}
// Render
TooltipHostBase.prototype.render = function () {
var _a = this.props, calloutProps = _a.calloutProps, children =
_a.children, content = _a.content, directionalHint = _a.directionalHint,
directionalHintForRTL = _a.directionalHintForRTL, className = _a.hostClassName, id
= _a.id,
_b = _a.setAriaDescribedBy,
setAriaDescribedBy = _b === void 0 ? true : _b, tooltipProps =
_a.tooltipProps, styles = _a.styles, theme = _a.theme;
theme: theme,
});
var isTooltipVisible = this.state.isTooltipVisible;
var tooltipId = id || this._defaultTooltipId;
var isContentPresent = !!(content ||
(tooltipProps && tooltipProps.onRenderContent &&
tooltipProps.onRenderContent()));
var showTooltip = isTooltipVisible && isContentPresent;
var ariaDescribedBy = setAriaDescribedBy && isTooltipVisible &&
isContentPresent ? tooltipId : undefined;
this._classNames.root, ref: this._tooltipHost }, { onFocusCapture:
this._onTooltipFocus }, { onBlurCapture: this._onTooltipBlur }, { onMouseEnter:
this._onTooltipMouseEnter, onMouseLeave: this._onTooltipMouseLeave, onKeyDown:
this._onTooltipKeyDown, role: "none", "aria-describedby": ariaDescribedBy }),
children,
showTooltip && (React.createElement(Tooltip_1.Tooltip,
tslib_1.__assign({ id: tooltipId + "--tooltip", content: content, targetElement:
this._getTargetElement(), directionalHint: directionalHint, directionalHintForRTL:
directionalHintForRTL, calloutProps: Utilities_1.assign({}, calloutProps, {
onDismiss: this._hideTooltip,
onMouseEnter: this._onTooltipMouseEnter,
onMouseLeave: this._onTooltipMouseLeave,
}), onMouseEnter: this._onTooltipMouseEnter, onMouseLeave:
this._onTooltipMouseLeave }, Utilities_1.getNativeProps(this.props,
Utilities_1.divProperties, ['id']), tooltipProps))),
React.createElement("div", { hidden: true, id: tooltipId, style:
Styling_1.hiddenContentStyle }, content)));
};
TooltipHostBase.prototype.componentWillUnmount = function () {
if (TooltipHostBase._currentVisibleTooltip &&
TooltipHostBase._currentVisibleTooltip === this) {
TooltipHostBase._currentVisibleTooltip = undefined;
}
};
TooltipHostBase.defaultProps = {
delay: Tooltip_types_1.TooltipDelay.medium,
};
return TooltipHostBase;
exports.TooltipHostBase = TooltipHostBase;
//# sourceMappingURL=TooltipHost.base.js.map
/***/ }),
/***/ 71902:
"use strict";

exports.TooltipHost = void 0;
var TooltipHost_base_1 = __webpack_require__(94075);
var TooltipHost_styles_1 = __webpack_require__(32110);
exports.TooltipHost = Utilities_1.styled(TooltipHost_base_1.TooltipHostBase,
TooltipHost_styles_1.getStyles, undefined, {
scope: 'TooltipHost',
});
//# sourceMappingURL=TooltipHost.js.map
/***/ }),
/***/ 32110:
"use strict";

root: 'ms-TooltipHost',
ariaPlaceholder: 'ms-TooltipHost-aria-placeholder',
};
return {
root: [
classNames.root,
{
display: 'inline',
},
className,
],
};
};
//# sourceMappingURL=TooltipHost.styles.js.map
/***/ }),
/***/ 14308:
"use strict";
exports.TooltipOverflowMode = void 0;
/**
* {@docCategory Tooltip}
*/
var TooltipOverflowMode;
(function (TooltipOverflowMode) {
/** Only show tooltip if parent DOM element is overflowing */
TooltipOverflowMode[TooltipOverflowMode["Parent"] = 0] = "Parent";
/**
* Only show tooltip if tooltip host's content is overflowing.
* Note that this does not check the children for overflow, only the
TooltipHost root.
*/
TooltipOverflowMode[TooltipOverflowMode["Self"] = 1] = "Self";
})(TooltipOverflowMode = exports.TooltipOverflowMode ||
(exports.TooltipOverflowMode = {}));
//# sourceMappingURL=TooltipHost.types.js.map
/***/ }),
/***/ 3508:
"use strict";

/***/ }),
/***/ 50854:
"use strict";

exports.WeeklyDayPickerBase = void 0;
var CalendarDayGrid_1 = __webpack_require__(80153);
var WeeklyDayPickerBase = /** @class */ (function (_super) {
tslib_1.__extends(WeeklyDayPickerBase, _super);
function WeeklyDayPickerBase(props) {
_this._dayGrid = React.createRef();
_this._onSelectDate = function (date) {
var onSelectDate = _this.props.onSelectDate;
// don't set the navigated date on selection because selection never
causes navigation
_this.setState({
selectedDate: date,
});
_this._focusOnUpdate = true;
if (onSelectDate) {
onSelectDate(date);
}
};
_this._onNavigateDate = function (date, focusOnNavigatedDay) {
var onNavigateDate = _this.props.onNavigateDate;
_this.setState({
navigatedDate: date,
});
_this._focusOnUpdate = focusOnNavigatedDay;
if (onNavigateDate) {
onNavigateDate(date);
}
};
_this._renderPreviousWeekNavigationButton = function (classNames) {
var _a;
var _b = _this.props, minDate = _b.minDate, firstDayOfWeek =
_b.firstDayOfWeek, navigationIcons = _b.navigationIcons;
var navigatedDate = _this.state.navigatedDate;
var leftNavigationIcon = utilities_1.getRTL() ?
navigationIcons.rightNavigation : navigationIcons.leftNavigation;
// determine if previous week in bounds
var prevWeekInBounds = minDate
? date_time_utilities_1.compareDatePart(minDate,
date_time_utilities_1.getStartDateOfWeek(navigatedDate, firstDayOfWeek)) < 0
: true;
utilities_1.css(classNames.navigationIconButton, (_a = {},
_a[classNames.disabledStyle] = !prevWeekInBounds,
_a)), disabled: !prevWeekInBounds, "aria-disabled": !
prevWeekInBounds, onClick: prevWeekInBounds ? _this._onSelectPrevDateRange :
undefined, onKeyDown: prevWeekInBounds ?
_this._onButtonKeyDown(_this._onSelectPrevDateRange) : undefined, title:
_this._createPreviousWeekAriaLabel(), type: "button" },
leftNavigationIcon })));
};
_this._renderNextWeekNavigationButton = function (classNames) {
var _a;
var _b = _this.props, maxDate = _b.maxDate, firstDayOfWeek =
_b.firstDayOfWeek, navigationIcons = _b.navigationIcons;
var rightNavigationIcon = utilities_1.getRTL() ?
navigationIcons.leftNavigation : navigationIcons.rightNavigation;
// determine if next week in bounds
var nextWeekInBounds = maxDate
?
date_time_utilities_1.compareDatePart(date_time_utilities_1.addDays(date_time_utili
ties_1.getStartDateOfWeek(navigatedDate, firstDayOfWeek), 7), maxDate) < 0
: true;
utilities_1.css(classNames.navigationIconButton, (_a = {},
_a[classNames.disabledStyle] = !nextWeekInBounds,
_a)), disabled: !nextWeekInBounds, "aria-disabled": !
nextWeekInBounds, onClick: nextWeekInBounds ? _this._onSelectNextDateRange :
undefined, onKeyDown: nextWeekInBounds ?
_this._onButtonKeyDown(_this._onSelectNextDateRange) : undefined, title:
_this._createNextWeekAriaLabel(), type: "button" },
rightNavigationIcon })));
};
_this._onSelectPrevDateRange = function () {
if (_this.props.showFullMonth) {
_this._navigateDate(date_time_utilities_1.addMonths(_this.state.navigatedDate, -
1));
}
else {
_this._navigateDate(date_time_utilities_1.addDays(_this.state.navigatedDate, -7));
}
};
_this._onSelectNextDateRange = function () {
if (_this.props.showFullMonth) {
_this._navigateDate(date_time_utilities_1.addMonths(_this.state.navigatedDate, 1));
}
else {
_this._navigateDate(date_time_utilities_1.addDays(_this.state.navigatedDate, 7));
}
};
_this._navigateDate = function (date) {
_this.setState({
navigatedDate: date,
});
if (_this.props.onNavigateDate) {
_this.props.onNavigateDate(date);
}
};
_this._onWrapperKeyDown = function (ev) {
switch (ev.which) {
break;
case utilities_1.KeyCodes.backspace:
break;
default:
break;
}
};
_this._onButtonKeyDown = function (callback) {
switch (ev.which) {
callback();
break;
}
};
};
var touch = ev.touches[0];
if (touch) {
_this._initialTouchX = touch.clientX;
}
};
_this._onTouchMove = function (ev) {
var isRtl = utilities_1.getRTL();
var touch = ev.touches[0];
if (touch && _this._initialTouchX !== undefined && touch.clientX !==
_this._initialTouchX) {
if ((touch.clientX - _this._initialTouchX) * (isRtl ? -1 : 1) < 0)
{
// swipe right
_this._onSelectNextDateRange();
}
else {
// swipe left
_this._onSelectPrevDateRange();
}
_this._initialTouchX = undefined;
}
};
_this._createPreviousWeekAriaLabel = function () {
var _a = _this.props, strings = _a.strings, showFullMonth =
_a.showFullMonth, firstDayOfWeek = _a.firstDayOfWeek;
var ariaLabel = undefined;
if (showFullMonth && strings.prevMonthAriaLabel) {
ariaLabel = strings.prevMonthAriaLabel + ' ' +
strings.months[date_time_utilities_1.addMonths(navigatedDate, -1).getMonth()];
}
else if (!showFullMonth && strings.prevWeekAriaLabel) {
var firstDayOfPreviousWeek =
date_time_utilities_1.getStartDateOfWeek(date_time_utilities_1.addDays(navigatedDat
e, -7), firstDayOfWeek);
var lastDayOfPreviousWeek =
date_time_utilities_1.addDays(firstDayOfPreviousWeek, 6);
ariaLabel =
strings.prevWeekAriaLabel + ' ' +
_this._formatDateRange(firstDayOfPreviousWeek, lastDayOfPreviousWeek);
}
return ariaLabel;
};
_this._createNextWeekAriaLabel = function () {
var _a = _this.props, strings = _a.strings, showFullMonth =
_a.showFullMonth, firstDayOfWeek = _a.firstDayOfWeek;
var ariaLabel = undefined;
if (showFullMonth && strings.nextMonthAriaLabel) {
ariaLabel = strings.nextMonthAriaLabel + ' ' +
strings.months[date_time_utilities_1.addMonths(navigatedDate, 1).getMonth()];
}
else if (!showFullMonth && strings.nextWeekAriaLabel) {
var firstDayOfNextWeek =
date_time_utilities_1.getStartDateOfWeek(date_time_utilities_1.addDays(navigatedDat
e, 7), firstDayOfWeek);
var lastDayOfNextWeek =
date_time_utilities_1.addDays(firstDayOfNextWeek, 6);
ariaLabel = strings.nextWeekAriaLabel + ' ' +
_this._formatDateRange(firstDayOfNextWeek, lastDayOfNextWeek);
}
return ariaLabel;
};
_this._formatDateRange = function (startDate, endDate) {
var _a = _this.props, dateTimeFormatter = _a.dateTimeFormatter, strings
= _a.strings;
return (dateTimeFormatter === null || dateTimeFormatter === void 0 ?
void 0 : dateTimeFormatter.formatMonthDayYear(startDate, strings)) + " - " +
(dateTimeFormatter === null || dateTimeFormatter === void 0 ? void 0 :
dateTimeFormatter.formatMonthDayYear(endDate, strings));
};
var currentDate = props.initialDate && !
isNaN(props.initialDate.getTime()) ? props.initialDate : props.today || new Date();
_this.state = {
selectedDate: currentDate,
navigatedDate: currentDate,
previousShowFullMonth: !!props.showFullMonth,
animationDirection: props.animationDirection,
};
_this._focusOnUpdate = false;
return _this;
}
WeeklyDayPickerBase.getDerivedStateFromProps = function (nextProps, prevState)
{
var currentDate = nextProps.initialDate && !
isNaN(nextProps.initialDate.getTime())
? nextProps.initialDate
: nextProps.today || new Date();
var showFullMonth = !!nextProps.showFullMonth;
var newAnimationDirection = showFullMonth !==
prevState.previousShowFullMonth ? Calendar_types_1.AnimationDirection.Vertical :
Calendar_types_1.AnimationDirection.Horizontal;
if (!date_time_utilities_1.compareDates(currentDate,
prevState.selectedDate)) {
return {
navigatedDate: currentDate,
previousShowFullMonth: showFullMonth,
animationDirection: newAnimationDirection,
};
}
return {
navigatedDate: prevState.navigatedDate,
previousShowFullMonth: showFullMonth,
animationDirection: newAnimationDirection,
};
};
WeeklyDayPickerBase.prototype.focus = function () {
if (this._dayGrid && this._dayGrid.current) {
this._dayGrid.current.focus();
}
};
WeeklyDayPickerBase.prototype.render = function () {
var _a = this.props, strings = _a.strings, dateTimeFormatter =
_a.dateTimeFormatter, firstDayOfWeek = _a.firstDayOfWeek, minDate = _a.minDate,
maxDate = _a.maxDate, restrictedDates = _a.restrictedDates, today = _a.today,
styles = _a.styles, theme = _a.theme, className = _a.className, showFullMonth =
_a.showFullMonth, weeksToShow = _a.weeksToShow, calendarDayGridProps =
tslib_1.__rest(_a, ["strings", "dateTimeFormatter", "firstDayOfWeek", "minDate",
"maxDate", "restrictedDates", "today", "styles", "theme", "className",
"showFullMonth", "weeksToShow"]);
theme: theme,
});
return (React.createElement("div", { className: classNames.root, onKeyDown:
this._onWrapperKeyDown, onTouchStart: this._onTouchStart, onTouchMove:
this._onTouchMove, "aria-expanded": showFullMonth },
this._renderPreviousWeekNavigationButton(classNames),
React.createElement(CalendarDayGrid_1.CalendarDayGrid,
tslib_1.__assign({ styles: styles, componentRef: this._dayGrid, strings: strings,
selectedDate: this.state.selectedDate, navigatedDate: this.state.navigatedDate,
firstDayOfWeek: firstDayOfWeek, firstWeekOfYear:
date_time_utilities_1.FirstWeekOfYear.FirstDay, dateRangeType:
date_time_utilities_1.DateRangeType.Day, weeksToShow: showFullMonth ? weeksToShow :
1, dateTimeFormatter: dateTimeFormatter, minDate: minDate, maxDate: maxDate,
restrictedDates: restrictedDates, onSelectDate: this._onSelectDate, onNavigateDate:
this._onNavigateDate, today: today, lightenDaysOutsideNavigatedMonth:
showFullMonth, animationDirection: this.state.animationDirection },
calendarDayGridProps)),
this._renderNextWeekNavigationButton(classNames)));
};
WeeklyDayPickerBase.prototype.componentDidUpdate = function () {
if (this._focusOnUpdate) {
this.focus();
this._focusOnUpdate = false;
}
};
WeeklyDayPickerBase.defaultProps = {
onSelectDate: undefined,
initialDate: undefined,
today: new Date(),
strings: defaults_1.defaultWeeklyDayPickerStrings,
navigationIcons: defaults_1.defaultWeeklyDayPickerNavigationIcons,
animationDirection: Calendar_types_1.AnimationDirection.Horizontal,
};
return WeeklyDayPickerBase;
exports.WeeklyDayPickerBase = WeeklyDayPickerBase;
//# sourceMappingURL=WeeklyDayPicker.base.js.map
/***/ }),
/***/ 97702:
"use strict";

exports.WeeklyDayPicker = void 0;
var WeeklyDayPicker_base_1 = __webpack_require__(50854);
var WeeklyDayPicker_styles_1 = __webpack_require__(20175);
exports.WeeklyDayPicker =
Utilities_1.styled(WeeklyDayPicker_base_1.WeeklyDayPickerBase,
WeeklyDayPicker_styles_1.styles, undefined, { scope: 'WeeklyDayPicker' });
//# sourceMappingURL=WeeklyDayPicker.js.map
/***/ }),
/***/ 20175:
"use strict";

root: 'ms-WeeklyDayPicker-root',
};
var _a;
theme);
return {
root: [
classNames.root,
{
width: 220,
padding: 12,
display: 'flex',
},
className,
],
dayButton: {
},
dayIsToday: {},
dayCell: {
borderRadius: '100%!important',
},
daySelected: {},
navigationIconButton: [
style_utilities_1.getFocusStyle(theme, { inset: 0 }),
{
width: 12,
minWidth: 12,
height: 0,
overflow: 'hidden',
padding: 0,
margin: 0,
border: 'none',
display: 'flex',
_a["." + classNames.root + ":hover &, ." +
utilities_1.IsFocusVisibleClassName + " ." + classNames.root + ":focus &, " +
("." + utilities_1.IsFocusVisibleClassName + " &:focus")] =
{
height: 53,
minHeight: 12,
overflow: 'initial',
},
_a["." + utilities_1.IsFocusVisibleClassName + " ." +
classNames.root + ":focus-within &"] = {
// edge does not recognize focus-within, so separate it out
height: 53,
minHeight: 12,
overflow: 'initial',
},
_a['&:hover'] = {
cursor: 'pointer',
},
_a['&:active'] = {
backgroundColor: palette.neutralTertiary,
},
_a),
},
],
disabledStyle: {
selectors: {
},
},
},
};
};
//# sourceMappingURL=WeeklyDayPicker.styles.js.map
/***/ }),
/***/ 63302:
"use strict";

//# sourceMappingURL=WeeklyDayPicker.types.js.map
/***/ }),
/***/ 56431:
"use strict";

exports.defaultWeeklyDayPickerNavigationIcons =
exports.defaultWeeklyDayPickerStrings = void 0;
exports.defaultWeeklyDayPickerStrings = tslib_1.__assign(tslib_1.__assign({},
date_time_utilities_1.DEFAULT_CALENDAR_STRINGS), { prevWeekAriaLabel: 'Previous
week', nextWeekAriaLabel: 'Next week', prevMonthAriaLabel: 'Go to previous month',
nextMonthAriaLabel: 'Go to next month', prevYearAriaLabel: 'Go to previous year',
nextYearAriaLabel: 'Go to next year', closeButtonAriaLabel: 'Close date picker' });
exports.defaultWeeklyDayPickerNavigationIcons = {
leftNavigation: 'ChevronLeft',
rightNavigation: 'ChevronRight',
};
/***/ }),
/***/ 43858:
"use strict";

/***/ }),
/***/ 46231:
"use strict";

// Deprecated, import directly from the component folder now.
//# sourceMappingURL=BaseAutoFill.js.map
/***/ }),
/***/ 9598:
"use strict";

// Deprecated, import directly from the component folder now.
//# sourceMappingURL=BaseAutoFill.types.js.map
/***/ }),
/***/ 79267:
"use strict";

exports.BasePickerListBelow = exports.BasePicker = void 0;
var Suggestions_1 = __webpack_require__(94369);
var Suggestions_styles_1 = __webpack_require__(13110);
var SuggestionsController_1 = __webpack_require__(22651);
var BasePicker_types_1 = __webpack_require__(73490);
var legacyStyles = stylesImport;
/**
* Should be removed once new picker without inheritance is created
*/
function getStyledSuggestions(suggestionsType) {
return Utilities_1.styled(suggestionsType, Suggestions_styles_1.getStyles,
undefined, {
scope: 'Suggestions',
});
}
/**
* {@docCategory Pickers}
*/
var BasePicker = /** @class */ (function (_super) {
tslib_1.__extends(BasePicker, _super);
function BasePicker(basePickerProps) {
// Refs
_this.input = React.createRef();
_this.suggestionElement = React.createRef();
/**
* @deprecated this is no longer necessary as typescript now supports
generic elements
*/
_this.SuggestionOfProperType = Suggestions_1.Suggestions;
_this._styledSuggestions =
getStyledSuggestions(_this.SuggestionOfProperType);
_this.dismissSuggestions = function (ev) {
var selectItemFunction = function () {
var addItemOnDismiss = true;
if (_this.props.onDismiss) {
addItemOnDismiss = _this.props.onDismiss(ev,
_this.suggestionStore.currentSuggestion ?
_this.suggestionStore.currentSuggestion.item : undefined);
}
if (!ev || (ev && !ev.defaultPrevented)) {
// Select the first suggestion if one is available and
permitted by onDismiss when user leaves.
if (addItemOnDismiss !== false &&
_this.canAddItems() &&
_this.suggestionStore.hasSelectedSuggestion() &&
_this.state.suggestedDisplayValue) {
_this.addItemByIndex(0);
}
}
};
if (_this.currentPromise) {
_this.currentPromise.then(function () { return
selectItemFunction(); });
}
else {
selectItemFunction();
}
_this.setState({ suggestionsVisible: false });
};
_this.refocusSuggestions = function (keyCode) {
_this.resetFocus();
if (_this.suggestionStore.suggestions &&
_this.suggestionStore.suggestions.length > 0) {
if (keyCode === Utilities_1.KeyCodes.up) {
_this.suggestionStore.setSelectedSuggestion(_this.suggestionStore.suggestions.lengt
h - 1);
}
else if (keyCode === Utilities_1.KeyCodes.down) {
_this.suggestionStore.setSelectedSuggestion(0);
}
}
};
_this.onInputChange = function (value) {
_this.updateValue(value);
_this.setState({
moreSuggestionsAvailable: true,
isMostRecentlyUsedVisible: false,
});
};
_this.onSuggestionClick = function (ev, item, index) {
_this.addItemByIndex(index);
};
_this.onSuggestionRemove = function (ev, item, index) {
_this.props.onRemoveSuggestion(item);
}
_this.suggestionStore.removeSuggestion(index);
};
_this.onInputFocus = function (ev) {
_this.selection.setAllSelected(false);
// Only trigger all of the focus if this component isn't already
focused.
// For example when an item is selected or removed from the selected
list it should be treated
// as though the input is still focused.
if (!_this.state.isFocused) {
_this._userTriggeredSuggestions();
if (_this.props.inputProps && _this.props.inputProps.onFocus) {
_this.props.inputProps.onFocus(ev);
}
}
};
_this.onInputBlur = function (ev) {
if (_this.props.inputProps && _this.props.inputProps.onBlur) {
_this.props.inputProps.onBlur(ev);
}
};
_this.onBlur = function (ev) {
if (_this.state.isFocused) {
// Only blur the entire component if an unrelated element gets
focus.
// Otherwise treat it as though it still has focus.
// Do nothing if the blur is coming from something
// inside the comboBox root or the comboBox menu since
// it we are not really bluring from the whole comboBox
var relatedTarget = ev.relatedTarget;
if (ev.relatedTarget === null) {
// In IE11, due to lack of support, event.relatedTarget is
always
// null making every onBlur call to be "outside" of the
ComboBox
// even when it's not. Using document.activeElement is another
way
// for us to be able to get what the relatedTarget without
relying
// on the event
relatedTarget = document.activeElement;
}
if (relatedTarget && !
Utilities_1.elementContains(_this.root.current, relatedTarget)) {
_this.setState({ isFocused: false });
}
}
}
};
/**
* Resets focus to last element in wrapper div if clicking back into Picker
that has hit item limit
*/
_this.onWrapperClick = function (ev) {
if (!_this.canAddItems()) {
_this.resetFocus(_this.state.items.length - 1);
}
};
/**
* Reveals suggestions any time the user clicks on the input element
* without shifting focus.
*/
_this.onClick = function (ev) {
if (_this.props.inputProps !== undefined &&
_this.props.inputProps.onClick !== undefined) {
_this.props.inputProps.onClick(ev);
}
// Only primary (left) clicks show suggestions.
if (ev.button === 0) {
_this._userTriggeredSuggestions();
}
};
_this.onFocus = function () {
if (!_this.state.isFocused) {
_this.setState({ isFocused: true });
}
};
_this.onKeyDown = function (ev) {
var keyCode = ev.which;
switch (keyCode) {
if (_this.state.suggestionsVisible) {
}
break;
if (_this.suggestionElement.current &&
_this.suggestionElement.current.hasSuggestedActionSelected()) {
_this.suggestionElement.current.executeSelectedAction();
}
else if (!ev.shiftKey &&
_this.suggestionStore.hasSelectedSuggestion() && _this.state.suggestionsVisible) {
_this.completeSuggestion();
}
else {
_this._completeGenericSuggestion();
}
break;
case Utilities_1.KeyCodes.backspace:
_this.onBackspace(ev);
}
break;
case Utilities_1.KeyCodes.del:
if (_this.input.current &&
ev.target === _this.input.current.inputElement &&
_this.state.suggestionsVisible &&
_this.suggestionStore.currentIndex !== -1) {
_this.props.onRemoveSuggestion(_this.suggestionStore.currentSuggestion.item);
}
_this.suggestionStore.removeSuggestion(_this.suggestionStore.currentIndex);
}
else {
_this.onBackspace(ev);
}
}
break;
if (_this.input.current && ev.target ===
_this.input.current.inputElement && _this.state.suggestionsVisible) {
_this.suggestionElement.current.tryHandleKeyDown(keyCode,
_this.suggestionStore.currentIndex)) {
}
else {
_this.suggestionElement.current.hasSuggestedAction() &&
_this.suggestionStore.currentIndex === 0) {
_this.suggestionElement.current.focusAboveSuggestions();
_this.suggestionStore.deselectAllSuggestions();
}
else {
if (_this.suggestionStore.previousSuggestion()) {
_this.onSuggestionSelect();
}
}
}
}
break;
if (_this.input.current && ev.target ===
_this.input.current.inputElement && _this.state.suggestionsVisible) {
_this.suggestionElement.current.tryHandleKeyDown(keyCode,
_this.suggestionStore.currentIndex)) {
}
else {
_this.suggestionElement.current.hasSuggestedAction() &&
_this.suggestionStore.currentIndex + 1 ===
_this.suggestionStore.suggestions.length) {
_this.suggestionElement.current.focusBelowSuggestions();
_this.suggestionStore.deselectAllSuggestions();
}
else {
if (_this.suggestionStore.nextSuggestion()) {
_this.onSuggestionSelect();
}
}
}
}
break;
}
};
_this.onItemChange = function (changedItem, index) {
if (index >= 0) {
var newItems = items;
newItems[index] = changedItem;
_this._updateSelectedItems(newItems);
}
};
_this.onGetMoreResults = function () {
_this.setState({
isSearching: true,
}, function () {
if (_this.props.onGetMoreResults && _this.input.current) {
var suggestions =
_this.props.onGetMoreResults(_this.input.current.value, _this.state.items);
var suggestionsArray = suggestions;
var suggestionsPromiseLike = suggestions;
if (Array.isArray(suggestionsArray)) {
_this.updateSuggestions(suggestionsArray);
_this.setState({ isSearching: false });
}
else if (suggestionsPromiseLike.then) {
suggestionsPromiseLike.then(function (newSuggestions) {
_this.updateSuggestions(newSuggestions);
});
}
}
else {
}
if (_this.input.current) {
_this.input.current.focus();
}
_this.setState({
moreSuggestionsAvailable: false,
isResultsFooterVisible: true,
});
});
};
_this.completeSelection = function (item) {
_this.addItem(item);
_this.updateValue('');
if (_this.input.current) {
_this.input.current.clear();
}
};
_this.addItemByIndex = function (index) {
_this.completeSelection(_this.suggestionStore.getSuggestionAtIndex(index).item);
};
_this.addItem = function (item) {
var processedItem = _this.props.onItemSelected
? _this.props.onItemSelected(item)
: item;
if (processedItem === null) {
return;
}
var processedItemObject = processedItem;
var processedItemPromiseLike = processedItem;
if (processedItemPromiseLike && processedItemPromiseLike.then) {
processedItemPromiseLike.then(function (resolvedProcessedItem) {
var newItems =
_this.state.items.concat([resolvedProcessedItem]);
});
}
else {
var newItems = _this.state.items.concat([processedItemObject]);
}
_this.setState({ suggestedDisplayValue: '', selectionRemoved: undefined
});
};
_this.removeItem = function (item) {
var index = items.indexOf(item);
if (index >= 0) {
var newItems = items.slice(0, index).concat(items.slice(index +
1));
_this.setState({ selectionRemoved: item });
}
};
_this.removeItems = function (itemsToRemove) {
var newItems = items.filter(function (item) { return
itemsToRemove.indexOf(item) === -1; });
};
/**
* @deprecated this is no longer necessary as focuszone has been removed
*/
_this._shouldFocusZoneEnterInnerZone = function (ev) {
// If suggestions are shown const up/down keys control them, otherwise
allow them through to control the focusZone.
if (_this.state.suggestionsVisible) {
switch (ev.which) {
return true;
}
}
return true;
}
return false;
};
_this._onResolveSuggestions = function (updatedValue) {
var suggestions = _this.props.onResolveSuggestions(updatedValue,
_this.state.items);
if (suggestions !== null) {
_this.updateSuggestionsList(suggestions, updatedValue);
}
};
_this._completeGenericSuggestion = function () {
if (_this.props.onValidateInput &&
_this.input.current &&
_this.props.onValidateInput(_this.input.current.value) !==
BasePicker_types_1.ValidationState.invalid &&
_this.props.createGenericItem) {
var itemToConvert =
_this.props.createGenericItem(_this.input.current.value,
_this.props.onValidateInput(_this.input.current.value));
_this.suggestionStore.createGenericSuggestion(itemToConvert);
_this.completeSuggestion();
}
};
/**
* This should be called when the user does something other than use text
entry to trigger suggestions.
*
*/
_this._userTriggeredSuggestions = function () {
if (!_this.state.suggestionsVisible) {
var input = _this.input.current ? _this.input.current.value : '';
if (!input) {
_this.onEmptyInputFocus();
}
else {
if (_this.suggestionStore.suggestions.length === 0) {
_this._onResolveSuggestions(input);
}
else {
_this.setState({
});
}
}
}
};
var items = basePickerProps.selectedItems ||
basePickerProps.defaultSelectedItems || [];
_this._id = Utilities_1.getId();
_this._ariaMap = {
selectedItems: "selected-items-" + _this._id,
selectedSuggestionAlert: "selected-suggestion-alert-" + _this._id,
suggestionList: "suggestion-list-" + _this._id,
combobox: "combobox-" + _this._id,
};
_this.suggestionStore = new
SuggestionsController_1.SuggestionsController();
_this.selection = new index_1.Selection({ onSelectionChanged: function () {
return _this.onSelectionChange(); } });
_this.selection.setItems(items);
_this.state = {
items: items,
suggestedDisplayValue: '',
isFocused: false,
isSearching: false,
selectedIndices: [],
selectionRemoved: undefined,
};
return _this;
}
BasePicker.getDerivedStateFromProps = function (newProps) {
if (newProps.selectedItems) {
return { items: newProps.selectedItems };
}
return null;
};
Object.defineProperty(BasePicker.prototype, "items", {
get: function () {
return this.state.items;
},
enumerable: false,
configurable: true
});
BasePicker.prototype.componentDidMount = function () {
this._onResolveSuggestions =
this._async.debounce(this._onResolveSuggestions, this.props.resolveDelay);
};
BasePicker.prototype.componentDidUpdate = function (oldProps, oldState) {
if (this.state.items && this.state.items !== oldState.items) {
var currentSelectedIndex = this.selection.getSelectedIndices()[0];
if (this.state.isFocused) {
// Reset focus and selection so that selected item stays in sync if
something
// has been removed
if (this.state.items.length < oldState.items.length) {
this.selection.setIndexSelected(currentSelectedIndex, false,
true);
this.resetFocus(currentSelectedIndex);
}
// Reset focus to last item if the input is removed
else if (this.state.items.length > oldState.items.length && !
this.canAddItems()) {
this.resetFocus(this.state.items.length - 1);
}
}
}
};
BasePicker.prototype.componentWillUnmount = function () {
if (this.currentPromise) {
this.currentPromise = undefined;
}
};
BasePicker.prototype.focus = function () {
}
};
BasePicker.prototype.focusInput = function () {
}
};
BasePicker.prototype.completeSuggestion = function (forceComplete) {
if (this.suggestionStore.hasSelectedSuggestion() && this.input.current) {
this.completeSelection(this.suggestionStore.currentSuggestion.item);
}
else if (forceComplete) {
this._completeGenericSuggestion();
}
};
BasePicker.prototype.render = function () {
var _a = this.state, suggestedDisplayValue = _a.suggestedDisplayValue,
isFocused = _a.isFocused, items = _a.items;
var _b = this.props, className = _b.className, inputProps = _b.inputProps,
disabled = _b.disabled, selectionAriaLabel = _b.selectionAriaLabel, _c =
_b.selectionRole, selectionRole = _c === void 0 ? 'list' : _c, theme = _b.theme,
styles = _b.styles;
var suggestionsVisible = !!this.state.suggestionsVisible;
var suggestionsAvailable = suggestionsVisible ?
this._ariaMap.suggestionList : undefined;
// TODO
// Clean this up by leaving only the first part after removing support for
SASS.
// Currently we can not remove the SASS styles from BasePicker class
because it
// might be used by consumers who created custom pickers from extending
from
// this base class and have not used the new 'styles' prop.
// We check for 'styles' prop which is going to be injected by the 'styled'
HOC
// for every other already existing picker variant (PeoplePicker,
TagPicker)
// so that we can use the CSS-in-JS styles. If the check fails (ex: custom
picker),
// then we just use the old SASS styles instead.
var classNames = styles
? getClassNames(styles, {
theme: theme,
disabled: disabled,
inputClassName: inputProps && inputProps.className,
})
: {
root: Utilities_1.css('ms-BasePicker', className ? className : ''),
text: Utilities_1.css('ms-BasePicker-text',
legacyStyles.pickerText, this.state.isFocused && legacyStyles.inputFocused),
itemsWrapper: legacyStyles.pickerItems,
input: Utilities_1.css('ms-BasePicker-input',
legacyStyles.pickerInput, inputProps && inputProps.className),
screenReaderText: legacyStyles.screenReaderOnly,
};
var comboLabel = this.props['aria-label'] || (inputProps === null ||
inputProps === void 0 ? void 0 : inputProps['aria-label']);
// selectionAriaLabel is contained in a separate <span> rather than an
aria-label on the items list
// because if the items list has an aria-label, the aria-describedby on the
input will only read
// that label instead of all the selected items. Using aria-labelledby
instead fixes this, since
// aria-describedby and aria-labelledby will not follow a second aria-
labelledby
classNames.root, onKeyDown: this.onKeyDown, onFocus: this.onFocus, onBlur:
this.onBlur, onClick: this.onWrapperClick },
this.renderCustomAlert(classNames.screenReaderText),
React.createElement("span", { id: this._ariaMap.selectedItems + "-
label", hidden: true }, selectionAriaLabel || comboLabel),
React.createElement(index_1.SelectionZone, { selection: this.selection,
selectionMode: index_1.SelectionMode.multiple },
React.createElement("div", { className: classNames.text, "aria-
owns": suggestionsAvailable },
items.length > 0 && (React.createElement("span", { id:
this._ariaMap.selectedItems, className: classNames.itemsWrapper, role:
selectionRole, "aria-labelledby": this._ariaMap.selectedItems + "-label" },
this.renderItems())),
this.canAddItems() && (React.createElement(index_2.Autofill,
tslib_1.__assign({ spellCheck: false }, inputProps, { className: classNames.input,
componentRef: this.input, id: (inputProps === null || inputProps === void 0 ? void
0 : inputProps.id) ? inputProps.id : this._ariaMap.combobox, onClick: this.onClick,
onFocus: this.onInputFocus, onBlur: this.onInputBlur, onInputValueChange:
this.onInputChange, suggestedDisplayValue: suggestedDisplayValue, "aria-
activedescendant": suggestionsVisible ? this.getActiveDescendant() : undefined,
"aria-controls": suggestionsAvailable, "aria-describedby": items.length > 0 ?
this._ariaMap.selectedItems : undefined, "aria-expanded": suggestionsVisible,
"aria-haspopup": "listbox", "aria-label": comboLabel, role: "combobox", disabled:
disabled, onInputChange: this.props.onInputChange }))))),
this.renderSuggestions()));
};
BasePicker.prototype.canAddItems = function () {
var items = this.state.items;
var itemLimit = this.props.itemLimit;
return itemLimit === undefined || items.length < itemLimit;
};
BasePicker.prototype.renderSuggestions = function () {
var StyledTypedSuggestions = this._styledSuggestions;
return this.state.suggestionsVisible && this.input ?
(React.createElement(Callout_1.Callout, tslib_1.__assign({ isBeakVisible: false,
gapSpace: 5, target: this.input.current ? this.input.current.inputElement :
undefined, onDismiss: this.dismissSuggestions, directionalHint:
DirectionalHint_1.DirectionalHint.bottomLeftEdge, directionalHintForRTL:
DirectionalHint_1.DirectionalHint.bottomRightEdge },
this.props.pickerCalloutProps),
React.createElement(StyledTypedSuggestions
// Assumed to set in derived component's defaultProps
, tslib_1.__assign({
// Assumed to set in derived component's defaultProps
onRenderSuggestion: this.props.onRenderSuggestionsItem,
onSuggestionClick: this.onSuggestionClick, onSuggestionRemove:
this.onSuggestionRemove, suggestions: this.suggestionStore.getSuggestions(),
componentRef: this.suggestionElement, onGetMoreResults: this.onGetMoreResults,
moreSuggestionsAvailable: this.state.moreSuggestionsAvailable, isLoading:
this.state.suggestionsLoading, isSearching: this.state.isSearching,
isMostRecentlyUsedVisible: this.state.isMostRecentlyUsedVisible,
isResultsFooterVisible: this.state.isResultsFooterVisible, refocusSuggestions:
this.refocusSuggestions, removeSuggestionAriaLabel:
this.props.removeButtonAriaLabel, suggestionsListId: this._ariaMap.suggestionList,
createGenericItem: this._completeGenericSuggestion },
this.props.pickerSuggestionsProps)))) : null;
};
BasePicker.prototype.renderItems = function () {
var _this = this;
var _a = this.props, disabled = _a.disabled, removeButtonAriaLabel =
_a.removeButtonAriaLabel, removeButtonIconProps = _a.removeButtonIconProps;
var onRenderItem = this.props.onRenderItem;
var _b = this.state, items = _b.items, selectedIndices =
_b.selectedIndices;
return items.map(function (item, index) {
return onRenderItem({
item: item,
index: index,
selected: selectedIndices.indexOf(index) !== -1,
disabled: disabled,
onItemChange: _this.onItemChange,
removeButtonIconProps: removeButtonIconProps,
});
});
};
BasePicker.prototype.resetFocus = function (index) {
var items = this.state.items;
if (items.length && index >= 0) {
var newEl = this.root.current &&
this.root.current.querySelectorAll('[data-selection-index]')
[Math.min(index, items.length - 1)];
if (newEl) {
newEl.focus();
}
}
else if (!this.canAddItems()) {
this.resetFocus(items.length - 1);
}
else {
}
}
};
BasePicker.prototype.onSuggestionSelect = function () {
if (this.suggestionStore.currentSuggestion) {
var currentValue = this.input.current ? this.input.current.value : '';
var itemValue =
this._getTextFromItem(this.suggestionStore.currentSuggestion.item, currentValue);
this.setState({ suggestedDisplayValue: itemValue });
}
};
BasePicker.prototype.onSelectionChange = function () {
this.setState({
selectedIndices: this.selection.getSelectedIndices(),
});
};
BasePicker.prototype.updateSuggestions = function (suggestions) {
this.suggestionStore.updateSuggestions(suggestions, 0);
this.forceUpdate();
};
/**
* Only to be called when there is nothing in the input. Checks to see if the
consumer has
* provided a function to resolve suggestions
*/
BasePicker.prototype.onEmptyInputFocus = function () {
var emptyResolveSuggestions = this.props.onEmptyResolveSuggestions
? this.props.onEmptyResolveSuggestions
: // eslint-disable-next-line deprecation/deprecation
this.props.onEmptyInputFocus;
// Only attempt to resolve suggestions if it exists
if (emptyResolveSuggestions) {
var suggestions = emptyResolveSuggestions(this.state.items);
this.setState({
isMostRecentlyUsedVisible: true,
});
}
};
BasePicker.prototype.updateValue = function (updatedValue) {
this._onResolveSuggestions(updatedValue);
};
BasePicker.prototype.updateSuggestionsList = function (suggestions,
updatedValue) {
var _this = this;
// Check to see if the returned value is an array, if it is then just pass
it into the next function .
// If the returned value is not an array then check to see if it's a
promise or PromiseLike.
if (Array.isArray(suggestions)) {
this._updateAndResolveValue(updatedValue, suggestions);
}
else if (suggestions && suggestions.then) {
this.setState({
suggestionsLoading: true,
});
// Clear suggestions
this.suggestionStore.updateSuggestions([]);
if (updatedValue !== undefined) {
this.setState({
suggestionsVisible: this._getShowSuggestions(),
});
}
else {
this.setState({
suggestionsVisible: this.input.current &&
this.input.current.inputElement === document.activeElement,
});
}
// Ensure that the promise will only use the callback if it was the
most recent one.
this.currentPromise = suggestions;
suggestions.then(function (newSuggestions) {
if (suggestions === _this.currentPromise) {
_this._updateAndResolveValue(updatedValue, newSuggestions);
}
});
}
};
BasePicker.prototype.resolveNewValue = function (updatedValue, suggestions) {
var _this = this;
this.updateSuggestions(suggestions);
var itemValue = undefined;
if (this.suggestionStore.currentSuggestion) {
itemValue =
this._getTextFromItem(this.suggestionStore.currentSuggestion.item, updatedValue);
}
// Only set suggestionloading to false after there has been time for the
new suggestions to flow
// to the suggestions list. This is to ensure that the suggestions are
available before aria-activedescendant
// is set so that screen readers will read out the first selected option.
this.setState({
suggestedDisplayValue: itemValue,
suggestionsVisible: this._getShowSuggestions(),
}, function () { return _this.setState({ suggestionsLoading: false }); });
};
BasePicker.prototype.onChange = function (items) {
this.props.onChange(items);
}
};
// This is protected because we may expect the backspace key to work
differently in a different kind of picker.
// This lets the subclass override it and provide it's own onBackspace. For an
example see the BasePickerListBelow
BasePicker.prototype.onBackspace = function (ev) {
if ((this.state.items.length && !this.input.current) ||
(this.input.current && !this.input.current.isValueSelected &&
this.input.current.cursorLocation === 0)) {
if (this.selection.getSelectedCount() > 0) {
this.removeItems(this.selection.getSelection());
}
else {
this.removeItem(this.state.items[this.state.items.length - 1]);
}
}
};
BasePicker.prototype.getActiveDescendant = function () {
var _a;
if (this.state.suggestionsLoading) {
return undefined;
}
var currentIndex = this.suggestionStore.currentIndex;
if (currentIndex < 0) {
// if the suggestions element has actions and the currentIndex does not
point to a suggestion,
// return the action id
if ((_a = this.suggestionElement.current) === null || _a === void 0 ?
void 0 : _a.hasSuggestedAction()) {
return 'sug-selectedAction';
}
// If there are no suggestions and no action suggested, then return the
ID for the no results found.
if (this.suggestionStore.suggestions.length === 0) {
return 'sug-noResultsFound';
}
return undefined;
}
else {
return "sug-" + currentIndex;
}
};
/** @deprecated use renderCustomAlert instead */
BasePicker.prototype.getSuggestionsAlert = function (suggestionAlertClassName)
{
if (suggestionAlertClassName === void 0) { suggestionAlertClassName =
legacyStyles.screenReaderOnly; }
var currentIndex = this.suggestionStore.currentIndex;
if (this.props.enableSelectedSuggestionAlert) {
var selectedSuggestion = currentIndex > -1 ?
this.suggestionStore.getSuggestionAtIndex(this.suggestionStore.currentIndex) :
undefined;
var selectedSuggestionAlertText = selectedSuggestion ?
selectedSuggestion.ariaLabel : undefined;
// keeping the id/className here for legacy support
return (React.createElement("div", { id:
this._ariaMap.selectedSuggestionAlert, className: suggestionAlertClassName },
selectedSuggestionAlertText + " "));
}
};
BasePicker.prototype.renderCustomAlert = function (alertClassName) {
if (alertClassName === void 0) { alertClassName =
legacyStyles.screenReaderOnly; }
var _a = this.props.suggestionRemovedText, suggestionRemovedText = _a ===
void 0 ? 'removed {0}' : _a;
var removedItemText = '';
if (this.state.selectionRemoved) {
var itemName = this._getTextFromItem(this.state.selectionRemoved, '');
removedItemText = Utilities_1.format(suggestionRemovedText, itemName);
}
return (React.createElement("div", { className: alertClassName, id:
this._ariaMap.selectedSuggestionAlert, "aria-live": "assertive" },
this.getSuggestionsAlert(alertClassName),
removedItemText));
};
/**
* Takes in the current updated value and either resolves it with the new
suggestions
* or if updated value is undefined then it clears out currently suggested
items
*/
BasePicker.prototype._updateAndResolveValue = function (updatedValue,
newSuggestions) {
if (updatedValue !== undefined) {
this.resolveNewValue(updatedValue, newSuggestions);
}
else {
this.suggestionStore.updateSuggestions(newSuggestions, -1);
if (this.state.suggestionsLoading) {
this.setState({
suggestionsLoading: false,
});
}
}
};
/**
* Controls what happens whenever there is an action that impacts the selected
items.
* If `selectedItems` is provided, this will act as a controlled component and
it will not update its own state.
*/
BasePicker.prototype._updateSelectedItems = function (items) {
var _this = this;
if (this.props.selectedItems) {
// If the component is a controlled component then the controlling
component will need to add or remove the items.
}
else {
this.setState({ items: items }, function () {
_this._onSelectedItemsUpdated(items);
});
}
};
BasePicker.prototype._onSelectedItemsUpdated = function (items) {
};
/**
* Suggestions are normally shown after the user updates text and the text
* is non-empty, but also when the user clicks on the input element.
* @returns True if suggestions should be shown.
*/
BasePicker.prototype._getShowSuggestions = function () {
var areSuggestionsVisible = this.input.current !== undefined &&
this.input.current !== null &&
this.input.current.inputElement === document.activeElement &&
this.input.current.value !== '';
return areSuggestionsVisible;
};
BasePicker.prototype._getTextFromItem = function (item, currentValue) {
if (this.props.getTextFromItem) {
return this.props.getTextFromItem(item, currentValue);
}
else {
return '';
}
};
return BasePicker;
exports.BasePicker = BasePicker;
var BasePickerListBelow = /** @class */ (function (_super) {
tslib_1.__extends(BasePickerListBelow, _super);
function BasePickerListBelow() {
}
BasePickerListBelow.prototype.render = function () {
var _a = this.state, suggestedDisplayValue = _a.suggestedDisplayValue,
isFocused = _a.isFocused;
var _b = this.props, className = _b.className, inputProps = _b.inputProps,
disabled = _b.disabled, selectionAriaLabel = _b.selectionAriaLabel, _c =
_b.selectionRole, selectionRole = _c === void 0 ? 'list' : _c, theme = _b.theme,
styles = _b.styles;
var suggestionsVisible = !!this.state.suggestionsVisible;
var suggestionsAvailable = suggestionsVisible ?
this._ariaMap.suggestionList : undefined;
// TODO
SASS.
// Currently we can not remove the SASS styles from BasePicker class
because it
// might be used by consumers who created custom pickers from extending
from
// this base class and have not used the new 'styles' prop.
HOC
// for every other already existing picker variant (PeoplePicker,
TagPicker)
// so that we can use the CSS-in-JS styles. If the check fails (ex: custom
picker),
theme: theme,
inputClassName: inputProps && inputProps.className,
})
: {
root: Utilities_1.css('ms-BasePicker', className ? className : ''),
text: Utilities_1.css('ms-BasePicker-text',
legacyStyles.pickerText, this.state.isFocused && legacyStyles.inputFocused,
disabled && legacyStyles.inputDisabled),
itemsWrapper: legacyStyles.pickerItems,
input: Utilities_1.css('ms-BasePicker-input',
legacyStyles.pickerInput, inputProps && inputProps.className),
screenReaderText: legacyStyles.screenReaderOnly,
};
var comboLabel = this.props['aria-label'] || (inputProps === null ||
inputProps === void 0 ? void 0 : inputProps['aria-label']);
return (React.createElement("div", { ref: this.root, onBlur: this.onBlur,
onFocus: this.onFocus },
React.createElement("div", { className: classNames.root, onKeyDown:
this.onKeyDown },
this.renderCustomAlert(classNames.screenReaderText),
React.createElement("div", { className: classNames.text, "aria-
owns": suggestionsAvailable },
React.createElement(index_2.Autofill, tslib_1.__assign({},
inputProps, { className: classNames.input, componentRef: this.input, onFocus:
this.onInputFocus, onBlur: this.onInputBlur, onClick: this.onClick,
onInputValueChange: this.onInputChange, suggestedDisplayValue:
suggestedDisplayValue, "aria-activedescendant": suggestionsVisible ?
this.getActiveDescendant() : undefined, "aria-controls": suggestionsAvailable,
"aria-expanded": suggestionsVisible, "aria-haspopup": "listbox", "aria-label":
comboLabel, role: "combobox", id: (inputProps === null || inputProps === void 0 ?
void 0 : inputProps.id) ? inputProps.id : this._ariaMap.combobox, disabled:
disabled, onInputChange: this.props.onInputChange })))),
this.renderSuggestions(),
React.createElement(index_1.SelectionZone, { selection: this.selection,
selectionMode: index_1.SelectionMode.single },
React.createElement("div", { id: this._ariaMap.selectedItems,
className: "ms-BasePicker-selectedItems" // just a className hook without any
styles applied to it.
, role: selectionRole, "aria-label": selectionAriaLabel ||
comboLabel }, this.renderItems()))));
};
BasePickerListBelow.prototype.onBackspace = function (ev) {
// override the existing backspace method to not do anything because the
list items appear below.
};
return BasePickerListBelow;
}(BasePicker));
exports.BasePickerListBelow = BasePickerListBelow;
//# sourceMappingURL=BasePicker.js.map
/***/ }),
/***/ 10349:
"use strict";

exports.screenReaderOnly = exports.pickerItems = exports.pickerInput =
exports.inputDisabled = exports.inputFocused = exports.pickerText = void 0;
load_themed_styles_1.loadStyles([{ "rawString": ".pickerText_a8f91b74{display:-
webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-
webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-
sizing:border-box;box-sizing:border-box;border:1px solid " }, { "theme":
"neutralTertiary", "defaultValue": "#a19f9d" }, { "rawString": ";min-
width:180px;min-height:30px}.pickerText_a8f91b74:hover{border-color:" }, { "theme":
"inputBorderHovered", "defaultValue": "#323130" }, { "rawString":
"}.pickerText_a8f91b74.inputFocused_a8f91b74{position:relative;border-color:" },
{ "theme": "inputFocusBorderAlt", "defaultValue": "#0078d4" }, { "rawString":
"}.pickerText_a8f91b74.inputFocused_a8f91b74:after{pointer-
events:none;content:\"\";position:absolute;left:-1px;top:-1px;bottom:-1px;right:-
1px;border:2px solid " }, { "theme": "inputFocusBorderAlt", "defaultValue":
"#0078d4" }, { "rawString": "}@media screen and (-ms-high-contrast:active),screen
and (forced-colors:active)
{.pickerText_a8f91b74.inputDisabled_a8f91b74{position:relative;border-
color:GrayText}.pickerText_a8f91b74.inputDisabled_a8f91b74:after{pointer-
events:none;content:\"\";position:absolute;left:0;top:0;bottom:0;right:0;background
-color:Window}}.pickerInput_a8f91b74{height:34px;border:none;-webkit-box-flex:1;-
ms-flex-positive:1;flex-grow:1;outline:0;padding:0 6px 0;-ms-flex-item-
align:end;align-self:flex-end}.pickerItems_a8f91b74{display:-webkit-box;display:-
ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;max-
width:100%}.screenReaderOnly_a8f91b74{position:absolute;width:1px;height:1px;paddin
g:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}" }]);
exports.pickerText = "pickerText_a8f91b74";
exports.inputFocused = "inputFocused_a8f91b74";
exports.inputDisabled = "inputDisabled_a8f91b74";
exports.pickerInput = "pickerInput_a8f91b74";
exports.pickerItems = "pickerItems_a8f91b74";
exports.screenReaderOnly = "screenReaderOnly_a8f91b74";
//# sourceMappingURL=BasePicker.scss.js.map
/***/ }),
/***/ 91311:
"use strict";

root: 'ms-BasePicker',
text: 'ms-BasePicker-text',
itemsWrapper: 'ms-BasePicker-itemsWrapper',
input: 'ms-BasePicker-input',
};
var _a, _b, _c;
var className = props.className, theme = props.theme, isFocused =
props.isFocused, inputClassName = props.inputClassName, disabled = props.disabled;
if (!theme) {
throw new Error('theme is undefined or null in base BasePicker getStyles
function.');
}
theme.fonts;
var inputBorder = semanticColors.inputBorder, inputBorderHovered =
semanticColors.inputBorderHovered, inputFocusBorderAlt =
semanticColors.inputFocusBorderAlt;
fonts.medium,
{
opacity: 1,
color: 'GrayText',
},
_a),
},
];
var disabledPlaceholderStyles = {
color: 'GrayText',
},
_b),
};
// The following lines are to create a semi-transparent color overlay for the
disabled state with designer's approval.
// @todo: investigate the performance cost of the calculation below and apply
if negligible.
// Replacing with a static color for now.
// const rgbColor: IRGB | undefined = cssColor(palette.neutralQuaternaryAlt);
// const disabledOverlayColor = rgbColor ? `rgba(${rgbColor.r}, ${rgbColor.g},
${rgbColor.b}, 0.29)` : 'transparent';
var disabledOverlayColor = 'rgba(218, 218, 218, 0.29)';
return {
root: [classNames.root, className],
text: [
classNames.text,
{
display: 'flex',
flexWrap: 'wrap',
minWidth: 180,
minHeight: 30,
border: "1px solid " + inputBorder,
},
!isFocused &&
!disabled && {
selectors: {
':hover': {
borderColor: inputBorderHovered,
},
},
},
isFocused && !disabled &&
Styling_1.getInputFocusStyle(inputFocusBorderAlt, effects.roundedCorner2),
disabled && {
borderColor: disabledOverlayColor,
selectors: (_c = {
':after': {
content: '""',
top: 0,
right: 0,
bottom: 0,
left: 0,
background: disabledOverlayColor,
}
},
selectors: {
':after': {
background: 'none',
},
},
},
_c),
},
],
itemsWrapper: [
classNames.itemsWrapper,
{
display: 'flex',
flexWrap: 'wrap',
maxWidth: '100%',
},
],
input: [
classNames.input,
fonts.medium,
{
height: 30,
border: 'none',
flexGrow: 1,
outline: 'none',
padding: '0 6px 0',
selectors: {
'::-ms-clear': {
display: 'none',
},
},
},
disabled && Styling_1.getPlaceholderStyles(disabledPlaceholderStyles),
inputClassName,
],
};
}
//# sourceMappingURL=BasePicker.styles.js.map
/***/ }),
/***/ 73490:
"use strict";

exports.ValidationState = void 0;
/**
* Validation state of the user's input.
*/
var ValidationState;
(function (ValidationState) {
/** User input is valid. */
ValidationState[ValidationState["valid"] = 0] = "valid";
/** User input could be valid or invalid, its state is not known yet. */
ValidationState[ValidationState["warning"] = 1] = "warning";
/** User input is invalid. */
ValidationState[ValidationState["invalid"] = 2] = "invalid";
})(ValidationState = exports.ValidationState || (exports.ValidationState = {}));
//# sourceMappingURL=BasePicker.types.js.map
/***/ }),
/***/ 55684:
"use strict";

exports.ListPeoplePicker = exports.CompactPeoplePicker = exports.NormalPeoplePicker
= exports.createGenericItem = exports.ListPeoplePickerBase =
exports.CompactPeoplePickerBase = exports.NormalPeoplePickerBase =
exports.MemberListPeoplePicker = exports.BasePeoplePicker = void 0;
var BasePicker_1 = __webpack_require__(79267);
var PeoplePickerItem_1 = __webpack_require__(95295);
var PeoplePickerItemSuggestion_1 = __webpack_require__(55042);
var BasePicker_styles_1 = __webpack_require__(91311);
/**
* {@docCategory PeoplePicker}
*/
var BasePeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(BasePeoplePicker, _super);
function BasePeoplePicker() {
}
return BasePeoplePicker;
}(BasePicker_1.BasePicker));
exports.BasePeoplePicker = BasePeoplePicker;
/**
*/
var MemberListPeoplePicker = /** @class */ (function (_super) {
tslib_1.__extends(MemberListPeoplePicker, _super);
function MemberListPeoplePicker() {
}
return MemberListPeoplePicker;
}(BasePicker_1.BasePickerListBelow));
exports.MemberListPeoplePicker = MemberListPeoplePicker;
/**
* Standard People Picker.
*/
var NormalPeoplePickerBase = /** @class */ (function (_super) {
tslib_1.__extends(NormalPeoplePickerBase, _super);
function NormalPeoplePickerBase() {
}
/** Default props for NormalPeoplePicker. */
NormalPeoplePickerBase.defaultProps = {
React.createElement(PeoplePickerItem_1.PeoplePickerItem, tslib_1.__assign({},
props)); },
onRenderSuggestionsItem: function (personaProps, suggestionsProps) { return
(React.createElement(PeoplePickerItemSuggestion_1.PeoplePickerItemSuggestion,
{ personaProps: personaProps, suggestionsProps: suggestionsProps })); },
createGenericItem: createGenericItem,
};
return NormalPeoplePickerBase;
}(BasePeoplePicker));
exports.NormalPeoplePickerBase = NormalPeoplePickerBase;
/**
* Compact layout. It uses personas without secondary text when displaying search
results.
*/
var CompactPeoplePickerBase = /** @class */ (function (_super) {
tslib_1.__extends(CompactPeoplePickerBase, _super);
function CompactPeoplePickerBase() {
}
/** Default props for CompactPeoplePicker. */
CompactPeoplePickerBase.defaultProps = {
props)); },
{ personaProps: personaProps, suggestionsProps: suggestionsProps, compact:
true })); },
};
return CompactPeoplePickerBase;
}(BasePeoplePicker));
exports.CompactPeoplePickerBase = CompactPeoplePickerBase;
/**
* MemberList layout. The selected people show up below the search box.
*/
var ListPeoplePickerBase = /** @class */ (function (_super) {
tslib_1.__extends(ListPeoplePickerBase, _super);
function ListPeoplePickerBase() {
}
/** Default props for ListPeoplePicker. */
ListPeoplePickerBase.defaultProps = {
props)); },
{ personaProps: personaProps, suggestionsProps: suggestionsProps })); },
};
return ListPeoplePickerBase;
}(MemberListPeoplePicker));
exports.ListPeoplePickerBase = ListPeoplePickerBase;
/**
*/
function createGenericItem(name, currentValidationState) {
var personaToConvert = {
key: name,
primaryText: name,
imageInitials: '!',
ValidationState: currentValidationState,
};
if (currentValidationState !== BasePicker_types_1.ValidationState.warning) {
personaToConvert.imageInitials = Utilities_1.getInitials(name,
Utilities_1.getRTL());
}
return personaToConvert;
}
exports.createGenericItem = createGenericItem;
exports.NormalPeoplePicker = Utilities_1.styled(NormalPeoplePickerBase,
BasePicker_styles_1.getStyles, undefined, {
scope: 'NormalPeoplePicker',
});
exports.CompactPeoplePicker = Utilities_1.styled(CompactPeoplePickerBase,
scope: 'CompactPeoplePicker',
});
exports.ListPeoplePicker = Utilities_1.styled(ListPeoplePickerBase,
scope: 'ListPeoplePickerBase',
});
//# sourceMappingURL=PeoplePicker.js.map
/***/ }),
/***/ 95295:
"use strict";

exports.PeoplePickerItem = exports.PeoplePickerItemBase = void 0;
var PeoplePickerItem_styles_1 = __webpack_require__(69125);
var PeoplePickerItemBase = function (props) {
var item = props.item, onRemoveItem = props.onRemoveItem, index = props.index,
selected = props.selected, removeButtonAriaLabel = props.removeButtonAriaLabel,
styles = props.styles, theme = props.theme, className = props.className, disabled =
props.disabled, removeButtonIconProps = props.removeButtonIconProps;
theme: theme,
selected: selected,
disabled: disabled,
invalid: item.ValidationState ===
BasePicker_types_1.ValidationState.warning,
});
var personaStyles = classNames.subComponentStyles
? classNames.subComponentStyles.persona
: undefined;
var personaCoinStyles = classNames.subComponentStyles
? classNames.subComponentStyles.personaCoin
: undefined;
'listitem' },
React.createElement("div", { className: classNames.itemContent, id:
'selectedItemPersona-' + itemId },
React.createElement(Persona_1.Persona, tslib_1.__assign({ size:
Persona_1.PersonaSize.size24, styles: personaStyles, coinProps: { styles:
personaCoinStyles } }, item))),
React.createElement(Button_1.IconButton, { id: itemId, onClick:
onRemoveItem, disabled: disabled, iconProps: removeButtonIconProps !== null &&
removeButtonIconProps !== void 0 ? removeButtonIconProps : { iconName: 'Cancel' },
styles: { icon: { fontSize: '12px' } }, className: classNames.removeButton,
ariaLabel: removeButtonAriaLabel, "aria-labelledby": itemId + "
selectedItemPersona-" + itemId, "data-selection-index": index })));
};
exports.PeoplePickerItemBase = PeoplePickerItemBase;
exports.PeoplePickerItem = Utilities_1.styled(exports.PeoplePickerItemBase,
PeoplePickerItem_styles_1.getStyles, undefined, { scope: 'PeoplePickerItem' });
//# sourceMappingURL=PeoplePickerItem.js.map
/***/ }),
/***/ 69125:
"use strict";

root: 'ms-PickerPersona-container',
itemContent: 'ms-PickerItem-content',
removeButton: 'ms-PickerItem-removeButton',
isInvalid: 'is-invalid',
};
var REMOVE_BUTTON_SIZE = 24;
var _a, _b, _c, _d, _e, _f, _g, _h;
var className = props.className, theme = props.theme, selected =
props.selected, invalid = props.invalid, disabled = props.disabled;
theme.fonts;
var personaPrimaryTextStyles = [
selected &&
!invalid &&
!disabled && {
selectors: (_a = {
':hover': {
}
},
},
_a),
},
((invalid && !selected) || (invalid && selected && disabled)) && {
color: palette.redDark,
borderBottom: "2px dotted " + palette.redDark,
_b["." + classNames.root + ":hover &"] = {
// override Persona root:hover selector
color: palette.redDark,
},
_b),
},
invalid &&
selected &&
!disabled && {
borderBottom: "2px dotted " + palette.white,
},
disabled && {
color: 'GrayText',
},
_c),
},
];
var personaSecondaryTextStyles = [
selected &&
!invalid &&
!disabled && {
selectors: (_d = {
':hover': {
}
},
},
_d),
},
];
var personaCoinInitialsStyles = [
invalid && {
},
];
return {
root: [
classNames.root,
{
borderRadius: 15,
background: palette.neutralLighter,
margin: '1px 2px',
cursor: 'default',
userSelect: 'none',
maxWidth: 300,
minWidth: 0,
selectors: (_e = {
':hover': {
background: !selected && !disabled ?
palette.neutralLight : '',
}
},
_e[Styling_1.HighContrastSelector] = [{ border: '1px solid
WindowText' }, disabled && { borderColor: 'GrayText' }],
_e),
},
selected &&
!disabled && [
{
_f[Styling_1.HighContrastSelector] =
tslib_1.__assign({ borderColor: 'HighLight', background: 'Highlight' },
_f),
},
],
invalid && [classNames.isInvalid],
invalid &&
selected &&
!disabled && {
background: palette.redDark,
},
className,
],
itemContent: [
classNames.itemContent,
{
flex: '0 1 auto',
minWidth: 0,
// CSS below is needed for IE 11 to properly truncate long persona
names in the picker
// and to clip the presence indicator (in all browsers)
maxWidth: '100%',
overflow: 'hidden',
},
],
removeButton: [
classNames.removeButton,
{
borderRadius: 15,
flex: '0 0 auto',
width: REMOVE_BUTTON_SIZE,
height: REMOVE_BUTTON_SIZE,
selectors: {
':hover': {
background: palette.neutralTertiaryAlt,
},
},
},
selected && [
{
selectors: (_g = {
':hover': {
},
':active': {
background: palette.themeDarker,
}
},
},
_g),
},
invalid && {
selectors: {
':hover': {
background: palette.red,
},
':active': {
background: palette.redDark,
},
},
},
],
disabled && {
_h["." +
},
_h),
},
],
persona: {
primaryText: personaPrimaryTextStyles,
secondaryText: personaSecondaryTextStyles,
},
personaCoin: {
initials: personaCoinInitialsStyles,
},
},
};
}
//# sourceMappingURL=PeoplePickerItem.styles.js.map
/***/ }),
/***/ 90949:
"use strict";

//# sourceMappingURL=PeoplePickerItem.types.js.map
/***/ }),
/***/ 55042:
"use strict";

exports.PeoplePickerItemSuggestion = exports.PeoplePickerItemSuggestionBase = void
0;
var PeoplePickerItemSuggestion_styles_1 = __webpack_require__(25483);
var PeoplePickerItemSuggestionBase = function (props) {
var personaProps = props.personaProps, suggestionsProps =
props.suggestionsProps, compact = props.compact, styles = props.styles, theme =
props.theme, className = props.className;
theme: theme,
className: (suggestionsProps && suggestionsProps.suggestionsItemClassName)
|| className,
});
var personaStyles = classNames.subComponentStyles &&
classNames.subComponentStyles.persona
? classNames.subComponentStyles.persona
: undefined;
React.createElement(Persona_1.Persona, tslib_1.__assign({ size:
Persona_1.PersonaSize.size24, styles: personaStyles, className:
classNames.personaWrapper, showSecondaryText: !compact, showOverflowTooltip:
false }, personaProps))));
};
exports.PeoplePickerItemSuggestionBase = PeoplePickerItemSuggestionBase;
exports.PeoplePickerItemSuggestion =
Utilities_1.styled(exports.PeoplePickerItemSuggestionBase,
PeoplePickerItemSuggestion_styles_1.getStyles, undefined, { scope:
'PeoplePickerItemSuggestion' });
//# sourceMappingURL=PeoplePickerItemSuggestion.js.map
/***/ }),
/***/ 25483:
"use strict";
var SuggestionsItem_styles_1 = __webpack_require__(40297);
root: 'ms-PeoplePicker-personaContent',
personaWrapper: 'ms-PeoplePicker-Persona',
};
var _a, _b, _c;
var textSelectorsStyles = {
_a["." +
SuggestionsItem_styles_1.SuggestionsItemGlobalClassNames.isSuggested + " &"] = {
},
_b),
},
_a["." + classNames.root + ":hover &"] = {
},
_c),
},
_a),
};
return {
root: [
classNames.root,
{
width: '100%',
},
className,
],
personaWrapper: [
classNames.personaWrapper,
{
width: 180,
},
],
persona: {
primaryText: textSelectorsStyles,
secondaryText: textSelectorsStyles,
},
},
};
}
//# sourceMappingURL=PeoplePickerItemSuggestion.styles.js.map
/***/ }),
/***/ 58131:
"use strict";

//# sourceMappingURL=PickerItem.types.js.map
/***/ }),
/***/ 94369:
"use strict";

exports.Suggestions = void 0;
var Spinner_1 = __webpack_require__(36875);
var Announced_1 = __webpack_require__(84399);
var Suggestions_types_1 = __webpack_require__(37285);
var SuggestionsItem_1 = __webpack_require__(16571);
var SuggestionsItem_styles_1 = __webpack_require__(40297);
var StyledSuggestionsItem = Utilities_1.styled(SuggestionsItem_1.SuggestionsItem,
SuggestionsItem_styles_1.getStyles, undefined, {
scope: 'SuggestionItem',
});
/**
*/
var Suggestions = /** @class */ (function (_super) {
tslib_1.__extends(Suggestions, _super);
function Suggestions(suggestionsProps) {
_this._forceResolveButton = React.createRef();
_this._searchForMoreButton = React.createRef();
_this._scrollContainer = React.createRef();
/**
* Returns true if the event was handled, false otherwise
*/
_this.tryHandleKeyDown = function (keyCode, currentSuggestionIndex) {
var isEventHandled = false;
var newSelectedActionType = null;
var currentSelectedAction = _this.state.selectedActionType;
var suggestionLength = _this.props.suggestions.length;
if (keyCode === Utilities_1.KeyCodes.down) {
switch (currentSelectedAction) {
case Suggestions_types_1.SuggestionActionType.forceResolve:
if (suggestionLength > 0) {
_this._refocusOnSuggestions(keyCode);
newSelectedActionType =
Suggestions_types_1.SuggestionActionType.none;
}
else if (_this._searchForMoreButton.current) {
Suggestions_types_1.SuggestionActionType.searchMore;
}
else {
Suggestions_types_1.SuggestionActionType.forceResolve;
}
break;
case Suggestions_types_1.SuggestionActionType.searchMore:
if (_this._forceResolveButton.current) {
}
else if (suggestionLength > 0) {
}
else {
}
break;
case Suggestions_types_1.SuggestionActionType.none:
if (currentSuggestionIndex === -1 &&
_this._forceResolveButton.current) {
}
break;
}
}
else if (keyCode === Utilities_1.KeyCodes.up) {
switch (currentSelectedAction) {
if (_this._searchForMoreButton.current) {
}
else if (suggestionLength > 0) {
}
break;
if (suggestionLength > 0) {
}
else if (_this._forceResolveButton.current) {
}
break;
case Suggestions_types_1.SuggestionActionType.none:
if (currentSuggestionIndex === -1 &&
_this._searchForMoreButton.current) {
}
break;
}
}
if (newSelectedActionType !== null) {
_this.setState({ selectedActionType: newSelectedActionType });
isEventHandled = true;
}
return isEventHandled;
};
_this._getAlertText = function () {
var _a = _this.props, isLoading = _a.isLoading, isSearching =
_a.isSearching, suggestions = _a.suggestions, suggestionsAvailableAlertText =
_a.suggestionsAvailableAlertText, noResultsFoundText = _a.noResultsFoundText;
if (!isLoading && !isSearching) {
if (suggestions.length > 0) {
return suggestionsAvailableAlertText || '';
}
if (noResultsFoundText) {
return noResultsFoundText;
}
}
return '';
};
_this._getMoreResults = function () {
if (_this.props.onGetMoreResults) {
_this.props.onGetMoreResults();
// Reset selected action type as it will be of type
SuggestionActionType.none after more results are gotten
_this.setState({ selectedActionType:
Suggestions_types_1.SuggestionActionType.none });
}
};
_this._forceResolve = function () {
if (_this.props.createGenericItem) {
_this.props.createGenericItem();
}
};
_this._shouldShowForceResolve = function () {
return _this.props.showForceResolve ? _this.props.showForceResolve() :
false;
};
_this._onClickTypedSuggestionsItem = function (item, index) {
_this.props.onSuggestionClick(ev, item, index);
};
};
_this._refocusOnSuggestions = function (keyCode) {
if (typeof _this.props.refocusSuggestions === 'function') {
_this.props.refocusSuggestions(keyCode);
}
};
_this._onRemoveTypedSuggestionsItem = function (item, index) {
var onSuggestionRemove = _this.props.onSuggestionRemove;
onSuggestionRemove(ev, item, index);
};
};
_this.state = {
selectedActionType: Suggestions_types_1.SuggestionActionType.none,
};
return _this;
}
Suggestions.prototype.componentDidMount = function () {
this.activeSelectedElement = this._selectedElement ?
this._selectedElement.current : null;
};
Suggestions.prototype.componentDidUpdate = function () {
// Only scroll to selected element if the selected element has changed.
Otherwise do nothing.
// This prevents some odd behavior where scrolling the active element out
of view and clicking on a selected element
// will trigger a focus event and not give the clicked element the click.
if (this._selectedElement.current && this.activeSelectedElement !==
this._selectedElement.current) {
this.activeSelectedElement = this._selectedElement.current;
}
};
Suggestions.prototype.render = function () {
var _a, _b;
var _this = this;
var _c = this.props, forceResolveText = _c.forceResolveText,
mostRecentlyUsedHeaderText = _c.mostRecentlyUsedHeaderText, searchForMoreIcon =
_c.searchForMoreIcon, searchForMoreText = _c.searchForMoreText, className =
_c.className, moreSuggestionsAvailable = _c.moreSuggestionsAvailable,
noResultsFoundText = _c.noResultsFoundText, suggestions = _c.suggestions, isLoading
= _c.isLoading, isSearching = _c.isSearching, loadingText = _c.loadingText,
onRenderNoResultFound = _c.onRenderNoResultFound, searchingText = _c.searchingText,
isMostRecentlyUsedVisible = _c.isMostRecentlyUsedVisible, resultsMaximumNumber =
_c.resultsMaximumNumber, resultsFooterFull = _c.resultsFooterFull, resultsFooter =
_c.resultsFooter, _d = _c.isResultsFooterVisible, isResultsFooterVisible = _d ===
void 0 ? true : _d, suggestionsHeaderText = _c.suggestionsHeaderText,
suggestionsClassName = _c.suggestionsClassName, theme = _c.theme, styles =
_c.styles, suggestionsListId = _c.suggestionsListId, suggestionsContainerAriaLabel
= _c.suggestionsContainerAriaLabel;
// TODO
SASS.
// Currently we can not remove the SASS styles from Suggestions class
because it
// might be used by consumers separately from pickers extending from
BasePicker
// and have not used the new 'styles' prop. Because it's expecting a type
parameter,
// we can not use the 'styled' function without adding some helpers which
can break
// downstream consumers who did not use the new helpers.
HOC
// in BasePicker when the typed Suggestions class is ready to be rendered.
If the check
// passes we can use the CSS-in-JS styles. If the check fails (ex: custom
picker),
this._classNames = styles
theme: theme,
suggestionsClassName: suggestionsClassName,
forceResolveButtonSelected: this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.forceResolve,
searchForMoreButtonSelected: this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.searchMore,
})
: {
root: Utilities_1.css('ms-Suggestions', className,
legacyStyles.root),
title: Utilities_1.css('ms-Suggestions-title',
legacyStyles.suggestionsTitle),
searchForMoreButton: Utilities_1.css('ms-SearchMore-button',
legacyStyles.actionButton, (_a = {},
_a['is-selected ' + legacyStyles.buttonSelected] =
this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.searchMore,
_a)),
forceResolveButton: Utilities_1.css('ms-forceResolve-button',
legacyStyles.actionButton, (_b = {},
_b['is-selected ' + legacyStyles.buttonSelected] =
this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.forceResolve,
_b)),
suggestionsAvailable: Utilities_1.css('ms-Suggestions-
suggestionsAvailable', legacyStyles.suggestionsAvailable),
suggestionsContainer: Utilities_1.css('ms-Suggestions-container',
legacyStyles.suggestionsContainer, suggestionsClassName),
noSuggestions: Utilities_1.css('ms-Suggestions-none',
legacyStyles.suggestionsNone),
};
var spinnerStyles = this._classNames.subComponentStyles
? this._classNames.subComponentStyles.spinner
: undefined;
// TODO: cleanup after refactor of pickers to composition pattern and
remove SASS support.
var spinnerClassNameOrStyles = styles
? { styles: spinnerStyles }
: {
className: Utilities_1.css('ms-Suggestions-spinner',
legacyStyles.suggestionsSpinner),
};
var noResults = function () { return (
// This ID can be used by the parent to set aria-activedescendant to this
React.createElement("div", { id: "sug-noResultsFound", role: "option" },
onRenderNoResultFound ? (onRenderNoResultFound(undefined, noResults)) :
(React.createElement("div", { className: _this._classNames.noSuggestions },
noResultsFoundText)))); };
// MostRecently Used text should supercede the header text if it's there
and available.
var headerText = suggestionsHeaderText;
if (isMostRecentlyUsedVisible && mostRecentlyUsedHeaderText) {
headerText = mostRecentlyUsedHeaderText;
}
var footerTitle = undefined;
if (isResultsFooterVisible) {
footerTitle = suggestions.length >= resultsMaximumNumber ?
resultsFooterFull : resultsFooter;
}
var hasNoSuggestions = (!suggestions || !suggestions.length) && !isLoading;
var forceResolveId = this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.forceResolve ? 'sug-selectedAction' :
undefined;
var searchForMoreId = this.state.selectedActionType ===
Suggestions_types_1.SuggestionActionType.searchMore ? 'sug-selectedAction' :
undefined;
"aria-label": suggestionsContainerAriaLabel || headerText, id: suggestionsListId,
role: "listbox" },
React.createElement(Announced_1.Announced, { message:
this._getAlertText(), "aria-live": "polite" }),
headerText ? React.createElement("div", { className:
this._classNames.title }, headerText) : null,
forceResolveText && this._shouldShowForceResolve() &&
(React.createElement(Button_1.CommandButton, { componentRef:
this._forceResolveButton, className: this._classNames.forceResolveButton, id:
forceResolveId, onClick: this._forceResolve, "data-automationid": 'sug-
forceResolve' }, forceResolveText)),
isLoading && React.createElement(Spinner_1.Spinner,
tslib_1.__assign({}, spinnerClassNameOrStyles, { ariaLabel: loadingText, label:
loadingText })),
hasNoSuggestions ? noResults() : this._renderSuggestions(),
searchForMoreText && moreSuggestionsAvailable &&
(React.createElement(Button_1.CommandButton, { componentRef:
this._searchForMoreButton, className: this._classNames.searchForMoreButton,
iconProps: searchForMoreIcon || { iconName: 'Search' }, id: searchForMoreId,
onClick: this._getMoreResults, "data-automationid": 'sug-searchForMore', role:
'option' }, searchForMoreText)),
isSearching ? React.createElement(Spinner_1.Spinner,
tslib_1.__assign({}, spinnerClassNameOrStyles, { ariaLabel: searchingText, label:
searchingText })) : null,
footerTitle && !moreSuggestionsAvailable && !isMostRecentlyUsedVisible
&& !isSearching ? (React.createElement("div", { className:
this._classNames.title }, footerTitle(this.props))) : null));
};
Suggestions.prototype.hasSuggestedAction = function () {
return !!this._searchForMoreButton.current || !!
this._forceResolveButton.current;
};
Suggestions.prototype.hasSuggestedActionSelected = function () {
return this.state.selectedActionType !==
};
Suggestions.prototype.executeSelectedAction = function () {
switch (this.state.selectedActionType) {
this._forceResolve();
break;
this._getMoreResults();
break;
}
};
Suggestions.prototype.focusAboveSuggestions = function () {
if (this._forceResolveButton.current) {
this.setState({ selectedActionType:
Suggestions_types_1.SuggestionActionType.forceResolve });
}
else if (this._searchForMoreButton.current) {
Suggestions_types_1.SuggestionActionType.searchMore });
}
};
Suggestions.prototype.focusBelowSuggestions = function () {
if (this._searchForMoreButton.current) {
Suggestions_types_1.SuggestionActionType.searchMore });
}
else if (this._forceResolveButton.current) {
Suggestions_types_1.SuggestionActionType.forceResolve });
}
};
Suggestions.prototype.focusSearchForMoreButton = function () {
if (this._searchForMoreButton.current) {
this._searchForMoreButton.current.focus();
}
};
Suggestions.prototype.scrollSelected = function () {
if (this._selectedElement.current &&
this._scrollContainer.current &&
this._scrollContainer.current.scrollTo !== undefined) {
var _a = this._selectedElement.current, offsetHeight = _a.offsetHeight,
offsetTop = _a.offsetTop;
var _b = this._scrollContainer.current, parentOffsetHeight =
_b.offsetHeight, scrollTop = _b.scrollTop;
var isAbove = offsetTop < scrollTop;
var isBelow = offsetTop + offsetHeight > scrollTop +
parentOffsetHeight;
if (isAbove) {
this._scrollContainer.current.scrollTo(0, offsetTop);
}
else if (isBelow) {
this._scrollContainer.current.scrollTo(0, offsetTop -
parentOffsetHeight + offsetHeight);
}
}
};
Suggestions.prototype._renderSuggestions = function () {
var _this = this;
var _a = this.props, onRenderSuggestion = _a.onRenderSuggestion,
removeSuggestionAriaLabel = _a.removeSuggestionAriaLabel, suggestionsItemClassName
= _a.suggestionsItemClassName, resultsMaximumNumber = _a.resultsMaximumNumber,
showRemoveButtons = _a.showRemoveButtons, removeButtonIconProps =
_a.removeButtonIconProps;
var StyledTypedSuggestionsItem = StyledSuggestionsItem;
var selectedIndex = -1;
suggestions.some(function (element, index) {
if (element.selected) {
selectedIndex = index;
return true;
}
return false;
});
if (resultsMaximumNumber) {
suggestions =
selectedIndex >= resultsMaximumNumber
? suggestions.slice(selectedIndex - resultsMaximumNumber + 1,
selectedIndex + 1)
: suggestions.slice(0, resultsMaximumNumber);
}
if (suggestions.length === 0) {
return null;
}
this._classNames.suggestionsContainer, ref: this._scrollContainer, role:
"presentation" }, suggestions.map(function (suggestion, index) { return
(React.createElement("div", { ref: suggestion.selected ? _this._selectedElement :
undefined, key: suggestion.item.key ? suggestion.item.key : index, role:
"presentation" },
React.createElement(StyledTypedSuggestionsItem, { suggestionModel:
suggestion, RenderSuggestion: onRenderSuggestion, onClick:
_this._onClickTypedSuggestionsItem(suggestion.item, index), className:
suggestionsItemClassName, showRemoveButton: showRemoveButtons,
removeButtonAriaLabel: removeSuggestionAriaLabel, onRemoveItem:
_this._onRemoveTypedSuggestionsItem(suggestion.item, index), id: 'sug-' + index,
removeButtonIconProps: removeButtonIconProps }))); })));
};
return Suggestions;
exports.Suggestions = Suggestions;
//# sourceMappingURL=Suggestions.js.map
/***/ }),
/***/ 13493:
"use strict";

exports.suggestionsAvailable = exports.suggestionsSpinner = exports.suggestionsNone
= exports.suggestionsContainer = exports.suggestionsTitle = exports.buttonSelected
= exports.actionButton = exports.itemButton = exports.suggestionsItemIsSuggested =
exports.closeButton = exports.suggestionsItem = exports.root = void 0;
load_themed_styles_1.loadStyles([{ "rawString": ".root_8c91000a{min-
width:260px}.suggestionsItem_8c91000a{display:-webkit-box;display:-ms-
flexbox;display:flex;-webkit-box-align:stretch;-ms-flex-align:stretch;align-
items:stretch;-webkit-box-sizing:border-box;box-sizing:border-
box;width:100%;position:relative;overflow:hidden}.suggestionsItem_8c91000a:hover{ba
ckground:" }, { "theme": "neutralLighter", "defaultValue": "#f3f2f1" },
{ "rawString":
"}.suggestionsItem_8c91000a:hover .closeButton_8c91000a{display:block}.suggestionsI
tem_8c91000a.suggestionsItemIsSuggested_8c91000a{background:" }, { "theme":
"neutralLight", "defaultValue": "#edebe9" }, { "rawString":
"}.suggestionsItem_8c91000a.suggestionsItemIsSuggested_8c91000a:hover{background:"
}, { "theme": "neutralTertiaryAlt", "defaultValue": "#c8c6c4" }, { "rawString":
"}@media screen and (-ms-high-contrast:active),screen and (forced-colors:active)
{.suggestionsItem_8c91000a.suggestionsItemIsSuggested_8c91000a:hover{background:Hig
hlight;color:HighlightText}}@media screen and (-ms-high-contrast:active),screen and
(forced-colors:active)
{.suggestionsItem_8c91000a.suggestionsItemIsSuggested_8c91000a{background:Highlight
;color:HighlightText;-ms-high-contrast-
adjust:none}}.suggestionsItem_8c91000a.suggestionsItemIsSuggested_8c91000a .closeBu
tton_8c91000a:hover{background:" }, { "theme": "neutralTertiary", "defaultValue":
"#a19f9d" }, { "rawString": ";color:" }, { "theme": "neutralPrimary",
"defaultValue": "#323130" }, { "rawString": "}@media screen and (-ms-high-
{.suggestionsItem_8c91000a.suggestionsItemIsSuggested_8c91000a .itemButton_8c91000a
{color:HighlightText}}.suggestionsItem_8c91000a .closeButton_8c91000a{display:none;
color:" }, { "theme": "neutralSecondary", "defaultValue": "#605e5c" },
{ "rawString": "}.suggestionsItem_8c91000a .closeButton_8c91000a:hover{background:"
}, { "theme": "neutralLight", "defaultValue": "#edebe9" }, { "rawString":
"}.actionButton_8c91000a{background-
color:transparent;border:0;cursor:pointer;margin:0;position:relative;border-top:1px
solid " }, { "theme": "neutralLight", "defaultValue": "#edebe9" }, { "rawString":
";height:40px;width:100%;font-size:12px}[dir=ltr] .actionButton_8c91000a{padding-
left:8px}[dir=rtl] .actionButton_8c91000a{padding-
right:8px}html[dir=ltr] .actionButton_8c91000a{text-
align:left}html[dir=rtl] .actionButton_8c91000a{text-
align:right}.actionButton_8c91000a:hover{background-color:" }, { "theme":
"neutralLight", "defaultValue": "#edebe9" }, { "rawString":
";cursor:pointer}.actionButton_8c91000a:active,.actionButton_8c91000a:focus{backgro
und-color:" }, { "theme": "themeLight", "defaultValue": "#c7e0f4" }, { "rawString":
"}.actionButton_8c91000a .ms-Button-icon{font-
size:16px;width:25px}.actionButton_8c91000a .ms-Button-label{margin:0 4px 0
9px}html[dir=rtl] .actionButton_8c91000a .ms-Button-label{margin:0 9px 0
4px}.buttonSelected_8c91000a{background-color:" }, { "theme": "themeLight",
"defaultValue": "#c7e0f4" }, { "rawString": "}.suggestionsTitle_8c91000a{padding:0
12px;color:" }, { "theme": "themePrimary", "defaultValue": "#0078d4" },
{ "rawString": ";font-size:12px;line-height:40px;border-bottom:1px solid " },
{ "theme": "neutralLight", "defaultValue": "#edebe9" }, { "rawString":
"}.suggestionsContainer_8c91000a{overflow-y:auto;overflow-x:hidden;max-
height:300px;border-bottom:1px solid " }, { "theme": "neutralLight",
"defaultValue": "#edebe9" }, { "rawString": "}.suggestionsNone_8c91000a{text-
align:center;color:#797775;font-size:12px;line-
height:30px}.suggestionsSpinner_8c91000a{margin:5px 0;white-space:nowrap;line-
height:20px;font-size:12px}html[dir=ltr] .suggestionsSpinner_8c91000a{padding-
left:14px}html[dir=rtl] .suggestionsSpinner_8c91000a{padding-
right:14px}html[dir=ltr] .suggestionsSpinner_8c91000a{text-align:left}html[dir=rtl]
.suggestionsSpinner_8c91000a{text-align:right}.suggestionsSpinner_8c91000a .ms-
Spinner-circle{display:inline-block;vertical-
align:middle}.suggestionsSpinner_8c91000a .ms-Spinner-label{display:inline-
block;margin:0 10px 0 16px;vertical-
align:middle}html[dir=rtl] .suggestionsSpinner_8c91000a .ms-Spinner-label{margin:0
16px 0 10px}.itemButton_8c91000a.itemButton_8c91000a{width:100%;padding:0;min-
width:0;height:100%}@media screen and (-ms-high-contrast:active),screen and
{.itemButton_8c91000a.itemButton_8c91000a{color:WindowText}}.itemButton_8c91000a.it
emButton_8c91000a:hover{color:" }, { "theme": "neutralDark", "defaultValue":
"#201f1e" }, { "rawString": "}.closeButton_8c91000a.closeButton_8c91000a{padding:0
4px;height:auto;width:32px}@media screen and (-ms-high-contrast:active),screen and
{.closeButton_8c91000a.closeButton_8c91000a{color:WindowText}}.closeButton_8c91000a
.closeButton_8c91000a:hover{background:" }, { "theme": "neutralTertiaryAlt",
"defaultValue": "#c8c6c4" }, { "rawString": ";color:" }, { "theme": "neutralDark",
"defaultValue": "#201f1e" }, { "rawString":
"}.suggestionsAvailable_8c91000a{position:absolute;width:1px;height:1px;padding:0;m
argin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}" }]);
exports.root = "root_8c91000a";
exports.suggestionsItem = "suggestionsItem_8c91000a";
exports.closeButton = "closeButton_8c91000a";
exports.suggestionsItemIsSuggested = "suggestionsItemIsSuggested_8c91000a";
exports.itemButton = "itemButton_8c91000a";
exports.actionButton = "actionButton_8c91000a";
exports.buttonSelected = "buttonSelected_8c91000a";
exports.suggestionsTitle = "suggestionsTitle_8c91000a";
exports.suggestionsContainer = "suggestionsContainer_8c91000a";
exports.suggestionsNone = "suggestionsNone_8c91000a";
exports.suggestionsSpinner = "suggestionsSpinner_8c91000a";
exports.suggestionsAvailable = "suggestionsAvailable_8c91000a";
//# sourceMappingURL=Suggestions.scss.js.map
/***/ }),
/***/ 13110:
"use strict";

root: 'ms-Suggestions',
suggestionsContainer: 'ms-Suggestions-container',
title: 'ms-Suggestions-title',
forceResolveButton: 'ms-forceResolve-button',
searchForMoreButton: 'ms-SearchMore-button',
spinner: 'ms-Suggestions-spinner',
noSuggestions: 'ms-Suggestions-none',
suggestionsAvailable: 'ms-Suggestions-suggestionsAvailable',
};
var _a;
var className = props.className, suggestionsClassName =
props.suggestionsClassName, theme = props.theme, forceResolveButtonSelected =
props.forceResolveButtonSelected, searchForMoreButtonSelected =
props.searchForMoreButtonSelected;
theme.fonts;
var actionButtonStyles = {
border: 0,
cursor: 'pointer',
margin: 0,
paddingLeft: 8,
borderTop: "1px solid " + palette.neutralLight,
height: 40,
textAlign: 'left',
width: '100%',
selectors: {
':hover': {
backgroundColor: semanticColors.menuItemBackgroundPressed,
cursor: 'pointer',
},
':focus, :active': {
},
'.ms-Button-icon': {
width: 25,
},
'.ms-Button-label': {
},
},
};
var actionButtonSelectedStyles = {
tslib_1.__assign({ backgroundColor: 'Highlight', borderColor: 'Highlight', color:
'HighlightText' }, Styling_1.getHighContrastNoAdjustStyle()),
_a),
};
return {
root: [
classNames.root,
{
minWidth: 260,
},
className,
],
suggestionsContainer: [
classNames.suggestionsContainer,
{
overflowY: 'auto',
maxHeight: 300,
transform: 'translate3d(0,0,0)',
},
suggestionsClassName,
],
title: [
classNames.title,
{
padding: '0 12px',
lineHeight: 40,
borderBottom: "1px solid " +
semanticColors.menuItemBackgroundPressed,
},
],
forceResolveButton: [
classNames.forceResolveButton,
actionButtonStyles,
forceResolveButtonSelected && [classNames.isSelected,
actionButtonSelectedStyles],
],
searchForMoreButton: [
classNames.searchForMoreButton,
actionButtonStyles,
searchForMoreButtonSelected && [classNames.isSelected,
actionButtonSelectedStyles],
],
noSuggestions: [
classNames.noSuggestions,
{
lineHeight: 30,
},
],
suggestionsAvailable: [classNames.suggestionsAvailable,
Styling_1.hiddenContentStyle],
spinner: {
root: [
classNames.spinner,
{
margin: '5px 0',
paddingLeft: 14,
textAlign: 'left',
lineHeight: 20,
},
],
circle: {
},
label: {
},
},
},
};
}
//# sourceMappingURL=Suggestions.styles.js.map
/***/ }),
/***/ 37285:
"use strict";

exports.SuggestionActionType = void 0;
/**
* Enum to help identify which suggestions action button is selected.
*/
var SuggestionActionType;
(function (SuggestionActionType) {
/** None of the actions is selected. */
SuggestionActionType[SuggestionActionType["none"] = 0] = "none";
/** ForceResolve action is selected. */
SuggestionActionType[SuggestionActionType["forceResolve"] = 1] =
"forceResolve";
/** SearchMore action is selected. */
SuggestionActionType[SuggestionActionType["searchMore"] = 2] = "searchMore";
})(SuggestionActionType = exports.SuggestionActionType ||
(exports.SuggestionActionType = {}));
//# sourceMappingURL=Suggestions.types.js.map
/***/ }),
/***/ 22651:
"use strict";

exports.SuggestionsController = void 0;
/**
*/
var SuggestionsController = /** @class */ (function () {
function SuggestionsController() {
var _this = this;
this._isSuggestionModel = function (value) {
return value.item !== undefined;
};
this._ensureSuggestionModel = function (suggestion) {
if (_this._isSuggestionModel(suggestion)) {
return suggestion;
}
else {
return {
item: suggestion,
selected: false,
ariaLabel: suggestion.name || suggestion.primaryText,
};
}
};
}
SuggestionsController.prototype.updateSuggestions = function (newSuggestions,
selectedIndex) {
if (newSuggestions && newSuggestions.length > 0) {
this.suggestions =
this.convertSuggestionsToSuggestionItems(newSuggestions);
this.currentIndex = selectedIndex ? selectedIndex : 0;
if (selectedIndex === -1) {
this.currentSuggestion = undefined;
}
else if (selectedIndex !== undefined) {
this.suggestions[selectedIndex].selected = true;
this.currentSuggestion = this.suggestions[selectedIndex];
}
}
else {
this.currentSuggestion = undefined;
}
};
/**
* Increments the suggestion index and gets the next suggestion in the list.
*/
SuggestionsController.prototype.nextSuggestion = function () {
if (this.suggestions && this.suggestions.length) {
if (this.currentIndex < this.suggestions.length - 1) {
this.setSelectedSuggestion(this.currentIndex + 1);
return true;
}
else if (this.currentIndex === this.suggestions.length - 1) {
return true;
}
}
return false;
};
/**
* Decrements the suggestion index and gets the previous suggestion in the
list.
*/
SuggestionsController.prototype.previousSuggestion = function () {
if (this.suggestions && this.suggestions.length) {
if (this.currentIndex > 0) {
this.setSelectedSuggestion(this.currentIndex - 1);
return true;
}
else if (this.currentIndex === 0) {
this.setSelectedSuggestion(this.suggestions.length - 1);
return true;
}
}
return false;
};
SuggestionsController.prototype.getSuggestions = function () {
return this.suggestions;
};
SuggestionsController.prototype.getCurrentItem = function () {
return this.currentSuggestion;
};
SuggestionsController.prototype.getSuggestionAtIndex = function (index) {
return this.suggestions[index];
};
SuggestionsController.prototype.hasSelectedSuggestion = function () {
return this.currentSuggestion ? true : false;
};
SuggestionsController.prototype.removeSuggestion = function (index) {
this.suggestions.splice(index, 1);
};
SuggestionsController.prototype.createGenericSuggestion = function
(itemToConvert) {
var itemToAdd = this.convertSuggestionsToSuggestionItems([itemToConvert])
[0];
this.currentSuggestion = itemToAdd;
};
SuggestionsController.prototype.convertSuggestionsToSuggestionItems = function
(suggestions) {
return Array.isArray(suggestions) ?
suggestions.map(this._ensureSuggestionModel) : [];
};
SuggestionsController.prototype.deselectAllSuggestions = function () {
if (this.currentIndex > -1) {
this.suggestions[this.currentIndex].selected = false;
}
};
SuggestionsController.prototype.setSelectedSuggestion = function (index) {
if (index > this.suggestions.length - 1 || index < 0) {
this.currentIndex = 0;
this.currentSuggestion.selected = false;
this.currentSuggestion = this.suggestions[0];
this.currentSuggestion.selected = true;
}
else {
if (this.currentIndex > -1) {
this.suggestions[this.currentIndex].selected = false;
}
this.suggestions[index].selected = true;
this.currentIndex = index;
this.currentSuggestion = this.suggestions[index];
}
};
return SuggestionsController;
}());
exports.SuggestionsController = SuggestionsController;
//# sourceMappingURL=SuggestionsController.js.map
/***/ }),
/***/ 16571:
"use strict";

exports.SuggestionsItem = void 0;
/**
*/
var SuggestionsItem = /** @class */ (function (_super) {
tslib_1.__extends(SuggestionsItem, _super);
function SuggestionsItem(props) {
return _this;
}
SuggestionsItem.prototype.render = function () {
var _a;
var _b = this.props, suggestionModel = _b.suggestionModel, RenderSuggestion
= _b.RenderSuggestion, onClick = _b.onClick, className = _b.className, id = _b.id,
onRemoveItem = _b.onRemoveItem, isSelectedOverride = _b.isSelectedOverride,
removeButtonAriaLabel = _b.removeButtonAriaLabel, styles = _b.styles, theme =
_b.theme, removeButtonIconProps = _b.removeButtonIconProps;
// TODO
SASS.
// Currently we can not remove the SASS styles from SuggestionsItem class
because it
// might be used by consumers separately from pickers extending from
BasePicker
// and have not used the new 'styles' prop. Because it's expecting a type
parameter,
// we can not use the 'styled' function without adding some helpers which
can break
// downstream consumers who did not use the new helpers.
HOC
// in Suggestions when the typed SuggestionsItem class is ready to be
rendered. If the
// check passes we can use the CSS-in-JS styles. If the check fails (ex:
custom picker),
theme: theme,
suggested: suggestionModel.selected || isSelectedOverride,
})
: {
root: Utilities_1.css('ms-Suggestions-item',
legacyStyles.suggestionsItem, (_a = {},
_a['is-suggested ' + legacyStyles.suggestionsItemIsSuggested] =
suggestionModel.selected || isSelectedOverride,
_a), className),
itemButton: Utilities_1.css('ms-Suggestions-itemButton',
legacyStyles.itemButton),
closeButton: Utilities_1.css('ms-Suggestions-closeButton',
legacyStyles.closeButton),
};
"presentation" },
React.createElement(Button_1.CommandButton, { onClick: onClick,
className: classNames.itemButton, id: id, "aria-selected":
suggestionModel.selected, role: "option", "aria-label":
suggestionModel.ariaLabel }, RenderSuggestion(suggestionModel.item, this.props)),
this.props.showRemoveButton ? (React.createElement(Button_1.IconButton,
{ iconProps: removeButtonIconProps !== null && removeButtonIconProps !== void 0 ?
removeButtonIconProps : { iconName: 'Cancel' }, styles: { icon: { fontSize:
'12px' } }, title: removeButtonAriaLabel, ariaLabel: removeButtonAriaLabel,
onClick: onRemoveItem, className: classNames.closeButton })) : null));
};
return SuggestionsItem;
exports.SuggestionsItem = SuggestionsItem;
//# sourceMappingURL=SuggestionsItem.js.map
/***/ }),
/***/ 40297:
"use strict";

exports.getStyles = exports.SuggestionsItemGlobalClassNames = void 0;
exports.SuggestionsItemGlobalClassNames = {
root: 'ms-Suggestions-item',
itemButton: 'ms-Suggestions-itemButton',
closeButton: 'ms-Suggestions-closeButton',
isSuggested: 'is-suggested',
};
var _a, _b, _c, _d, _e, _f;
var className = props.className, theme = props.theme, suggested =
props.suggested;
var classNames =
Styling_1.getGlobalClassNames(exports.SuggestionsItemGlobalClassNames, theme);
return {
root: [
classNames.root,
{
display: 'flex',
width: '100%',
selectors: {
'&:hover': {
background: semanticColors.menuItemBackgroundHovered,
},
'&:hover .ms-Suggestions-closeButton': {
display: 'block',
},
},
},
suggested && {
_a["." + Utilities_1.IsFocusVisibleClassName + " &"] = {
_b["." + classNames.closeButton] = {
display: 'block',
background:
semanticColors.menuItemBackgroundPressed,
},
_b),
},
_a[':after'] = {
content: '""',
left: 0,
top: 0,
bottom: 0,
right: 0,
border: "1px solid " + theme.semanticColors.focusBorder,
},
_a),
},
className,
],
itemButton: [
classNames.itemButton,
{
width: '100%',
padding: 0,
border: 'none',
height: '100%',
// Force the item button to be collapsible so it can always shrink
// to accommodate the close button as a peer in its flex container.
minWidth: 0,
// Require for IE11 to truncate the component.
overflow: 'hidden',
selectors: {
':hover': tslib_1.__assign({ background: 'Highlight',
color: 'HighlightText' }, Styling_1.getHighContrastNoAdjustStyle()),
},
},
_c[':hover'] = {
},
_c),
},
suggested && [
classNames.isSuggested,
{
background: semanticColors.menuItemBackgroundPressed,
selectors: (_d = {
':hover': {
background: semanticColors.menuDivider,
}
},
tslib_1.__assign({ background: 'Highlight', color: 'HighlightText' },
_d),
},
],
],
closeButton: [
{
display: 'none',
padding: '0 4px',
height: 'auto',
width: 32,
selectors: (_e = {
':hover, :active': {
background: palette.neutralTertiaryAlt,
}
},
},
_e),
},
suggested && (_f = {},
_f["." + Utilities_1.IsFocusVisibleClassName + " &"] = {
selectors: {
background: palette.neutralTertiary,
},
},
},
_f.selectors = {
background: palette.neutralTertiary,
},
},
_f),
],
};
}
//# sourceMappingURL=SuggestionsItem.styles.js.map
/***/ }),
/***/ 52346:
"use strict";

//# sourceMappingURL=SuggestionsItem.types.js.map
/***/ }),
/***/ 85764:
"use strict";

exports.TagItem = exports.TagItemBase = void 0;
var TagItem_styles_1 = __webpack_require__(40234);
/**
* {@docCategory TagPicker}
*/
var TagItemBase = function (props) {
var theme = props.theme, styles = props.styles, selected = props.selected,
disabled = props.disabled, enableTagFocusInDisabledPicker =
props.enableTagFocusInDisabledPicker, children = props.children, className =
props.className, index = props.index, onRemoveItem = props.onRemoveItem,
removeButtonAriaLabel = props.removeButtonAriaLabel, _a = props.title, title = _a
=== void 0 ? typeof props.children === 'string' ? props.children :
props.item.name : _a, removeButtonIconProps = props.removeButtonIconProps;
theme: theme,
selected: selected,
disabled: disabled,
});
var itemId = react_hooks_1.useId();
var disabledAttrs = enableTagFocusInDisabledPicker
? {
'aria-disabled': disabled,
tabindex: 0,
}
: {
disabled: disabled,
};
'listitem', key: index },
React.createElement("span", { className: classNames.text, title: title, id:
itemId + "-text" }, children),
React.createElement(Button_1.IconButton, tslib_1.__assign({ id: itemId,
onClick: onRemoveItem }, disabledAttrs, { iconProps: removeButtonIconProps !== null
&& removeButtonIconProps !== void 0 ? removeButtonIconProps : { iconName:
'Cancel' }, styles: { icon: { fontSize: '12px' } }, className: classNames.close,
ariaLabel: removeButtonAriaLabel, "aria-labelledby": itemId + " " + itemId + "-
text", "data-selection-index": index }))));
};
exports.TagItemBase = TagItemBase;
exports.TagItem = Utilities_1.styled(exports.TagItemBase,
TagItem_styles_1.getStyles, undefined, {
scope: 'TagItem',
});
//# sourceMappingURL=TagItem.js.map
/***/ }),
/***/ 40234:
"use strict";

root: 'ms-TagItem',
text: 'ms-TagItem-text',
close: 'ms-TagItem-close',
};
var TAG_HEIGHT = 26;
var _a, _b, _c, _d;
var className = props.className, theme = props.theme, selected =
props.selected, disabled = props.disabled;
var palette = theme.palette, effects = theme.effects, fonts = theme.fonts,
semanticColors = theme.semanticColors;
return {
root: [
classNames.root,
fonts.medium,
{
flexShrink: '1',
margin: 2,
height: TAG_HEIGHT,
lineHeight: TAG_HEIGHT,
cursor: 'default',
userSelect: 'none',
display: 'flex',
flexWrap: 'nowrap',
maxWidth: 300,
minWidth: 0,
background: palette.neutralLighter,
selectors: (_a = {
':hover': [
!disabled &&
!selected && {
background: palette.neutralLight,
selectors: {
'.ms-TagItem-close': {
},
},
},
disabled && { background: palette.neutralLighter },
],
':focus-within': [
!disabled && {
},
]
},
border: "1px solid " + (!selected ? 'WindowText' :
'WindowFrame'),
},
_a),
},
disabled && {
},
_b),
},
selected && !disabled && [classNames.isSelected],
className,
],
text: [
classNames.text,
{
overflow: 'hidden',
minWidth: 30,
margin: '0 8px',
},
disabled && {
color: 'GrayText',
},
_c),
},
],
close: [
classNames.close,
{
width: 30,
height: '100%',
flex: '0 0 auto',
borderRadius: Utilities_1.getRTL(theme)
? effects.roundedCorner2 + " 0 0 " + effects.roundedCorner2
: "0 " + effects.roundedCorner2 + " " + effects.roundedCorner2
+ " 0",
selectors: {
':hover': {
background: palette.neutralQuaternaryAlt,
},
':focus': {
},
':focus:hover': {
},
':active': {
},
},
},
disabled && {
_d["." +
},
_d),
},
],
};
}
//# sourceMappingURL=TagItem.styles.js.map
/***/ }),
/***/ 64580:
"use strict";

exports.TagItemSuggestion = exports.TagItemSuggestionBase = void 0;
var TagItemSuggestion_styles_1 = __webpack_require__(381);
/**
*/
var TagItemSuggestionBase = function (props) {
var styles = props.styles, theme = props.theme, children = props.children;
theme: theme,
});
classNames.suggestionTextOverflow },
" ",
children,
" ");
};
exports.TagItemSuggestionBase = TagItemSuggestionBase;
exports.TagItemSuggestion = Utilities_1.styled(exports.TagItemSuggestionBase,
TagItemSuggestion_styles_1.getStyles, undefined, { scope: 'TagItemSuggestion' });
//# sourceMappingURL=TagItemSuggestion.js.map
/***/ }),
/***/ 381:
"use strict";

suggestionTextOverflow: 'ms-TagItem-TextOverflow',
};
return {
suggestionTextOverflow: [
classNames.suggestionTextOverflow,
{
overflow: 'hidden',
maxWidth: '60vw',
padding: '6px 12px 7px',
},
className,
],
};
}
//# sourceMappingURL=TagItemSuggestion.styles.js.map
/***/ }),
/***/ 95945:
"use strict";

exports.TagPicker = exports.TagPickerBase = void 0;
var BasePicker_1 = __webpack_require__(79267);
var BasePicker_styles_1 = __webpack_require__(91311);
var TagItem_1 = __webpack_require__(85764);
var TagItemSuggestion_1 = __webpack_require__(64580);
/**
*/
var TagPickerBase = /** @class */ (function (_super) {
tslib_1.__extends(TagPickerBase, _super);
function TagPickerBase(props) {
return _this;
}
TagPickerBase.defaultProps = {
React.createElement(TagItem_1.TagItem, tslib_1.__assign({}, props),
props.item.name); },
onRenderSuggestionsItem: function (props) { return
React.createElement(TagItemSuggestion_1.TagItemSuggestion, null, props.name); },
};
return TagPickerBase;
}(BasePicker_1.BasePicker));
exports.TagPickerBase = TagPickerBase;
exports.TagPicker = Utilities_1.styled(TagPickerBase,
scope: 'TagPicker',
});
//# sourceMappingURL=TagPicker.js.map
/***/ }),
/***/ 23153:
"use strict";

//# sourceMappingURL=TagPicker.types.js.map
/***/ }),
/***/ 43428:
"use strict";

/***/ }),
/***/ 85411:
"use strict";

exports.SharedColors = exports.NeutralColors = exports.MotionAnimations =
exports.MotionTimings = exports.MotionDurations = exports.mergeThemes =
exports.LocalizedFontNames = exports.LocalizedFontFamilies = exports.FluentTheme =
exports.Depths = exports.DefaultSpacing = exports.CommunicationColors = void 0;
// export * from './ChoiceGroupOption'; // exported by ChoiceGroup
// export * from './PersonaPresence'; (Exported as part of Persona)
/**
* Now explicitly declaring Theme exports that are NOT already being exported from
Styles.
* Styles and Theme both exported the same names which causes conflicting
* star exports with webpack5. See here:
https://github.com/microsoft/fluentui/issues/21601.
*/
var Theme_1 = __webpack_require__(36754);
Object.defineProperty(exports, "CommunicationColors", ({ enumerable: true, get:
function () { return Theme_1.CommunicationColors; } }));
() { return Theme_1.DefaultSpacing; } }));
{ return Theme_1.Depths; } }));
{ return Theme_1.FluentTheme; } }));
function () { return Theme_1.LocalizedFontFamilies; } }));
function () { return Theme_1.LocalizedFontNames; } }));
Object.defineProperty(exports, "mergeThemes", ({ enumerable: true, get: function ()
{ return Theme_1.mergeThemes; } }));
Object.defineProperty(exports, "MotionDurations", ({ enumerable: true, get:
function () { return Theme_1.MotionDurations; } }));
Object.defineProperty(exports, "MotionTimings", ({ enumerable: true, get: function
() { return Theme_1.MotionTimings; } }));
Object.defineProperty(exports, "MotionAnimations", ({ enumerable: true, get:
function () { return Theme_1.MotionAnimations; } }));
Object.defineProperty(exports, "NeutralColors", ({ enumerable: true, get: function
() { return Theme_1.NeutralColors; } }));
Object.defineProperty(exports, "SharedColors", ({ enumerable: true, get: function
() { return Theme_1.SharedColors; } }));
/***/ }),
/***/ 97026:
"use strict";

exports.ButtonGridBase = void 0;
exports.ButtonGridBase = React.forwardRef(function (props, forwardedRef) {
var id = react_hooks_1.useId(undefined, props.id);
var items = props.items, columnCount = props.columnCount, onRenderItem =
props.onRenderItem, isSemanticRadio = props.isSemanticRadio,
_a = props.ariaPosInSet,
ariaPosInSet = _a === void 0 ? props.positionInSet : _a,
_b = props.ariaSetSize,
ariaSetSize = _b === void 0 ? props.setSize : _b, styles = props.styles,
doNotContainWithinFocusZone = props.doNotContainWithinFocusZone;
var htmlProps = Utilities_1.getNativeProps(props,
Utilities_1.htmlElementProperties,
// avoid applying onBlur on the table if it's being used in the FocusZone
doNotContainWithinFocusZone ? [] : ['onBlur']);
var classNames = getClassNames(styles, { theme: props.theme });
// Array to store the cells in the correct row index
var rowsOfItems = Utilities_1.toMatrix(items, columnCount);
var content = (React.createElement("table", tslib_1.__assign({ "aria-posinset":
ariaPosInSet, "aria-setsize": ariaSetSize, id: id, role: isSemanticRadio ?
'radiogroup' : 'grid' }, htmlProps, { className: classNames.root }),
React.createElement("tbody", { role: isSemanticRadio ? 'presentation' :
'rowgroup' }, rowsOfItems.map(function (rows, rowIndex) {
return (React.createElement("tr", { role: isSemanticRadio ?
'presentation' : 'row', key: rowIndex }, rows.map(function (cell, cellIndex) {
return (React.createElement("td", { role: "presentation", key:
cellIndex + '-cell', className: classNames.tableCell }, onRenderItem(cell,
cellIndex)));
})));
}))));
return doNotContainWithinFocusZone ? (content) :
(React.createElement(FocusZone_1.FocusZone, { elementRef: forwardedRef,
isCircularNavigation: props.shouldFocusCircularNavigate, className:
classNames.focusedContainer, onBlur: props.onBlur }, content));
});
//# sourceMappingURL=ButtonGrid.base.js.map
/***/ }),
/***/ 90555:
"use strict";

exports.ButtonGrid = void 0;
var ButtonGrid_base_1 = __webpack_require__(97026);
var ButtonGrid_styles_1 = __webpack_require__(8056);
exports.ButtonGrid = Utilities_1.styled(ButtonGrid_base_1.ButtonGridBase,
ButtonGrid_styles_1.getStyles);
exports.ButtonGrid.displayName = 'ButtonGrid';
//# sourceMappingURL=ButtonGrid.js.map
/***/ }),
/***/ 8056:
"use strict";

return {
root: {
padding: 2,
outline: 'none',
},
tableCell: {
padding: 0,
},
};
};
//# sourceMappingURL=ButtonGrid.styles.js.map
/***/ }),
/***/ 23753:
"use strict";

//# sourceMappingURL=ButtonGrid.types.js.map
/***/ }),
/***/ 33477:
"use strict";

exports.ButtonGridCell = void 0;
var ButtonGridCell = function (props) {
var _a;
var defaultId = react_hooks_1.useId('gridCell');
var item = props.item, _b = props.id, id = _b === void 0 ? defaultId : _b,
className = props.className, selected = props.selected, _c = props.disabled,
disabled = _c === void 0 ? false : _c, onRenderItem = props.onRenderItem,
cellDisabledStyle = props.cellDisabledStyle, cellIsSelectedStyle =
props.cellIsSelectedStyle, index = props.index, label = props.label, getClassNames
= props.getClassNames, onClick = props.onClick, onHover = props.onHover,
onMouseMove = props.onMouseMove, onMouseLeave = props.onMouseLeave, onMouseEnter =
props.onMouseEnter, onFocus = props.onFocus;
var buttonProps = Utilities_1.getNativeProps(props,
Utilities_1.buttonProperties);
var handleClick = React.useCallback(function (event) {
if (onClick && !disabled) {
onClick(item, event);
}
}, [disabled, item, onClick]);
var handleMouseEnter = React.useCallback(function (ev) {
var didUpdateOnEnter = onMouseEnter && onMouseEnter(ev);
if (!didUpdateOnEnter && onHover && !disabled) {
onHover(item, ev);
}
}, [disabled, item, onHover, onMouseEnter]);
var handleMouseMove = React.useCallback(function (ev) {
var didUpdateOnMove = onMouseMove && onMouseMove(ev);
if (!didUpdateOnMove && onHover && !disabled) {
onHover(item, ev);
}
}, [disabled, item, onHover, onMouseMove]);
var handleMouseLeave = React.useCallback(function (ev) {
var didUpdateOnLeave = onMouseLeave && onMouseLeave(ev);
if (!didUpdateOnLeave && onHover && !disabled) {
onHover(undefined, ev);
}
}, [disabled, onHover, onMouseLeave]);
var handleFocus = React.useCallback(function (event) {
if (onFocus && !disabled) {
onFocus(item, event);
}
}, [disabled, item, onFocus]);
return (React.createElement(Button_1.CommandButton, tslib_1.__assign({ id: id,
"data-index": index, "data-is-focusable": true, "aria-selected": selected,
ariaLabel: label, title: label }, buttonProps, { className:
Utilities_1.css(className, (_a = {},
_a['' + cellIsSelectedStyle] = selected,
_a['' + cellDisabledStyle] = disabled,
_a)), onClick: handleClick, onMouseEnter: handleMouseEnter,
onMouseMove: handleMouseMove, onMouseLeave: handleMouseLeave, onFocus: handleFocus,
getClassNames: getClassNames }), onRenderItem(item)));
};
exports.ButtonGridCell = ButtonGridCell;
//# sourceMappingURL=ButtonGridCell.js.map
/***/ }),
/***/ 96756:
"use strict";

//# sourceMappingURL=ButtonGridCell.types.js.map
/***/ }),
/***/ 9193:
"use strict";

/***/ }),
/***/ 6487:
"use strict";

exports.DraggableZone = void 0;
var DraggableZone_styles_1 = __webpack_require__(3371);
var eventMapping = {
touch: {
start: 'touchstart',
move: 'touchmove',
stop: 'touchend',
},
mouse: {
start: 'mousedown',
move: 'mousemove',
stop: 'mouseup',
},
};
var DraggableZone = /** @class */ (function (_super) {
tslib_1.__extends(DraggableZone, _super);
function DraggableZone(props) {
_this._currentEventType = eventMapping.mouse;
_this._events = [];
_this._onMouseDown = function (event) {
var onMouseDown =
React.Children.only(_this.props.children).props.onMouseDown;
if (onMouseDown) {
onMouseDown(event);
}
return _this._onDragStart(event);
};
_this._onMouseUp = function (event) {
var onMouseUp =
React.Children.only(_this.props.children).props.onMouseUp;
if (onMouseUp) {
onMouseUp(event);
}
return _this._onDragStop(event);
};
_this._onTouchStart = function (event) {
var onTouchStart =
React.Children.only(_this.props.children).props.onTouchStart;
if (onTouchStart) {
onTouchStart(event);
}
_this._currentEventType = eventMapping.touch;
return _this._onDragStart(event);
};
_this._onTouchEnd = function (event) {
var onTouchEnd =
React.Children.only(_this.props.children).props.onTouchEnd;
if (onTouchEnd) {
onTouchEnd(event);
}
_this._currentEventType = eventMapping.touch;
_this._onDragStop(event);
};
_this._onDragStart = function (event) {
// Only handle left click for dragging
if (typeof event.button === 'number' && event.button !== 0) {
return false;
}
// If the target doesn't match the handleSelector OR
// if the target does match the preventDragSelector, bail out
if ((_this.props.handleSelector && !
_this._matchesSelector(event.target, _this.props.handleSelector)) ||
(_this.props.preventDragSelector &&
_this._matchesSelector(event.target,
_this.props.preventDragSelector))) {
return;
}
// Remember the touch identifier if this is a touch event so we can
// distinguish between individual touches in multitouch scenarios
// by remembering which touch point we were given
_this._touchId = _this._getTouchId(event);
var position = _this._getControlPosition(event);
if (position === undefined) {
return;
}
var dragData = _this._createDragDataFromPosition(position);
_this.props.onStart && _this.props.onStart(event, dragData);
_this.setState({
isDragging: true,
lastPosition: position,
});
// hook up the appropriate mouse/touch events to the body to ensure
// smooth dragging
_this._events = [
Utilities_1.on(document.body, _this._currentEventType.move,
_this._onDrag, true /* use capture phase */),
Utilities_1.on(document.body, _this._currentEventType.stop,
_this._onDragStop, true /* use capture phase */),
];
};
_this._onDrag = function (event) {
// Prevent scrolling on mobile devices
if (event.type === 'touchmove') {
}
if (!position) {
return;
}
// create the updated drag data from the position data
var updatedData =
_this._createUpdatedDragData(_this._createDragDataFromPosition(position));
var updatedPosition = updatedData.position;
_this.props.onDragChange && _this.props.onDragChange(event,
updatedData);
_this.setState({
position: updatedPosition,
});
};
_this._onDragStop = function (event) {
if (!_this.state.isDragging) {
return;
}
if (!position) {
return;
}
var baseDragData = _this._createDragDataFromPosition(position);
// Set dragging to false and reset the lastPosition
_this.setState({
isDragging: false,
lastPosition: undefined,
});
_this.props.onStop && _this.props.onStop(event, baseDragData);
if (_this.props.position) {
_this.setState({
position: _this.props.position,
});
}
// Remove event handlers
_this._events.forEach(function (dispose) { return dispose(); });
};
_this.state = {
isDragging: false,
position: _this.props.position || { x: 0, y: 0 },
lastPosition: undefined,
};
return _this;
}
DraggableZone.prototype.componentDidUpdate = function (prevProps) {
if (this.props.position && (!prevProps.position || this.props.position !==
prevProps.position)) {
this.setState({ position: this.props.position });
}
};
DraggableZone.prototype.componentWillUnmount = function () {
this._events.forEach(function (dispose) { return dispose(); });
};
DraggableZone.prototype.render = function () {
var child = React.Children.only(this.props.children);
var props = child.props;
var position = this.props.position;
var _a = this.state, statePosition = _a.position, isDragging =
_a.isDragging;
var x = statePosition.x;
var y = statePosition.y;
if (position && !isDragging) {
x = position.x;
y = position.y;
}
return React.cloneElement(child, {
style: tslib_1.__assign(tslib_1.__assign({}, props.style), { transform:
"translate(" + x + "px, " + y + "px)" }),
className: DraggableZone_styles_1.getClassNames(props.className,
this.state.isDragging).root,
onMouseDown: this._onMouseDown,
onMouseUp: this._onMouseUp,
onTouchStart: this._onTouchStart,
onTouchEnd: this._onTouchEnd,
});
};
/**
* Get the control position based off the event that fired
* @param event - The event to get offsets from
*/
DraggableZone.prototype._getControlPosition = function (event) {
var touchObj = this._getActiveTouch(event);
// did we get the right touch?
if (this._touchId !== undefined && !touchObj) {
return undefined;
}
var eventToGetOffset = touchObj || event;
return {
x: eventToGetOffset.clientX,
y: eventToGetOffset.clientY,
};
};
/**
* Get the active touch point that we have saved from the event's TouchList
* @param event - The event used to get the TouchList for the active touch
point
*/
DraggableZone.prototype._getActiveTouch = function (event) {
return ((event.targetTouches &&
this._findTouchInTouchList(event.targetTouches)) ||
(event.changedTouches &&
this._findTouchInTouchList(event.changedTouches)));
};
/**
* Get the initial touch identifier associated with the given event
* @param event - The event that contains the TouchList
*/
DraggableZone.prototype._getTouchId = function (event) {
var touch = (event.targetTouches && event.targetTouches[0]) ||
(event.changedTouches && event.changedTouches[0]);
if (touch) {
return touch.identifier;
}
};
/**
* Returns if an element (or any of the element's parents) match the given
selector
*/
DraggableZone.prototype._matchesSelector = function (element, selector) {
if (!element || element === document.body) {
return false;
}
var matchesSelectorFn = element.matches || element.webkitMatchesSelector ||
element.msMatchesSelector; /* for IE */
if (!matchesSelectorFn) {
return false;
}
return matchesSelectorFn.call(element, selector) ||
this._matchesSelector(element.parentElement, selector);
};
/**
* Attempts to find the Touch that matches the identifier we stored in
dragStart
* @param touchList The TouchList to look for the stored identifier from
dragStart
*/
DraggableZone.prototype._findTouchInTouchList = function (touchList) {
if (this._touchId === undefined) {
return;
}
for (var i = 0; i < touchList.length; i++) {
if (touchList[i].identifier === this._touchId) {
return touchList[i];
}
}
return undefined;
};
/**
* Create DragData based off of the last known position and the new position
passed in
* @param position The new position as part of the drag
*/
DraggableZone.prototype._createDragDataFromPosition = function (position) {
var lastPosition = this.state.lastPosition;
// If we have no lastPosition, use the given position
// for last position
if (lastPosition === undefined) {
return {
delta: { x: 0, y: 0 },
position: position,
};
}
return {
delta: {
x: position.x - lastPosition.x,
y: position.y - lastPosition.y,
},
lastPosition: lastPosition,
position: position,
};
};
/**
* Creates an updated DragData based off the current position and given
baseDragData
* @param baseDragData The base DragData (from _createDragDataFromPosition)
used to calculate the updated positions
*/
DraggableZone.prototype._createUpdatedDragData = function (baseDragData) {
var position = this.state.position;
return {
position: {
x: position.x + baseDragData.delta.x,
y: position.y + baseDragData.delta.y,
},
delta: baseDragData.delta,
};
};
return DraggableZone;
exports.DraggableZone = DraggableZone;
//# sourceMappingURL=DraggableZone.js.map
/***/ }),
/***/ 3371:
"use strict";

exports.getClassNames = Utilities_1.memoizeFunction(function (className,
isDragging) {
return {
root: Styling_1.mergeStyles(className, isDragging && {
touchAction: 'none',
selectors: {
'& *': {
userSelect: 'none',
},
},
}),
};
});
//# sourceMappingURL=DraggableZone.styles.js.map
/***/ }),
/***/ 35969:
"use strict";

//# sourceMappingURL=DraggableZone.types.js.map
/***/ }),
/***/ 87177:
"use strict";

/***/ }),
/***/ 18814:
"use strict";

exports.useMenuContext = exports.MenuContext = void 0;
exports.MenuContext = React.createContext({});
var useMenuContext = function () {
return React.useContext(exports.MenuContext);
};
exports.useMenuContext = useMenuContext;
//# sourceMappingURL=MenuContext.js.map
/***/ }),
/***/ 88842:
"use strict";

/***/ }),
/***/ 44615:
"use strict";

//# sourceMappingURL=types.js.map
/***/ }),
/***/ 22008:
"use strict";

exports.ThemeContext = void 0;
exports.ThemeContext = React.createContext(undefined);
//# sourceMappingURL=ThemeContext.js.map
/***/ }),
/***/ 64968:
"use strict";

exports.ThemeProvider = void 0;
var useThemeProviderClasses_1 = __webpack_require__(87536);
var useThemeProvider_1 = __webpack_require__(79115);
/**
* ThemeProvider, used for providing css variables and registering stylesheets.
*/
exports.ThemeProvider = React.forwardRef(function (props, ref) {
var rootRef = react_hooks_1.useMergedRefs(ref, React.useRef(null));
var _a = useThemeProvider_1.useThemeProvider(props, {
ref: rootRef,
as: 'div',
applyTo: 'element',
}), render = _a.render, state = _a.state;
// Render styles.
useThemeProviderClasses_1.useThemeProviderClasses(state);
// Apply focus rect class on key presses.
utilities_1.useFocusRects(state.ref);
// Return the rendered content.
return render(state);
});
exports.ThemeProvider.displayName = 'ThemeProvider';
//# sourceMappingURL=ThemeProvider.js.map
/***/ }),
/***/ 43906:
"use strict";
exports.ThemeContext = exports.useTheme = exports.ThemeProvider = void 0;
var ThemeProvider_1 = __webpack_require__(64968);
Object.defineProperty(exports, "ThemeProvider", ({ enumerable: true, get: function
() { return ThemeProvider_1.ThemeProvider; } }));
var useTheme_1 = __webpack_require__(61412);
Object.defineProperty(exports, "useTheme", ({ enumerable: true, get: function ()
{ return useTheme_1.useTheme; } }));
var ThemeContext_1 = __webpack_require__(22008);
Object.defineProperty(exports, "ThemeContext", ({ enumerable: true, get: function
() { return ThemeContext_1.ThemeContext; } }));
/***/ }),
/***/ 83295:
"use strict";

exports.makeStyles = void 0;
var mergeStylesRenderer_1 = __webpack_require__(7785);
var graphGet = function (graphNode, _a) {
var _b, _c, _d;
var windowId = _a[0], id = _a[1], theme = _a[2];
return (_d = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ?
void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme)) === null
|| _d === void 0 ? void 0 : _d.classMap;
};
var graphSet = function (graphNode, _a, classMap) {
var _b, _c;
var windowNode = (_b = graphNode.get(windowId)) !== null && _b !== void 0 ?
_b : new Map();
graphNode.set(windowId, windowNode);
var idNode = (_c = windowNode.get(id)) !== null && _c !== void 0 ? _c : new
Map();
windowNode.set(id, idNode);
idNode.set(theme, { classMap: classMap, refCount: 0 });
};
function graphRef(graphNode, _a) {
var _b, _c;
var node = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ?
void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme);
if (node) {
node.refCount++;
}
}
function graphDeref(graphNode, _a) {
var _b, _c, _d, _e, _f, _g, _h, _j;
var node = (_c = (_b = graphNode.get(windowId)) === null || _b === void 0 ?
void 0 : _b.get(id)) === null || _c === void 0 ? void 0 : _c.get(theme);
if (node) {
node.refCount--;
if (node.refCount === 0) {
(_e = (_d = graphNode.get(windowId)) === null || _d === void 0 ? void 0
: _d.get(id)) === null || _e === void 0 ? void 0 : _e.delete(theme);
if (((_g = (_f = graphNode.get(windowId)) === null || _f === void 0 ?
void 0 : _f.get(id)) === null || _g === void 0 ? void 0 : _g.size) === 0) {
(_h = graphNode.get(windowId)) === null || _h === void 0 ? void 0 :
_h.delete(id);
if (((_j = graphNode.get(windowId)) === null || _j === void 0 ?
void 0 : _j.size) === 0) {
graphNode.delete(windowId);
}
}
}
}
}
/**
* Registers a css object, optionally as a function of the theme.
*
* @param styleOrFunction - Either a css javascript object, or a function which
takes in ÌTheme`
* and returns a css javascript object.
*
* @deprecated Use `mergeStyles` instead for v8 related code. We will be using a
new implementation of `makeStyles` in
* future versions of the library.
*/
function makeStyles(styleOrFunction) {
// Create graph of inputs to map to output.
var graph = new Map();
// Retain a dictionary of window ids we're tracking
var allWindows = new Set();
// cleanupMapEntries will
// 1. remove all the graph branches for the window,
// 2. remove the event listener,
// 3. delete the allWindows entry.
var cleanupMapEntries = function (ev) {
var win = ev.currentTarget;
var winId = win.__id__;
graph.delete(winId);
win.removeEventListener('unload', cleanupMapEntries);
allWindows.delete(winId);
};
return function (options) {
var theme = options.theme;
var winId;
if (win) {
win.__id__ = win.__id__ || utilities_1.getId();
winId = win.__id__;
if (!allWindows.has(winId)) {
allWindows.add(winId);
win.addEventListener('unload', cleanupMapEntries);
}
}
var contextualTheme = useTheme_1.useTheme();
theme = theme || contextualTheme;
var renderer = mergeStylesRenderer_1.mergeStylesRenderer;
var id = renderer.getId();
var path = [winId, id, theme];
var value = graphGet(graph, path);
// Don't keep around unused styles
react_1.useEffect(function () {
graphRef(graph, [winId, id, theme]);
return function () { return graphDeref(graph, [winId, id, theme]); };
}, [winId, id, theme]);
if (!value) {
var styles = isStyleFunction(styleOrFunction)
? styleOrFunction(theme)
: styleOrFunction;
value = mergeStylesRenderer_1.mergeStylesRenderer.renderStyles(styles,
{ targetWindow: win, rtl: !!theme.rtl });
graphSet(graph, path, value);
}
return value;
};
}
exports.makeStyles = makeStyles;
function isStyleFunction(styleOrFunction) {
return typeof styleOrFunction === 'function';
}
//# sourceMappingURL=makeStyles.js.map
/***/ }),
/***/ 91590:
"use strict";

exports.renderThemeProvider = void 0;
var renderThemeProvider = function (state) {
var theme = state.theme, customizerContext = state.customizerContext;
var Root = state.as || 'div';
var rootProps = typeof state.as === 'string' ?
utilities_1.getNativeElementProps(state.as, state) : utilities_1.omit(state,
['as']);
return (React.createElement(ThemeContext_1.ThemeContext.Provider, { value:
theme },
React.createElement(utilities_1.CustomizerContext.Provider, { value:
customizerContext },
React.createElement(Root, tslib_1.__assign({}, rootProps)))));
};
exports.renderThemeProvider = renderThemeProvider;
//# sourceMappingURL=renderThemeProvider.js.map
/***/ }),
/***/ 7785:
"use strict";

exports.mergeStylesRenderer = void 0;
var _seed = 0;
exports.mergeStylesRenderer = {
reset: function () {
// If the stylesheet reset call is made, invalidate the cache keys.
merge_styles_1.Stylesheet.getInstance().onReset(function () { return _seed+
+; });
},
getId: function () { return _seed; },
renderStyles: function (styleSet, options) {
return merge_styles_1.mergeCssSets((Array.isArray(styleSet) ? styleSet :
[styleSet]), options);
},
renderFontFace: function (fontFace, options) {
return merge_styles_1.fontFace(fontFace);
},
renderKeyframes: function (keyframes) {
return merge_styles_1.keyframes(keyframes);
},
};
//# sourceMappingURL=mergeStylesRenderer.js.map
/***/ }),
/***/ 61412:
"use strict";

exports.useTheme = void 0;
/**
* Get theme from CustomizerContext or Customizations singleton.
*/
function useCompatTheme() {
return utilities_1.useCustomizationSettings(['theme']).theme;
}
/**
* React hook for programmatically accessing the theme.
*/
var useTheme = function () {
var theme = react_1.useContext(ThemeContext_1.ThemeContext);
var legacyTheme = useCompatTheme();
return theme || legacyTheme || theme_1.createTheme({});
};
exports.useTheme = useTheme;
//# sourceMappingURL=useTheme.js.map
/***/ }),
/***/ 79115:
"use strict";

exports.useThemeProvider = void 0;
var renderThemeProvider_1 = __webpack_require__(91590);
var useThemeProviderState_1 = __webpack_require__(2943);
/**
* Returns the ThemeProvider render function and calculated state, given user
input, ref, and
* a set of default prop values.
*/
var useThemeProvider = function (props, defaultProps) {
var state = utilities_1.getPropsWithDefaults(defaultProps, props);
// Apply changes to state.
useThemeProviderState_1.useThemeProviderState(state);
return {
state: state,
render: renderThemeProvider_1.renderThemeProvider,
};
};
exports.useThemeProvider = useThemeProvider;
//# sourceMappingURL=useThemeProvider.js.map
/***/ }),
/***/ 87536:
"use strict";

exports.useThemeProviderClasses = void 0;
var makeStyles_1 = __webpack_require__(83295);
var useThemeProviderStyles = makeStyles_1.makeStyles(function (theme) {
return {
body: [
{
background: semanticColors.bodyBackground,
fontFamily: fonts.medium.fontFamily,
fontWeight: fonts.medium.fontWeight,
MozOsxFontSmoothing: fonts.medium.MozOsxFontSmoothing,
WebkitFontSmoothing: fonts.medium.WebkitFontSmoothing,
},
],
};
});
/**
* Hook to add class to body element.
*/
function useApplyClassToBody(state, classesToApply) {
var _a;
var applyTo = state.applyTo;
var applyToBody = applyTo === 'body';
var body = (_a = react_window_provider_1.useDocument()) === null || _a === void
0 ? void 0 : _a.body;
if (!applyToBody || !body) {
return;
}
for (var _i = 0, classesToApply_1 = classesToApply; _i <
classesToApply_1.length; _i++) {
var classToApply = classesToApply_1[_i];
if (classToApply) {
body.classList.add(classToApply);
}
}
if (!applyToBody || !body) {
return;
}
for (var _i = 0, classesToApply_2 = classesToApply; _i <
classesToApply_2.length; _i++) {
var classToApply = classesToApply_2[_i];
if (classToApply) {
body.classList.remove(classToApply);
}
}
};
}, [applyToBody, body, classesToApply]);
}
function useThemeProviderClasses(state) {
var classes = useThemeProviderStyles(state);
var className = state.className, applyTo = state.applyTo;
useApplyClassToBody(state, [classes.root, classes.body]);
state.className = utilities_1.css(className, classes.root, applyTo ===
'element' && classes.body);
}
exports.useThemeProviderClasses = useThemeProviderClasses;
//# sourceMappingURL=useThemeProviderClasses.js.map
/***/ }),
/***/ 2943:
"use strict";

exports.useThemeProviderState = void 0;
var themeToIdMap = new Map();
var getThemeId = function () {
var themes = [];
themes[_i] = arguments[_i];
}
var ids = [];
for (var _a = 0, themes_1 = themes; _a < themes_1.length; _a++) {
var theme = themes_1[_a];
if (theme) {
var id = theme.id || themeToIdMap.get(theme);
if (!id) {
id = utilities_1.getId('');
themeToIdMap.set(theme, id);
}
ids.push(id);
}
}
return ids.join('-');
};
var useThemeProviderState = function (draftState) {
var userTheme = draftState.theme;
// Pull contextual theme.
var parentTheme = useTheme_1.useTheme();
// Update the incoming theme with a memoized version of the merged theme.
var theme = (draftState.theme = React.useMemo(function () {
var mergedTheme = theme_1.mergeThemes(parentTheme, userTheme);
mergedTheme.id = getThemeId(parentTheme, userTheme);
return mergedTheme;
}, [parentTheme, userTheme]));
draftState.customizerContext = React.useMemo(function () { return ({
customizations: {
inCustomizerContext: true,
settings: { theme: theme },
scopedSettings: theme.components || {},
},
}); }, [theme]);
if (draftState.theme.rtl !== parentTheme.rtl) {
draftState.dir = draftState.theme.rtl ? 'rtl' : 'ltr';
}
};
exports.useThemeProviderState = useThemeProviderState;
//# sourceMappingURL=useThemeProviderState.js.map
/***/ }),
/***/ 50050:
"use strict";

exports._rgbaOrHexString = void 0;
/**
* @internal
* Get a CSS color string from some color components.
* If à` is specified and not 100, returns an `rgba()` string.
* Otherwise returns `hex` prefixed with #.
*/
function _rgbaOrHexString(r, g, b, a, hex) {
return a === consts_1.MAX_COLOR_ALPHA || typeof a !== 'number' ? "#" + hex :
"rgba(" + r + ", " + g + ", " + b + ", " + a / consts_1.MAX_COLOR_ALPHA + ")";
}
exports._rgbaOrHexString = _rgbaOrHexString;
//# sourceMappingURL=_rgbaOrHexString.js.map
/***/ }),
/***/ 96033:
"use strict";

exports.clamp = void 0;
/** Clamp a value to ensure it falls within a given range. */
function clamp(value, max, min) {
if (min === void 0) { min = 0; }
return value < min ? min : value > max ? max : value;
}
exports.clamp = clamp;
//# sourceMappingURL=clamp.js.map
/***/ }),
/***/ 71783:
"use strict";

//# sourceMappingURL=colors.js.map
/***/ }),
/***/ 79376:
"use strict";

exports.RGBA_REGEX = exports.HEX_REGEX = exports.MAX_RGBA_LENGTH =
exports.MIN_RGBA_LENGTH = exports.MAX_HEX_LENGTH = exports.MIN_HEX_LENGTH =
exports.MAX_COLOR_ALPHA = exports.MAX_COLOR_RGBA = exports.MAX_COLOR_RGB =
exports.MAX_COLOR_VALUE = exports.MAX_COLOR_HUE = exports.MAX_COLOR_SATURATION =
void 0;
exports.MAX_COLOR_SATURATION = 100;
exports.MAX_COLOR_HUE = 359;
exports.MAX_COLOR_VALUE = 100;
exports.MAX_COLOR_RGB = 255;
/** @deprecated Use MAX_COLOR_RGB (255) or MAX_COLOR_ALPHA (100) */
exports.MAX_COLOR_RGBA = exports.MAX_COLOR_RGB;
exports.MAX_COLOR_ALPHA = 100;
/** Minimum length for a hexadecimal color string (not including the #) */
exports.MIN_HEX_LENGTH = 3;
/** Maximum length for a hexadecimal color string (not including the #) */
exports.MAX_HEX_LENGTH = 6;
/** Minimum length for a string of an RGBA color component */
exports.MIN_RGBA_LENGTH = 1;
/** Maximum length for a string of an RGBA color component */
exports.MAX_RGBA_LENGTH = 3;
/** Regular expression matching only valid hexadecimal chars */
exports.HEX_REGEX = /^[\da-f]{0,6}$/i;
/** Regular expression matching only numbers */
exports.RGBA_REGEX = /^\d{0,3}$/;
//# sourceMappingURL=consts.js.map
/***/ }),
/***/ 83178:
"use strict";

exports.correctHSV = void 0;
/** Corrects an HSV color to fall within the valid range. */
function correctHSV(color) {
return {
h: clamp_1.clamp(color.h, consts_1.MAX_COLOR_HUE),
s: clamp_1.clamp(color.s, consts_1.MAX_COLOR_SATURATION),
v: clamp_1.clamp(color.v, consts_1.MAX_COLOR_VALUE),
};
}
exports.correctHSV = correctHSV;
//# sourceMappingURL=correctHSV.js.map
/***/ }),
/***/ 93507:
"use strict";
exports.correctHex = void 0;
/**
* Corrects a hex color to have length 3 or 6. Defaults to white if too short.
* Does NOT check anything besides the length (such as valid characters) and does
NOT handle
* hex values starting with # sign.
*/
function correctHex(hex) {
if (!hex || hex.length < consts_1.MIN_HEX_LENGTH) {
return 'ffffff'; // not a valid color--default to white
}
if (hex.length >= consts_1.MAX_HEX_LENGTH) {
return hex.substring(0, consts_1.MAX_HEX_LENGTH);
}
return hex.substring(0, consts_1.MIN_HEX_LENGTH);
}
exports.correctHex = correctHex;
//# sourceMappingURL=correctHex.js.map
/***/ }),
/***/ 20356:
"use strict";

exports.correctRGB = void 0;
/** Corrects an RGB color to fall within the valid range. */
function correctRGB(color) {
return {
r: clamp_1.clamp(color.r, consts_1.MAX_COLOR_RGB),
g: clamp_1.clamp(color.g, consts_1.MAX_COLOR_RGB),
b: clamp_1.clamp(color.b, consts_1.MAX_COLOR_RGB),
a: typeof color.a === 'number' ? clamp_1.clamp(color.a,
consts_1.MAX_COLOR_ALPHA) : color.a,
};
}
exports.correctRGB = correctRGB;
//# sourceMappingURL=correctRGB.js.map
/***/ }),
/***/ 15893:
"use strict";

exports.cssColor = void 0;
var hsl2rgb_1 = __webpack_require__(32853);
/**
* Converts a valid CSS color string to an RGB color.
* Note that hex colors *must* be prefixed with # to be considered valid.
* Alpha in returned color defaults to 100.
* Four and eight digit hex values (with alpha) are supported if the current
browser supports them.
*/
function cssColor(color) {
if (!color) {
return undefined;
}
// Need to check the following valid color formats: RGB(A), HSL(A), hex, named
color
// First check for well formatted RGB(A), HSL(A), and hex formats at the start.
// This is for perf (no creating an element) and catches the intentional
"transparent" color
// case early on.
var easyColor = _rgba(color) || _hex6(color) || _hex3(color) || _hsla(color);
if (easyColor) {
return easyColor;
}
// if the above fails, do the more expensive catch-all
return _browserCompute(color);
}
exports.cssColor = cssColor;
/**
* Uses the browser's getComputedStyle() to determine what the passed-in color is.
* This assumes _rgba, _hex6, _hex3, and _hsla have already been tried and all
failed.
* This works by attaching an element to the DOM, which may fail in server-side
rendering
* or with headless browsers.
*/
function _browserCompute(str) {
if (typeof document === 'undefined') {
// don't throw an error when used server-side
return undefined;
}
var elem = document.createElement('div');
elem.style.backgroundColor = str;
// This element must be attached to the DOM for getComputedStyle() to have a
value
elem.style.position = 'absolute';
elem.style.top = '-9999px';
elem.style.left = '-9999px';
elem.style.height = '1px';
elem.style.width = '1px';
document.body.appendChild(elem);
var eComputedStyle = getComputedStyle(elem);
var computedColor = eComputedStyle && eComputedStyle.backgroundColor;
document.body.removeChild(elem);
// computedColor is always an RGB(A) string, except for invalid colors in
IE/Edge which return 'transparent'
// browsers return one of these if the color string is invalid,
// so need to differentiate between an actual error and intentionally passing
in this color
if (computedColor === 'rgba(0, 0, 0, 0)' || computedColor === 'transparent') {
switch (str.trim()) {
// RGB and HSL were already checked at the start of the function
case 'transparent':
case '#0000':
case '#00000000':
return { r: 0, g: 0, b: 0, a: 0 };
}
return undefined;
}
return _rgba(computedColor);
}
/**
* If `str` is in valid `rgb()` or `rgba()` format, returns an RGB color (alpha
defaults to 100).
* Otherwise returns undefined.
*/
function _rgba(str) {
if (!str) {
return undefined;
}
var match = str.match(/^rgb(a?)$([\d., ]+)$$/);
if (match) {
var hasAlpha = !!match[1];
var expectedPartCount = hasAlpha ? 4 : 3;
var parts = match[2].split(/ *, */).map(Number);
if (parts.length === expectedPartCount) {
return {
r: parts[0],
g: parts[1],
b: parts[2],
a: hasAlpha ? parts[3] * 100 : consts_1.MAX_COLOR_ALPHA,
};
}
}
}
/**
* If `str` is in `hsl()` or `hsla()` format, returns an RGB color (alpha defaults
to 100).
*/
function _hsla(str) {
var match = str.match(/^hsl(a?)$([\d., ]+)$$/);
if (match) {
var hasAlpha = !!match[1];
var expectedPartCount = hasAlpha ? 4 : 3;
var parts = match[2].split(/ *, */).map(Number);
if (parts.length === expectedPartCount) {
var rgba = hsl2rgb_1.hsl2rgb(parts[0], parts[1], parts[2]);
rgba.a = hasAlpha ? parts[3] * 100 : consts_1.MAX_COLOR_ALPHA;
return rgba;
}
}
}
/**
* If `str` is in valid 6-digit hex format *with* # prefix, returns an RGB color
(with alpha 100).
*/
function _hex6(str) {
if (str[0] === '#' && str.length === 7 && /^#[\da-fA-F]{6}$/.test(str)) {
return {
r: parseInt(str.slice(1, 3), 16),
g: parseInt(str.slice(3, 5), 16),
b: parseInt(str.slice(5, 7), 16),
a: consts_1.MAX_COLOR_ALPHA,
};
}
}
/**
* If `str` is in valid 3-digit hex format *with* # prefix, returns an RGB color
(with alpha 100).
*/
function _hex3(str) {
if (str[0] === '#' && str.length === 4 && /^#[\da-fA-F]{3}$/.test(str)) {
return {
r: parseInt(str[1] + str[1], 16),
g: parseInt(str[2] + str[2], 16),
b: parseInt(str[3] + str[3], 16),
a: consts_1.MAX_COLOR_ALPHA,
};
}
}
//# sourceMappingURL=cssColor.js.map
/***/ }),
/***/ 67988:
"use strict";

exports.getColorFromHSV = void 0;
var hsv2rgb_1 = __webpack_require__(41506);
var hsv2hex_1 = __webpack_require__(80566);
var _rgbaOrHexString_1 = __webpack_require__(50050);
/**
* Converts an HSV color (and optional alpha value) to a color object.
* If à` is not given, a default of 100 is used.
* Hex in the returned value will *not* be prefixed with #.
* If à` is unspecified or 100, the result's `str` property will contain a hex
value
* (*not* prefixed with #)
*/
function getColorFromHSV(hsv, a) {
var h = hsv.h, s = hsv.s, v = hsv.v;
a = typeof a === 'number' ? a : consts_1.MAX_COLOR_ALPHA;
var _a = hsv2rgb_1.hsv2rgb(h, s, v), r = _a.r, g = _a.g, b = _a.b;
var hex = hsv2hex_1.hsv2hex(h, s, v);
var str = _rgbaOrHexString_1._rgbaOrHexString(r, g, b, a, hex);
var t = consts_1.MAX_COLOR_ALPHA - a;
return { a: a, b: b, g: g, h: h, hex: hex, r: r, s: s, str: str, v: v, t: t };
}
exports.getColorFromHSV = getColorFromHSV;
//# sourceMappingURL=getColorFromHSV.js.map
/***/ }),
/***/ 46868:
"use strict";

exports.getColorFromRGBA = void 0;
var rgb2hsv_1 = __webpack_require__(51375);
var rgb2hex_1 = __webpack_require__(2542);
/** Converts an RGBA color to a color object (alpha defaults to 100). */
function getColorFromRGBA(rgba) {
var _a = rgba.a, a = _a === void 0 ? consts_1.MAX_COLOR_ALPHA : _a, b = rgba.b,
g = rgba.g, r = rgba.r;
var _b = rgb2hsv_1.rgb2hsv(r, g, b), h = _b.h, s = _b.s, v = _b.v;
var hex = rgb2hex_1.rgb2hex(r, g, b);
var str = _rgbaOrHexString_1._rgbaOrHexString(r, g, b, a, hex);
var t = consts_1.MAX_COLOR_ALPHA - a;
return { a: a, b: b, g: g, h: h, hex: hex, r: r, s: s, str: str, v: v, t: t };
}
exports.getColorFromRGBA = getColorFromRGBA;
//# sourceMappingURL=getColorFromRGBA.js.map
/***/ }),
/***/ 7453:
"use strict";

exports.getColorFromString = void 0;
var cssColor_1 = __webpack_require__(15893);
/**
* Converts a CSS color string to a color object.
* Note that hex colors *must* be prefixed with # to be considered valid.
*
* ìnputColor` will be used unmodified as the `str` property of the returned
object.
* Alpha defaults to 100 if not specified in ìnputColor`.
* Returns undefined if the color string is invalid/not recognized.
*/
function getColorFromString(inputColor) {
var color = cssColor_1.cssColor(inputColor);
if (!color) {
return;
}
return tslib_1.__assign(tslib_1.__assign({},
getColorFromRGBA_1.getColorFromRGBA(color)), { str: inputColor });
}
exports.getColorFromString = getColorFromString;
//# sourceMappingURL=getColorFromString.js.map
/***/ }),
/***/ 7252:
"use strict";

exports.getFullColorString = void 0;
var hsv2hex_1 = __webpack_require__(80566);
/**
* Converts a color hue to an HTML color string (with # prefix).
* This implementation ignores all components of `color` except hue.
*/
function getFullColorString(color) {
return "#" + hsv2hex_1.hsv2hex(color.h, consts_1.MAX_COLOR_SATURATION,
consts_1.MAX_COLOR_VALUE);
}
exports.getFullColorString = getFullColorString;
//# sourceMappingURL=getFullColorString.js.map
/***/ }),
/***/ 67579:
"use strict";

exports.hsl2hsv = void 0;
/** Converts HSL components to an HSV color. */
function hsl2hsv(h, s, l) {
s *= (l < 50 ? l : 100 - l) / 100;
var v = l + s;
return {
h: h,
s: v === 0 ? 0 : ((2 * s) / v) * 100,
v: v,
};
}
exports.hsl2hsv = hsl2hsv;
//# sourceMappingURL=hsl2hsv.js.map
/***/ }),
/***/ 32853:
"use strict";

exports.hsl2rgb = void 0;
var hsl2hsv_1 = __webpack_require__(67579);
/** Converts HSL components to an RGB color. Does not set the alpha value. */
function hsl2rgb(h, s, l) {
var hsv = hsl2hsv_1.hsl2hsv(h, s, l);
return hsv2rgb_1.hsv2rgb(hsv.h, hsv.s, hsv.v);
}
exports.hsl2rgb = hsl2rgb;
//# sourceMappingURL=hsl2rgb.js.map
/***/ }),
/***/ 80566:
"use strict";

exports.hsv2hex = void 0;
/** Converts HSV components to a hex color string (without # prefix). */
function hsv2hex(h, s, v) {
var _a = hsv2rgb_1.hsv2rgb(h, s, v), r = _a.r, g = _a.g, b = _a.b;
return rgb2hex_1.rgb2hex(r, g, b);
}
exports.hsv2hex = hsv2hex;
//# sourceMappingURL=hsv2hex.js.map
/***/ }),
/***/ 64444:
"use strict";

exports.hsv2hsl = void 0;
/** Converts HSV components to an HSL color. */
function hsv2hsl(h, s, v) {
s /= consts_1.MAX_COLOR_SATURATION;
v /= consts_1.MAX_COLOR_VALUE;
var l = (2 - s) * v;
var sl = s * v;
sl /= l <= 1 ? l : 2 - l;
sl = sl || 0;
l /= 2;
return { h: h, s: sl * 100, l: l * 100 };
}
exports.hsv2hsl = hsv2hsl;
//# sourceMappingURL=hsv2hsl.js.map
/***/ }),
/***/ 41506:
"use strict";

exports.hsv2rgb = void 0;
/** Converts HSV components to an RGB color. Does not set the alpha value. */
function hsv2rgb(h, s, v) {
s = s / 100;
v = v / 100;
var rgb = [];
var c = v * s;
var hh = h / 60;
var x = c * (1 - Math.abs((hh % 2) - 1));
var m = v - c;
switch (Math.floor(hh)) {
case 0:
rgb = [c, x, 0];
break;
case 1:
rgb = [x, c, 0];
break;
case 2:
rgb = [0, c, x];
break;
case 3:
rgb = [0, x, c];
break;
case 4:
rgb = [x, 0, c];
break;
case 5:
rgb = [c, 0, x];
break;
}
return {
r: Math.round(consts_1.MAX_COLOR_RGB * (rgb[0] + m)),
g: Math.round(consts_1.MAX_COLOR_RGB * (rgb[1] + m)),
b: Math.round(consts_1.MAX_COLOR_RGB * (rgb[2] + m)),
};
}
exports.hsv2rgb = hsv2rgb;
//# sourceMappingURL=hsv2rgb.js.map
/***/ }),
/***/ 54870:
"use strict";

/***/ }),
/***/ 57127:
"use strict";

//# sourceMappingURL=interfaces.js.map
/***/ }),
/***/ 2542:
"use strict";

exports.rgb2hex = void 0;
/** Converts RGB components to a hex color string (without # prefix). */
function rgb2hex(r, g, b) {
return [_rgbToPaddedHex(r), _rgbToPaddedHex(g), _rgbToPaddedHex(b)].join('');
}
exports.rgb2hex = rgb2hex;
/** Converts an RGB component to a 0-padded hex component of length 2. */
function _rgbToPaddedHex(num) {
num = clamp_1.clamp(num, consts_1.MAX_COLOR_RGB);
var hex = num.toString(16);
return hex.length === 1 ? '0' + hex : hex;
}
//# sourceMappingURL=rgb2hex.js.map
/***/ }),
/***/ 51375:
"use strict";

exports.rgb2hsv = void 0;
/** Converts RGB components to an HSV color. */
function rgb2hsv(r, g, b) {
var h = NaN;
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var delta = max - min;
// hue
if (delta === 0) {
h = 0;
}
else if (r === max) {
h = ((g - b) / delta) % 6;
}
else if (g === max) {
h = (b - r) / delta + 2;
}
else if (b === max) {
h = (r - g) / delta + 4;
}
h = Math.round(h * 60);
if (h < 0) {
h += 360;
}
// saturation
var s = Math.round((max === 0 ? 0 : delta / max) * 100);
// value
var v = Math.round((max / consts_1.MAX_COLOR_RGB) * 100);
return { h: h, s: s, v: v };
}
exports.rgb2hsv = rgb2hsv;
//# sourceMappingURL=rgb2hsv.js.map
/***/ }),
/***/ 48032:
"use strict";

exports.getContrastRatio = exports.getBackgroundShade = exports.getShade =
exports.isDark = exports.isValidShade = exports.Shade = void 0;
// Technically this should be shades and tints, but for simplicity we'll call
everything a shade.
/*
* This utility module is used with theming. Given a color to shade, whether the
theme is inverted
* (i.e. is a dark color), and the desired shade enum, this will return an
appropriate shade of that color.
*/
var hsv2hsl_1 = __webpack_require__(64444);
// Soften: to get closer to the background color's luminance
// (softening with a white background would be lightening, with black it'd be
darkening)
// Strongen: opposite of soften
// Luminance multiplier constants for generating shades of a given color
var WhiteShadeTableBG = [0.027, 0.043, 0.082, 0.145, 0.184, 0.216, 0.349,
0.537]; // white bg
var BlackTintTableBG = [0.537, 0.45, 0.349, 0.216, 0.184, 0.145, 0.082, 0.043]; //
black bg
var WhiteShadeTable = [0.537, 0.349, 0.216, 0.184, 0.145, 0.082, 0.043, 0.027]; //
white fg
var BlackTintTable = [0.537, 0.45, 0.349, 0.216, 0.184, 0.145, 0.082, 0.043]; //
black fg
var LumTintTable = [0.88, 0.77, 0.66, 0.55, 0.44, 0.33, 0.22, 0.11]; // light
(strongen all)
var LumShadeTable = [0.11, 0.22, 0.33, 0.44, 0.55, 0.66, 0.77, 0.88]; // dark
(soften all)
var ColorTintTable = [0.96, 0.84, 0.7, 0.4, 0.12]; // default soften
var ColorShadeTable = [0.1, 0.24, 0.44]; // default strongen
// If the given shade's luminance is below/above these values, we'll swap to using
the White/Black tables above
var LowLuminanceThreshold = 0.2;
var HighLuminanceThreshold = 0.8;
/** Shades of a given color, from softest to strongest. */
var Shade;
(function (Shade) {
Shade[Shade["Unshaded"] = 0] = "Unshaded";
Shade[Shade["Shade1"] = 1] = "Shade1";
// remember to update isValidShade()!
})(Shade = exports.Shade || (exports.Shade = {}));
/**
* Returns true if the argument is a valid Shade value
* @param shade - The Shade value to validate.
*/
function isValidShade(shade) {
return typeof shade === 'number' && shade >= Shade.Unshaded && shade <=
Shade.Shade8;
}
exports.isValidShade = isValidShade;
function _isBlack(color) {
return color.r === 0 && color.g === 0 && color.b === 0;
}
function _isWhite(color) {
return color.r === consts_1.MAX_COLOR_RGB && color.g === consts_1.MAX_COLOR_RGB
&& color.b === consts_1.MAX_COLOR_RGB;
}
function _darken(hsv, factor) {
return {
h: hsv.h,
s: hsv.s,
v: clamp_1.clamp(hsv.v - hsv.v * factor, 100, 0),
};
}
function _lighten(hsv, factor) {
return {
h: hsv.h,
s: clamp_1.clamp(hsv.s - hsv.s * factor, 100, 0),
v: clamp_1.clamp(hsv.v + (100 - hsv.v) * factor, 100, 0),
};
}
function isDark(color) {
return hsv2hsl_1.hsv2hsl(color.h, color.s, color.v).l < 50;
}
exports.isDark = isDark;
/**
* Given a color and a shade specification, generates the requested shade of the
color.
* Logic:
* if white
* darken via tables defined above
* if black
* lighten
* if light
* strongen
* if dark
* soften
* else default
* soften or strongen depending on shade#
* @param color - The base color whose shade is to be computed
* @param shade - The shade of the base color to compute
* @param isInverted - Default false. Whether the given theme is inverted (reverse
strongen/soften logic)
*/
function getShade(color, shade, isInverted) {
if (!color) {
return null;
}
if (shade === Shade.Unshaded || !isValidShade(shade)) {
return color;
}
var hsl = hsv2hsl_1.hsv2hsl(color.h, color.s, color.v);
var hsv = { h: color.h, s: color.s, v: color.v };
var tableIndex = shade - 1;
var _soften = _lighten;
var _strongen = _darken;
if (isInverted) {
_soften = _darken;
_strongen = _lighten;
}
if (_isWhite(color)) {
// white
hsv = _darken(hsv, WhiteShadeTable[tableIndex]);
}
else if (_isBlack(color)) {
// black
hsv = _lighten(hsv, BlackTintTable[tableIndex]);
}
else if (hsl.l / 100 > HighLuminanceThreshold) {
// light
hsv = _strongen(hsv, LumShadeTable[tableIndex]);
}
else if (hsl.l / 100 < LowLuminanceThreshold) {
// dark
hsv = _soften(hsv, LumTintTable[tableIndex]);
}
else {
// default
if (tableIndex < ColorTintTable.length) {
hsv = _soften(hsv, ColorTintTable[tableIndex]);
}
else {
hsv = _strongen(hsv, ColorShadeTable[tableIndex -
ColorTintTable.length]);
}
}
return
getColorFromRGBA_1.getColorFromRGBA(Utilities_1.assign(hsv2rgb_1.hsv2rgb(hsv.h,
hsv.s, hsv.v), { a: color.a }));
}
exports.getShade = getShade;
// Background shades/tints are generated differently. The provided color will be
guaranteed
// to be the darkest or lightest one. If it is <50% luminance, it will always be
the darkest,
// otherwise it will always be the lightest.
function getBackgroundShade(color, shade, isInverted) {
if (!color) {
return null;
}
if (shade === Shade.Unshaded || !isValidShade(shade)) {
return color;
}
var hsv = { h: color.h, s: color.s, v: color.v };
var tableIndex = shade - 1;
if (!isInverted) {
// lightish
hsv = _darken(hsv, WhiteShadeTableBG[tableIndex]);
}
else {
// default: if (hsl.l / 100 < .5) { // darkish
hsv = _lighten(hsv, BlackTintTableBG[BlackTintTable.length - 1 -
tableIndex]);
}
return
getColorFromRGBA_1.getColorFromRGBA(Utilities_1.assign(hsv2rgb_1.hsv2rgb(hsv.h,
hsv.s, hsv.v), { a: color.a }));
}
exports.getBackgroundShade = getBackgroundShade;
/* Calculates the contrast ratio between two colors. Used for verifying
* color pairs meet minimum accessibility requirements.
* See: https://www.w3.org/TR/WCAG20/ section 1.4.3
*/
function getContrastRatio(color1, color2) {
// Formula defined by: http://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-
contrast-contrast.html#contrast-ratiodef
// relative luminance:
http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
/* calculate the intermediate value needed to calculating relative luminance */
function _getThing(x) {
if (x <= 0.03928) {
return x / 12.92;
}
else {
return Math.pow((x + 0.055) / 1.055, 2.4);
}
}
var r1 = _getThing(color1.r / consts_1.MAX_COLOR_RGB);
var g1 = _getThing(color1.g / consts_1.MAX_COLOR_RGB);
var b1 = _getThing(color1.b / consts_1.MAX_COLOR_RGB);
var L1 = 0.2126 * r1 + 0.7152 * g1 + 0.0722 * b1; // relative luminance of
first color
L1 += 0.05;
var r2 = _getThing(color2.r / consts_1.MAX_COLOR_RGB);
var g2 = _getThing(color2.g / consts_1.MAX_COLOR_RGB);
var b2 = _getThing(color2.b / consts_1.MAX_COLOR_RGB);
var L2 = 0.2126 * r2 + 0.7152 * g2 + 0.0722 * b2; // relative luminance of
second color
L2 += 0.05;
// return the lighter color divided by darker
return L1 / L2 > 1 ? L1 / L2 : L2 / L1;
}
exports.getContrastRatio = getContrastRatio;
//# sourceMappingURL=shades.js.map
/***/ }),
/***/ 78685:
"use strict";

exports.updateA = void 0;
/**
* Gets a color with the given alpha value and the same other components as
`color`.
* Does not modify the original color.
*/
function updateA(color, a) {
return tslib_1.__assign(tslib_1.__assign({}, color), { a: a, t:
consts_1.MAX_COLOR_ALPHA - a, str: _rgbaOrHexString_1._rgbaOrHexString(color.r,
color.g, color.b, a, color.hex) });
}
exports.updateA = updateA;
//# sourceMappingURL=updateA.js.map
/***/ }),
/***/ 74634:
"use strict";

exports.updateH = void 0;
/**
* Gets a color with the same saturation and value as `color` and the other
components updated
* to match the given hue.
*
* Does not modify the original `color` and does not supply a default alpha value.
*/
function updateH(color, h) {
var _a = hsv2rgb_1.hsv2rgb(h, color.s, color.v), r = _a.r, g = _a.g, b = _a.b;
return tslib_1.__assign(tslib_1.__assign({}, color), { h: h, r: r, g: g, b: b,
hex: hex, str: _rgbaOrHexString_1._rgbaOrHexString(r, g, b, color.a, hex) });
}
exports.updateH = updateH;
//# sourceMappingURL=updateH.js.map
/***/ }),
/***/ 31341:
"use strict";

exports.updateRGB = void 0;
/**
* Gets a color with a single RGBA component updated to a new value.
* Does not modify the original `color`. Alpha defaults to 100 if not set.
*/
function updateRGB(color, component, value) {
var _a;
return getColorFromRGBA_1.getColorFromRGBA((_a = {
r: color.r,
g: color.g,
b: color.b,
a: color.a
},
_a[component] = value,
_a));
}
exports.updateRGB = updateRGB;
//# sourceMappingURL=updateRGB.js.map
/***/ }),
/***/ 42083:
"use strict";

exports.updateSV = void 0;
/**
* Gets a color with the same hue as `color` and other components updated to match
the given
* saturation and value.
*
* Does not modify the original `color` and does not supply a default alpha value.
*/
function updateSV(color, s, v) {
var _a = hsv2rgb_1.hsv2rgb(color.h, s, v), r = _a.r, g = _a.g, b = _a.b;
return tslib_1.__assign(tslib_1.__assign({}, color), { s: s, v: v, r: r, g: g,
b: b, hex: hex, str: _rgbaOrHexString_1._rgbaOrHexString(r, g, b, color.a, hex) });
}
exports.updateSV = updateSV;
//# sourceMappingURL=updateSV.js.map
/***/ }),
/***/ 51869:
"use strict";

exports.updateT = void 0;
/**
* Gets a color with the given transparency value and the same other components as
`color`.
* Does not modify the original color.
*/
function updateT(color, t) {
var a = consts_1.MAX_COLOR_ALPHA - t;
return tslib_1.__assign(tslib_1.__assign({}, color), { t: t, a: a, str:
_rgbaOrHexString_1._rgbaOrHexString(color.r, color.g, color.b, a, color.hex) });
}
exports.updateT = updateT;
//# sourceMappingURL=updateT.js.map
/***/ }),
/***/ 82547:
"use strict";

exports.getMenuItemAriaRole = exports.isItemDisabled = exports.hasSubmenu =
exports.getIsChecked = void 0;
/**
* Determines the effective checked state of a menu item.
*
* @param item {IContextualMenuItem} to get the check state of.
* @returns {true} if the item is checked.
* @returns {false} if the item is unchecked.
* @returns {null} if the item is not checkable.
*/
function getIsChecked(item) {
if (item.canCheck) {
return !!(item.isChecked || item.checked);
}
if (typeof item.isChecked === 'boolean') {
return item.isChecked;
}
if (typeof item.checked === 'boolean') {
return item.checked;
}
// Item is not checkable.
return null;
}
exports.getIsChecked = getIsChecked;
function hasSubmenu(item) {
return !!(item.subMenuProps || item.items);
}
exports.hasSubmenu = hasSubmenu;
function isItemDisabled(item) {
return !!(item.isDisabled || item.disabled);
}
exports.isItemDisabled = isItemDisabled;
function getMenuItemAriaRole(item) {
var isChecked = getIsChecked(item);
var canCheck = isChecked !== null;
return canCheck ? 'menuitemcheckbox' : 'menuitem';
}
exports.getMenuItemAriaRole = getMenuItemAriaRole;
//# sourceMappingURL=contextualMenuUtility.js.map
/***/ }),
/***/ 70721:
"use strict";

/***/ }),
/***/ 74354:
"use strict";

exports.BaseDecorator = void 0;
var BaseDecorator = /** @class */ (function (_super) {
tslib_1.__extends(BaseDecorator, _super);
function BaseDecorator(props) {
_this._updateComposedComponentRef =
_this._updateComposedComponentRef.bind(_this);
return _this;
}
/**
* Updates the ref to the component composed by the decorator, which will also
take care of hoisting
* (and unhoisting as appropriate) methods from said component.
*
* Pass this method as the argument to the 'ref' property of the composed
component.
*/
BaseDecorator.prototype._updateComposedComponentRef = function
(composedComponentInstance) {
this._composedComponentInstance = composedComponentInstance;
if (composedComponentInstance) {
this._hoisted = Utilities_1.hoistMethods(this,
composedComponentInstance);
}
else if (this._hoisted) {
Utilities_1.unhoistMethods(this, this._hoisted);
}
};
return BaseDecorator;
exports.BaseDecorator = BaseDecorator;
//# sourceMappingURL=BaseDecorator.js.map
/***/ }),
/***/ 19170:
"use strict";

exports.getResponsiveMode = exports.withResponsiveMode =
exports.getInitialResponsiveMode = exports.initializeResponsiveMode =
exports.setResponsiveMode = exports.ResponsiveMode = void 0;
var BaseDecorator_1 = __webpack_require__(74354);
var ResponsiveMode;
(function (ResponsiveMode) {
/** Width \<= 479px */
ResponsiveMode[ResponsiveMode["small"] = 0] = "small";
/** Width \> 479px and \<= 639px */
ResponsiveMode[ResponsiveMode["medium"] = 1] = "medium";
/** Width \> 639px and \<= 1023px */
ResponsiveMode[ResponsiveMode["large"] = 2] = "large";
/** Width \> 1023px and \<= 1365px */
ResponsiveMode[ResponsiveMode["xLarge"] = 3] = "xLarge";
/** Width \> 1365px and \<= 1919px */
ResponsiveMode[ResponsiveMode["xxLarge"] = 4] = "xxLarge";
/** Width \> 1919px */
ResponsiveMode[ResponsiveMode["xxxLarge"] = 5] = "xxxLarge";
ResponsiveMode[ResponsiveMode["unknown"] = 999] = "unknown";
})(ResponsiveMode = exports.ResponsiveMode || (exports.ResponsiveMode = {}));
var RESPONSIVE_MAX_CONSTRAINT = [479, 639, 1023, 1365, 1919, 99999999];
/**
* User specified mode to default to, useful for server side rendering scenarios.
*/
var _defaultMode;
/**
* Tracking the last mode we successfully rendered, which allows us to
* paint initial renders with the correct size.
*/
var _lastMode;
/**
* Allows a server rendered scenario to provide a **default** responsive mode.
* This WILL NOT trigger any updates to components that have already consumed the
responsive mode!
*/
function setResponsiveMode(responsiveMode) {
_defaultMode = responsiveMode;
}
exports.setResponsiveMode = setResponsiveMode;
/**
* Initializes the responsive mode to the current window size. This can be used to
avoid
* a re-render during first component mount since the window would otherwise not be
measured
* until after mounting.
*
* This WILL NOT trigger any updates to components that have already consumed the
responsive mode!
*/
function initializeResponsiveMode(element) {
var currentWindow = Utilities_1.getWindow(element);
if (currentWindow) {
getResponsiveMode(currentWindow);
}
}
exports.initializeResponsiveMode = initializeResponsiveMode;
function getInitialResponsiveMode() {
var _a;
return (_a = _defaultMode !== null && _defaultMode !== void 0 ? _defaultMode :
_lastMode) !== null && _a !== void 0 ? _a : ResponsiveMode.large;
}
exports.getInitialResponsiveMode = getInitialResponsiveMode;
/**
* @deprecated Decorator usage is deprecated. Either call `getResponsiveMode`
manually, or
* use the ùseResponsiveMode` hook within a function component.
*/
function withResponsiveMode(ComposedComponent) {
var _a;
var resultClass = (_a = /** @class */ (function (_super) {
tslib_1.__extends(WithResponsiveMode, _super);
function WithResponsiveMode(props) {
_this._onResize = function () {
var responsiveMode = getResponsiveMode(_this.context.window);
if (responsiveMode !== _this.state.responsiveMode) {
_this.setState({
responsiveMode: responsiveMode,
});
}
};
_this._updateComposedComponentRef =
_this._updateComposedComponentRef.bind(_this);
_this.state = {
responsiveMode: getInitialResponsiveMode(),
};
return _this;
}
WithResponsiveMode.prototype.componentDidMount = function () {
this._events.on(this.context.window, 'resize', this._onResize);
this._onResize();
};
WithResponsiveMode.prototype.componentWillUnmount = function () {
};
WithResponsiveMode.prototype.render = function () {
var responsiveMode = this.state.responsiveMode;
return responsiveMode === ResponsiveMode.unknown ? null :
(React.createElement(ComposedComponent, tslib_1.__assign({ ref:
this._updateComposedComponentRef, responsiveMode: responsiveMode }, this.props)));
};
return WithResponsiveMode;
}(BaseDecorator_1.BaseDecorator)),
_a.contextType = WindowProvider_1.WindowContext,
_a);
return Utilities_1.hoistStatics(ComposedComponent, resultClass);
}
exports.withResponsiveMode = withResponsiveMode;
function getWidthOfCurrentWindow(currentWindow) {
try {
return currentWindow.document.documentElement.clientWidth;
}
catch (e) {
return currentWindow.innerWidth;
}
}
/**
* Hook to get the current responsive mode (window size category).
* @param currentWindow - Use this window when determining the responsive mode.
*/
function getResponsiveMode(currentWindow) {
var responsiveMode = ResponsiveMode.small;
if (currentWindow) {
try {
while (getWidthOfCurrentWindow(currentWindow) >
RESPONSIVE_MAX_CONSTRAINT[responsiveMode]) {
responsiveMode++;
}
}
catch (e) {
// Return a best effort result in cases where we're in the browser but
it throws on getting innerWidth.
responsiveMode = getInitialResponsiveMode();
}
// Tracking last mode just gives us a better default in future renders,
// which avoids starting with the wrong value if we've measured once.
_lastMode = responsiveMode;
}
else {
if (_defaultMode !== undefined) {
responsiveMode = _defaultMode;
}
else {
throw new Error('Content was rendered in a server environment without
providing a default responsive mode. ' +
'Call setResponsiveMode to define what the responsive mode is.');
}
}
return responsiveMode;
}
exports.getResponsiveMode = getResponsiveMode;
//# sourceMappingURL=withResponsiveMode.js.map
/***/ }),
/***/ 38685:
"use strict";

exports.withViewport = void 0;
var BaseDecorator_1 = __webpack_require__(74354);
var MAX_RESIZE_ATTEMPTS = 3;
/**
* A decorator to update decorated component on viewport or window resize events.
*
* @param ComposedComponent decorated React component reference.
*/
function withViewport(ComposedComponent) {
return /** @class */ (function (_super) {
tslib_1.__extends(WithViewportComponent, _super);
function WithViewportComponent(props) {
_this._registerResizeObserver = function () {
var win = Utilities_1.getWindow(_this._root.current);
_this._viewportResizeObserver = new
win.ResizeObserver(_this._onAsyncResize);
_this._viewportResizeObserver.observe(_this._root.current);
};
_this._unregisterResizeObserver = function () {
if (_this._viewportResizeObserver) {
_this._viewportResizeObserver.disconnect();
delete _this._viewportResizeObserver;
}
};
/* Note: using lambda here because decorators don't seem to work in
decorators. */
_this._updateViewport = function (withForceUpdate) {
var viewport = _this.state.viewport;
var viewportElement = _this._root.current;
var scrollElement =
Utilities_1.findScrollableParent(viewportElement);
var scrollRect = Utilities_1.getRect(scrollElement);
var clientRect = Utilities_1.getRect(viewportElement);
var updateComponent = function () {
if (withForceUpdate && _this._composedComponentInstance) {
_this._composedComponentInstance.forceUpdate();
}
};
var isSizeChanged = (clientRect && clientRect.width) !==
viewport.width || (scrollRect && scrollRect.height) !== viewport.height;
if (isSizeChanged && _this._resizeAttempts < MAX_RESIZE_ATTEMPTS &&
clientRect && scrollRect) {
_this._resizeAttempts++;
_this.setState({
viewport: {
width: clientRect.width,
height: scrollRect.height,
},
}, function () {
_this._updateViewport(withForceUpdate);
});
}
else {
_this._resizeAttempts = 0;
updateComponent();
}
};
_this._resizeAttempts = 0;
_this.state = {
viewport: {
width: 0,
height: 0,
},
};
return _this;
}
WithViewportComponent.prototype.componentDidMount = function () {
var _this = this;
var _a = this.props, delayFirstMeasure = _a.delayFirstMeasure,
disableResizeObserver = _a.disableResizeObserver, skipViewportMeasures =
_a.skipViewportMeasures;
this._onAsyncResize = this._async.debounce(this._onAsyncResize,
RESIZE_DELAY, {
leading: false,
});
if (!disableResizeObserver && this._isResizeObserverAvailable()) {
this._registerResizeObserver();
}
else {
this._events.on(win, 'resize', this._onAsyncResize);
}
if (delayFirstMeasure) {
_this._updateViewport();
}, RESIZE_DELAY);
}
else {
this._updateViewport();
}
}
};
WithViewportComponent.prototype.componentDidUpdate = function
(previousProps) {
var previousSkipViewportMeasures = previousProps.skipViewportMeasures;
var _a = this.props, disableResizeObserver = _a.disableResizeObserver,
skipViewportMeasures = _a.skipViewportMeasures;
if (skipViewportMeasures !== previousSkipViewportMeasures) {
if (!disableResizeObserver &&
this._isResizeObserverAvailable()) {
if (!this._viewportResizeObserver) {
this._registerResizeObserver();
}
}
else {
this._events.on(win, 'resize', this._onAsyncResize);
}
}
else {
this._unregisterResizeObserver();
this._events.off(win, 'resize', this._onAsyncResize);
}
}
};
WithViewportComponent.prototype.componentWillUnmount = function () {
this._unregisterResizeObserver();
};
WithViewportComponent.prototype.render = function () {
var viewport = this.state.viewport;
var newViewport = viewport.width > 0 && viewport.height > 0 ?
viewport : undefined;
return (React.createElement("div", { className: "ms-Viewport", ref:
this._root, style: { minWidth: 1, minHeight: 1 } },
React.createElement(ComposedComponent, tslib_1.__assign({ ref:
this._updateComposedComponentRef, viewport: newViewport }, this.props))));
};
WithViewportComponent.prototype.forceUpdate = function () {
this._updateViewport(true);
};
WithViewportComponent.prototype._onAsyncResize = function () {
};
WithViewportComponent.prototype._isResizeObserverAvailable = function () {
return win && win.ResizeObserver;
};
return WithViewportComponent;
}(BaseDecorator_1.BaseDecorator));
}
exports.withViewport = withViewport;
//# sourceMappingURL=withViewport.js.map
/***/ }),
/***/ 420:
"use strict";

exports.DragDropHelper = void 0;
var MOUSEMOVE_PRIMARY_BUTTON = 1; // for mouse move event we are using ev.buttons
var DragDropHelper = /** @class */ (function () {
function DragDropHelper(params) {
this._selection = params.selection;
this._dragEnterCounts = {};
this._activeTargets = {};
this._lastId = 0;
// To make this class cheap to create, which allows simplifying some logic
elsewhere,
// only initialize the event group and global event handlers as needed.
this._initialized = false;
}
DragDropHelper.prototype.dispose = function () {
if (this._events) {
}
};
DragDropHelper.prototype.subscribe = function (root, events, dragDropOptions) {
var _this = this;
if (!this._initialized) {
this._events = new Utilities_1.EventGroup(this);
var doc = Utilities_1.getDocument();
// clear drag data when mouse up, use capture event to ensure it will
be run
if (doc) {
this._events.on(doc.body, 'mouseup', this._onMouseUp.bind(this),
true);
this._events.on(doc, 'mouseup', this._onDocumentMouseUp.bind(this),
true);
}
this._initialized = true;
}
var _a = dragDropOptions.key, key = _a === void 0 ? "" + ++this._lastId :
_a;
var handlers = [];
var onDragStart;
var onDragLeave;
var onDragEnter;
var onDragEnd;
var onDrop;
var onDragOver;
var onMouseDown;
var isDraggable;
var isDroppable;
var activeTarget;
if (dragDropOptions && root) {
var eventMap = dragDropOptions.eventMap, context =
dragDropOptions.context, updateDropState_1 = dragDropOptions.updateDropState;
var dragDropTarget = {
root: root,
options: dragDropOptions,
key: key,
};
isDraggable = this._isDraggable(dragDropTarget);
isDroppable = this._isDroppable(dragDropTarget);
if (isDraggable || isDroppable) {
if (eventMap) {
for (var _i = 0, eventMap_1 = eventMap; _i < eventMap_1.length;
_i++) {
var event_1 = eventMap_1[_i];
var handler = {
callback: event_1.callback.bind(null, context),
eventName: event_1.eventName,
};
handlers.push(handler);
this._events.on(root, handler.eventName, handler.callback);
}
}
}
if (isDroppable) {
// If the target is droppable, wire up global event listeners to
track drop-related events.
onDragLeave = function (event) {
if (!event.isHandled) {
event.isHandled = true;
_this._dragEnterCounts[key]--;
if (_this._dragEnterCounts[key] === 0) {
updateDropState_1(false /* isDropping */, event);
}
}
};
onDragEnter = function (event) {
event.preventDefault(); // needed for IE
if (!event.isHandled) {
event.isHandled = true;
_this._dragEnterCounts[key]++;
if (_this._dragEnterCounts[key] === 1) {
updateDropState_1(true /* isDropping */, event);
}
}
};
onDragEnd = function (event) {
_this._dragEnterCounts[key] = 0;
};
onDrop = function (event) {
_this._dragEnterCounts[key] = 0;
if (dragDropOptions.onDrop) {
dragDropOptions.onDrop(dragDropOptions.context.data,
event);
}
};
onDragOver = function (event) {
if (dragDropOptions.onDragOver) {
dragDropOptions.onDragOver(dragDropOptions.context.data,
event);
}
};
this._dragEnterCounts[key] = 0;
// dragenter and dragleave will be fired when hover to the child
element
// but we only want to change state when enter or leave the current
element
// use the count to ensure it.
events.on(root, 'dragenter', onDragEnter);
events.on(root, 'dragleave', onDragLeave);
events.on(root, 'dragend', onDragEnd);
events.on(root, 'drop', onDrop);
events.on(root, 'dragover', onDragOver);
}
if (isDraggable) {
// If the target is draggable, wire up local event listeners for
mouse events.
onMouseDown = this._onMouseDown.bind(this, dragDropTarget);
onDragEnd = this._onDragEnd.bind(this, dragDropTarget);
// We need to add in data so that on Firefox we show the ghost
element when dragging
onDragStart = function (event) {
var options = dragDropOptions;
if (options && options.onDragStart) {
options.onDragStart(options.context.data,
options.context.index, _this._selection.getSelection(), event);
}
_this._isDragging = true;
if (event.dataTransfer) {
event.dataTransfer.setData('id', root.id);
}
};
events.on(root, 'dragstart', onDragStart);
events.on(root, 'mousedown', onMouseDown);
events.on(root, 'dragend', onDragEnd);
}
activeTarget = {
target: dragDropTarget,
dispose: function () {
if (_this._activeTargets[key] === activeTarget) {
delete _this._activeTargets[key];
}
if (root) {
for (var _i = 0, handlers_1 = handlers; _i <
handlers_1.length; _i++) {
var handler = handlers_1[_i];
_this._events.off(root, handler.eventName,
handler.callback);
}
if (isDroppable) {
events.off(root, 'dragenter', onDragEnter);
events.off(root, 'dragleave', onDragLeave);
events.off(root, 'dragend', onDragEnd);
events.off(root, 'dragover', onDragOver);
events.off(root, 'drop', onDrop);
}
if (isDraggable) {
events.off(root, 'dragstart', onDragStart);
events.off(root, 'mousedown', onMouseDown);
events.off(root, 'dragend', onDragEnd);
}
}
},
};
this._activeTargets[key] = activeTarget;
}
return {
key: key,
dispose: function () {
if (activeTarget) {
activeTarget.dispose();
}
},
};
};
DragDropHelper.prototype.unsubscribe = function (root, key) {
var activeTarget = this._activeTargets[key];
if (activeTarget) {
activeTarget.dispose();
}
};
DragDropHelper.prototype._onDragEnd = function (target, event) {
var options = target.options;
if (options.onDragEnd) {
options.onDragEnd(options.context.data, event);
}
};
/**
* clear drag data when mouse up on body
*/
DragDropHelper.prototype._onMouseUp = function (event) {
this._isDragging = false;
if (this._dragData) {
for (var _i = 0, _a = Object.keys(this._activeTargets); _i < _a.length;
_i++) {
var key = _a[_i];
if (activeTarget.target.root) {
this._events.off(activeTarget.target.root, 'mousemove');
this._events.off(activeTarget.target.root, 'mouseleave');
}
}
if (this._dragData.dropTarget) {
// raise dragleave event to let dropTarget know it need to remove
dropping style
Utilities_1.EventGroup.raise(this._dragData.dropTarget.root,
'dragleave');
Utilities_1.EventGroup.raise(this._dragData.dropTarget.root,
'drop');
}
}
this._dragData = null;
};
/**
* clear drag data when mouse up outside of the document
*/
DragDropHelper.prototype._onDocumentMouseUp = function (event) {
if (doc && event.target === doc.documentElement) {
this._onMouseUp(event);
}
};
/**
* when mouse move over a new drop target while dragging some items,
* fire dragleave on the old target and fire dragenter to the new target
* The target will handle style change on dragenter and dragleave events.
*/
DragDropHelper.prototype._onMouseMove = function (target, event) {
var
updating well during the move.
// but firefox doesn't support it, so we set the default value when it is
not defined.
_a = event.buttons,
updating well during the move.
// but firefox doesn't support it, so we set the default value when it is
not defined.
buttons = _a === void 0 ? MOUSEMOVE_PRIMARY_BUTTON : _a;
if (this._dragData && buttons !== MOUSEMOVE_PRIMARY_BUTTON) {
// cancel mouse down event and return early when the primary button is
not pressed
this._onMouseUp(event);
return;
}
var root = target.root, key = target.key;
if (this._isDragging) {
if (this._isDroppable(target)) {
// we can have nested drop targets in the DOM, like a folder inside
a group. In that case, when we drag into
// the inner target (folder), we first set dropTarget to the inner
element. But the same event is bubbled to the
// outer target too, and we need to prevent the outer one from
taking over.
// So, check if the last dropTarget is not a child of the current.
if (this._dragData) {
if (this._dragData.dropTarget &&
this._dragData.dropTarget.key !== key &&
!this._isChild(root, this._dragData.dropTarget.root)) {
if (this._dragEnterCounts[this._dragData.dropTarget.key] >
0) {
Utilities_1.EventGroup.raise(this._dragData.dropTarget.root, 'dragleave');
Utilities_1.EventGroup.raise(root, 'dragenter');
this._dragData.dropTarget = target;
}
}
}
}
}
};
/**
* when mouse leave a target while dragging some items, fire dragleave to the
target
*/
DragDropHelper.prototype._onMouseLeave = function (target, event) {
if (this._isDragging) {
if (this._dragData && this._dragData.dropTarget &&
this._dragData.dropTarget.key === target.key) {
Utilities_1.EventGroup.raise(target.root, 'dragleave');
this._dragData.dropTarget = undefined;
}
}
};
/**
* when mouse down on a draggable item, we start to track dragdata.
*/
DragDropHelper.prototype._onMouseDown = function (target, event) {
if (event.button !== MOUSEDOWN_PRIMARY_BUTTON) {
return;
}
if (this._isDraggable(target)) {
this._dragData = {
clientX: event.clientX,
clientY: event.clientY,
eventTarget: event.target,
dragTarget: target,
};
for (var _i = 0, _a = Object.keys(this._activeTargets); _i < _a.length;
_i++) {
var key = _a[_i];
if (activeTarget.target.root) {
this._events.on(activeTarget.target.root, 'mousemove',
this._onMouseMove.bind(this, activeTarget.target));
this._events.on(activeTarget.target.root, 'mouseleave',
this._onMouseLeave.bind(this, activeTarget.target));
}
}
}
else {
this._dragData = null;
}
};
/**
* determine whether the child target is a descendant of the parent
*/
DragDropHelper.prototype._isChild = function (parentElement, childElement) {
while (childElement && childElement.parentElement) {
if (childElement.parentElement === parentElement) {
return true;
}
childElement = childElement.parentElement;
}
return false;
};
DragDropHelper.prototype._isDraggable = function (target) {
return !!(options.canDrag && options.canDrag(options.context.data));
};
DragDropHelper.prototype._isDroppable = function (target) {
// TODO: take the drag item into consideration to prevent dragging an item
into the same group
var dragContext = this._dragData && this._dragData.dragTarget ?
this._dragData.dragTarget.options.context : undefined;
return !!(options.canDrop && options.canDrop(options.context,
dragContext));
};
return DragDropHelper;
}());
exports.DragDropHelper = DragDropHelper;
//# sourceMappingURL=DragDropHelper.js.map
/***/ }),
/***/ 35695:
"use strict";

/***/ }),
/***/ 65106:
"use strict";

/***/ }),
/***/ 71289:
"use strict";

exports.GetGroupCount = void 0;
/**
* Takes an array of groups and returns a count of the groups and all descendant
groups.
* @param groups - The array of groups to count.
*/
var GetGroupCount = function (groups) {
var total = 0;
if (groups) {
var remainingGroups = tslib_1.__spreadArray([], groups);
var currentGroup = void 0;
while (remainingGroups && remainingGroups.length > 0) {
++total;
currentGroup = remainingGroups.pop();
if (currentGroup && currentGroup.children) {
remainingGroups.push.apply(remainingGroups, currentGroup.children);
}
}
}
return total;
};
exports.GetGroupCount = GetGroupCount;
//# sourceMappingURL=GroupedListUtility.js.map
/***/ }),
/***/ 14791:
"use strict";

exports.useResponsiveMode = void 0;
var withResponsiveMode_1 = __webpack_require__(19170);
/**
* Hook to get the current responsive mode (window size category).
* @param elementRef - Use this element's parent window when determining the
responsive mode.
* @param overrideResponsiveMode - Override the responsive mode. If this param is
present, it's always returned.
*/
var useResponsiveMode = function (elementRef, overrideResponsiveMode) {
var _a = React.useState(withResponsiveMode_1.getInitialResponsiveMode()),
lastResponsiveMode = _a[0], setLastResponsiveMode = _a[1];
var onResize = React.useCallback(function () {
var newResponsiveMode =
withResponsiveMode_1.getResponsiveMode(utilities_1.getWindow(elementRef.current));
// Setting the same value should not cause a re-render.
if (lastResponsiveMode !== newResponsiveMode) {
setLastResponsiveMode(newResponsiveMode);
}
}, [elementRef, lastResponsiveMode]);
var win = WindowProvider_1.useWindow();
react_hooks_1.useOnEvent(win, 'resize', onResize);
// Call resize function initially on mount, or if the override changes from
defined to undefined
// (the effect will run on all override changes, but onResize will only be
called if it changed to undefined)
if (overrideResponsiveMode === undefined) {
onResize();
}
// eslint-disable-next-line react-hooks/exhaustive-deps -- only meant to
run on mount or when override changes
}, [overrideResponsiveMode]);
return overrideResponsiveMode !== null && overrideResponsiveMode !== void 0 ?
overrideResponsiveMode : lastResponsiveMode;
};
exports.useResponsiveMode = useResponsiveMode;
//# sourceMappingURL=useResponsiveMode.js.map
/***/ }),
/***/ 23587:
"use strict";

exports.transitionKeysContain = exports.transitionKeysAreEqual = void 0;
/**
* Tests for equality between two IKeytipTransitionKeys.
*
* @param key1 - First IKeytipTransitionKey.
* @param key2 - Second IKeytipTransitionKey.
* @returns T/F if the transition keys are equal.
*/
function transitionKeysAreEqual(key1, key2) {
if (key1.key !== key2.key) {
return false;
}
var mod1 = key1.modifierKeys;
var mod2 = key2.modifierKeys;
if ((!mod1 && mod2) || (mod1 && !mod2)) {
// Not equal if one modifier is defined and the other isn't
return false;
}
if (mod1 && mod2) {
if (mod1.length !== mod2.length) {
return false;
}
// Sort both arrays
mod1 = mod1.sort();
mod2 = mod2.sort();
for (var i = 0; i < mod1.length; i++) {
if (mod1[i] !== mod2[i]) {
return false;
}
}
}
return true;
}
exports.transitionKeysAreEqual = transitionKeysAreEqual;
/**
* Tests if 'key' is present in 'keys'.
*
* @param keys - Array of IKeytipTransitionKey.
* @param key - IKeytipTransitionKey to find in 'keys'.
* @returns T/F if 'keys' contains 'key'.
*/
function transitionKeysContain(keys, key) {
return !!Utilities_1.find(keys, function (transitionKey) {
return transitionKeysAreEqual(transitionKey, key);
});
}
exports.transitionKeysContain = transitionKeysContain;
//# sourceMappingURL=IKeytipTransitionKey.js.map
/***/ }),
/***/ 72752:
"use strict";

exports.constructKeytip = exports.buildKeytipConfigMap = void 0;
/**
* Builds a map of ID to IKeytipProps
*
* @param config - IKeytipConfig object
* @returns Config map
*/
function buildKeytipConfigMap(config) {
var configMap = {};
for (var _i = 0, _a = config.keytips; _i < _a.length; _i++) {
var keytip = _a[_i];
constructKeytip(configMap, [], keytip);
}
return configMap;
}
exports.buildKeytipConfigMap = buildKeytipConfigMap;
/**
* Constructs a keytip from an IKeytipConfigItem and puts it in the configMap
*
* @param configMap - IKeytipConfigMap to store the keytip in
* @param parentSequence - string of the parent keytip
* @param keytip - IKeytipConfigItem data
*/
function constructKeytip(configMap, parentSequence, keytip) {
// Compute full key sequence
var sequence = keytip.sequence ? keytip.sequence :
keytip.content.toLocaleLowerCase();
var keytipSequence = parentSequence.concat(sequence);
// Save props in configMap
var keytipProps = tslib_1.__assign(tslib_1.__assign({}, keytip.optionalProps),
{ keySequences: keytipSequence, content: keytip.content });
configMap[keytip.id] = keytipProps;
if (keytip.children) {
for (var _i = 0, _a = keytip.children; _i < _a.length; _i++) {
var child = _a[_i];
// Create keytips for all children
constructKeytip(configMap, keytipSequence, child);
}
}
}
exports.constructKeytip = constructKeytip;
//# sourceMappingURL=KeytipConfig.js.map
/***/ }),
/***/ 42962:
"use strict";

exports.KeytipEvents = exports.KTP_ARIA_SEPARATOR = exports.KTP_LAYER_ID =
exports.DATAKTP_ARIA_TARGET = exports.DATAKTP_EXECUTE_TARGET =
exports.DATAKTP_TARGET = exports.KTP_FULL_PREFIX = exports.KTP_SEPARATOR =
exports.KTP_PREFIX = void 0;
exports.KTP_PREFIX = 'ktp';
exports.KTP_SEPARATOR = '-';
exports.KTP_FULL_PREFIX = exports.KTP_PREFIX + exports.KTP_SEPARATOR;
exports.DATAKTP_TARGET = 'data-ktp-target';
exports.DATAKTP_EXECUTE_TARGET = 'data-ktp-execute-target';
exports.DATAKTP_ARIA_TARGET = 'data-ktp-aria-target';
exports.KTP_LAYER_ID = 'ktp-layer-id';
exports.KTP_ARIA_SEPARATOR = ', ';
// Events
var KeytipEvents;
(function (KeytipEvents) {
KeytipEvents.KEYTIP_ADDED = 'keytipAdded';
KeytipEvents.KEYTIP_REMOVED = 'keytipRemoved';
KeytipEvents.KEYTIP_UPDATED = 'keytipUpdated';
KeytipEvents.PERSISTED_KEYTIP_ADDED = 'persistedKeytipAdded';
KeytipEvents.PERSISTED_KEYTIP_REMOVED = 'persistedKeytipRemoved';
KeytipEvents.PERSISTED_KEYTIP_EXECUTE = 'persistedKeytipExecute';
KeytipEvents.ENTER_KEYTIP_MODE = 'enterKeytipMode';
KeytipEvents.EXIT_KEYTIP_MODE = 'exitKeytipMode';
})(KeytipEvents = exports.KeytipEvents || (exports.KeytipEvents = {}));
//# sourceMappingURL=KeytipConstants.js.map
/***/ }),
/***/ 84992:
"use strict";

exports.KeytipManager = void 0;
/**
* This class is responsible for handling registering, updating, and unregistering
of keytips
*/
var KeytipManager = /** @class */ (function () {
function KeytipManager() {
this.keytips = {};
this.persistedKeytips = {};
this.sequenceMapping = {};
// This is (and should be) updated and kept in sync
// with the inKeytipMode in KeytipLayer.
this.inKeytipMode = false;
// Boolean that gets checked before entering keytip mode by the KeytipLayer
// Used for an override in special cases (e.g. Disable entering keytip mode
when a modal is shown)
this.shouldEnterKeytipMode = true;
// Boolean to indicate whether to delay firing an event to update
subscribers of
// keytip data changed.
this.delayUpdatingKeytipChange = false;
}
/**
* Static function to get singleton KeytipManager instance
*
* @returns Singleton KeytipManager instance
*/
KeytipManager.getInstance = function () {
return this._instance;
};
/**
* Initialization code to set set parameters to define
* how the KeytipManager handles keytip data.
*
* @param delayUpdatingKeytipChange - T/F if we should delay notifiying keytip
subscribers
* of keytip changes
*/
KeytipManager.prototype.init = function (delayUpdatingKeytipChange) {
this.delayUpdatingKeytipChange = delayUpdatingKeytipChange;
};
/**
* Registers a keytip
*
* @param keytipProps - Keytip to register
* @param persisted - T/F if this keytip should be persisted, default is false
* @returns Unique ID for this keytip
*/
KeytipManager.prototype.register = function (keytipProps, persisted) {
if (persisted === void 0) { persisted = false; }
var props = keytipProps;
if (!persisted) {
// Add the overflowSetSequence if necessary
props = this.addParentOverflow(keytipProps);
this.sequenceMapping[props.keySequences.toString()] = props;
}
// Create a unique keytip
var uniqueKeytip = this._getUniqueKtp(props);
// Add to dictionary
persisted
? (this.persistedKeytips[uniqueKeytip.uniqueID] = uniqueKeytip)
: (this.keytips[uniqueKeytip.uniqueID] = uniqueKeytip);
// We only want to add something new if we are currently showing keytip
mode
if (this.inKeytipMode || !this.delayUpdatingKeytipChange) {
var event_1 = persisted ?
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_ADDED :
KeytipConstants_1.KeytipEvents.KEYTIP_ADDED;
Utilities_1.EventGroup.raise(this, event_1, {
keytip: props,
uniqueID: uniqueKeytip.uniqueID,
});
}
return uniqueKeytip.uniqueID;
};
/**
* Update a keytip
*
* @param keytipProps - Keytip to update
* @param uniqueID - Unique ID of this keytip
*/
KeytipManager.prototype.update = function (keytipProps, uniqueID) {
var newKeytipProps = this.addParentOverflow(keytipProps);
var uniqueKeytip = this._getUniqueKtp(newKeytipProps, uniqueID);
var oldKeyTip = this.keytips[uniqueID];
if (oldKeyTip) {
// Update everything except 'visible'
uniqueKeytip.keytip.visible = oldKeyTip.keytip.visible;
// Update keytip in this.keytips
this.keytips[uniqueID] = uniqueKeytip;
// Update the sequence to be up to date
delete this.sequenceMapping[oldKeyTip.keytip.keySequences.toString()];
this.sequenceMapping[uniqueKeytip.keytip.keySequences.toString()] =
uniqueKeytip.keytip;
// Raise event only if we are currently in keytip mode
Utilities_1.EventGroup.raise(this,
KeytipConstants_1.KeytipEvents.KEYTIP_UPDATED, {
keytip: uniqueKeytip.keytip,
uniqueID: uniqueKeytip.uniqueID,
});
}
}
};
/**
* Unregisters a keytip
*
* @param keytipToRemove - IKeytipProps of the keytip to remove
* @param uniqueID - Unique ID of this keytip
* @param persisted - T/F if this keytip should be persisted, default is false
*/
KeytipManager.prototype.unregister = function (keytipToRemove, uniqueID,
persisted) {
if (persisted === void 0) { persisted = false; }
persisted ? delete this.persistedKeytips[uniqueID] : delete
this.keytips[uniqueID];
!persisted && delete
this.sequenceMapping[keytipToRemove.keySequences.toString()];
var event = persisted ?
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_REMOVED :
KeytipConstants_1.KeytipEvents.KEYTIP_REMOVED;
// Update keytips only if we're in keytip mode
Utilities_1.EventGroup.raise(this, event, {
keytip: keytipToRemove,
uniqueID: uniqueID,
});
}
};
/**
* Manual call to enter keytip mode
*/
KeytipManager.prototype.enterKeytipMode = function () {
KeytipConstants_1.KeytipEvents.ENTER_KEYTIP_MODE);
};
/**
* Manual call to exit keytip mode
*/
KeytipManager.prototype.exitKeytipMode = function () {
KeytipConstants_1.KeytipEvents.EXIT_KEYTIP_MODE);
};
/**
* Gets all IKeytipProps from this.keytips
*
* @returns All keytips stored in the manager
*/
KeytipManager.prototype.getKeytips = function () {
var _this = this;
return Object.keys(this.keytips).map(function (key) { return
_this.keytips[key].keytip; });
};
/**
* Adds the overflowSetSequence to the keytipProps if its parent keytip also
has it
*
* @param keytipProps - Keytip props to add overflowSetSequence to if necessary
* @returns - Modified keytip props, if needed to be modified
*/
KeytipManager.prototype.addParentOverflow = function (keytipProps) {
fullSequence.pop();
if (fullSequence.length !== 0) {
var parentKeytip = this.sequenceMapping[fullSequence.toString()];
if (parentKeytip && parentKeytip.overflowSetSequence) {
return tslib_1.__assign(tslib_1.__assign({}, keytipProps),
{ overflowSetSequence: parentKeytip.overflowSetSequence });
}
}
return keytipProps;
};
/**
* Public function to bind for overflow items that have a submenu
*/
KeytipManager.prototype.menuExecute = function (overflowButtonSequences,
keytipSequences) {
KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_EXECUTE, {
overflowButtonSequences: overflowButtonSequences,
keytipSequences: keytipSequences,
});
};
/**
* Creates an IUniqueKeytip object
*
* @param keytipProps - IKeytipProps
* @param uniqueID - Unique ID, will default to the next unique ID if not
passed
* @returns IUniqueKeytip object
*/
KeytipManager.prototype._getUniqueKtp = function (keytipProps, uniqueID) {
if (uniqueID === void 0) { uniqueID = Utilities_1.getId(); }
return { keytip: tslib_1.__assign({}, keytipProps), uniqueID: uniqueID };
};
KeytipManager._instance = new KeytipManager();
return KeytipManager;
}());
exports.KeytipManager = KeytipManager;
//# sourceMappingURL=KeytipManager.js.map
/***/ }),
/***/ 59409:
"use strict";

exports.getAriaDescribedBy = exports.ktpTargetFromId =
exports.ktpTargetFromSequences = exports.mergeOverflows = exports.sequencesToID =
void 0;
/**
* Converts a whole set of KeySequences into one keytip ID, which will be the ID
for the last keytip sequence specified
* keySequences should not include the initial keytip 'start' sequence.
*
* @param keySequences - Full path of IKeySequences for one keytip.
* @returns String to use for the keytip ID.
*/
function sequencesToID(keySequences) {
return keySequences.reduce(function (prevValue, keySequence) {
return prevValue + KeytipConstants_1.KTP_SEPARATOR +
keySequence.split('').join(KeytipConstants_1.KTP_SEPARATOR);
}, KeytipConstants_1.KTP_PREFIX);
}
exports.sequencesToID = sequencesToID;
/**
* Merges an overflow sequence with a key sequence.
*
* @param keySequences - Full sequence for one keytip.
* @param overflowKeySequences - Full overflow keytip sequence.
* @returns Sequence that will be used by the keytip when in the overflow.
*/
function mergeOverflows(keySequences, overflowKeySequences) {
var overflowSequenceLen = overflowKeySequences.length;
var overflowSequence = tslib_1.__spreadArray([], overflowKeySequences).pop();
var newKeySequences = tslib_1.__spreadArray([], keySequences);
return Utilities_1.addElementAtIndex(newKeySequences, overflowSequenceLen - 1,
overflowSequence);
}
exports.mergeOverflows = mergeOverflows;
/**
* Constructs the data-ktp-target attribute selector from a full key sequence.
*
* @param keySequences - Full string[] for a Keytip.
* @returns String selector to use to query for the keytip target.
*/
function ktpTargetFromSequences(keySequences) {
return '[' + KeytipConstants_1.DATAKTP_TARGET + '="' +
sequencesToID(keySequences) + '"]';
}
exports.ktpTargetFromSequences = ktpTargetFromSequences;
/**
* Constructs the data-ktp-execute-target attribute selector from a keytip ID.
*
* @param keytipId - ID of the Keytip.
* @returns String selector to use to query for the keytip execute target.
*/
function ktpTargetFromId(keytipId) {
return '[' + KeytipConstants_1.DATAKTP_EXECUTE_TARGET + '="' + keytipId + '"]';
}
exports.ktpTargetFromId = ktpTargetFromId;
/**
* Gets the aria-describedby value to put on the component with this keytip.
*
* @param keySequences - KeySequences of the keytip.
* @returns The aria-describedby value to set on the component with this keytip.
*/
function getAriaDescribedBy(keySequences) {
var describedby = ' ' + KeytipConstants_1.KTP_LAYER_ID;
if (!keySequences.length) {
// Return just the layer ID
return describedby;
}
return describedby + ' ' + sequencesToID(keySequences);
}
exports.getAriaDescribedBy = getAriaDescribedBy;
//# sourceMappingURL=KeytipUtils.js.map
/***/ }),
/***/ 34708:
"use strict";

/***/ }),
/***/ 71752:
"use strict";

exports.observeResize = void 0;
/**
* Wrapper for ResizeObserver, with fallback for browsers that don't support
ResizeObserver.
*
* Calls the onResize callback once layout is complete, and again whenever any of
the target(s) change size.
* Or if ResizeObserver isn't supported, calls the callback whenever the window
changes size.
*
* @param target - Either a single element, or array of elements to watch for size
changes.
* @param onResize - Callback to be notified when layout is complete, and when the
target(s) change size.
* If this browser supports ResizeObserver, the callback will be passed the
ResizeObserverEntry[] array.
* Otherwise, the entries array will be undefined, and you'll need to find
another way to get the element's size,
* (e.g. clientWidth/clientHeight or getBoundingClientRect).
*
* @returns A function to clean up the observer/listener.
*/
var observeResize = function (target, onResize) {
if (typeof ResizeObserver !== 'undefined') {
var observer_1 = new ResizeObserver(onResize);
if (Array.isArray(target)) {
target.forEach(function (t) { return observer_1.observe(t); });
}
else {
observer_1.observe(target);
}
return function () { return observer_1.disconnect(); };
}
else {
// Fallback for browsers that don't support ResizeObserver
var onResizeWrapper_1 = function () { return onResize(undefined); };
var win_1 = utilities_1.getWindow(Array.isArray(target) ? target[0] :
target);
if (!win_1) {
// Can't listen for resize if we can't get the window object
// Nothing to clean up
};
}
// Listen for the first animation frame, which will happen after layout is
complete
var animationFrameId_1 = win_1.requestAnimationFrame(onResizeWrapper_1);
win_1.addEventListener('resize', onResizeWrapper_1, false);
win_1.cancelAnimationFrame(animationFrameId_1);
win_1.removeEventListener('resize', onResizeWrapper_1, false);
};
}
};
exports.observeResize = observeResize;
//# sourceMappingURL=observeResize.js.map
/***/ }),
/***/ 45430:
"use strict";

exports.positionElement = exports.positionCard = exports.positionCallout =
exports.getOppositeEdge = exports.getMaxHeight = exports.getBoundsFromTargetWindow
= void 0;
var positioning_1 = __webpack_require__(72966);
Object.defineProperty(exports, "getBoundsFromTargetWindow", ({ enumerable: true,
get: function () { return positioning_1.getBoundsFromTargetWindow; } }));
Object.defineProperty(exports, "getMaxHeight", ({ enumerable: true, get: function
() { return positioning_1.getMaxHeight; } }));
Object.defineProperty(exports, "getOppositeEdge", ({ enumerable: true, get:
function () { return positioning_1.getOppositeEdge; } }));
Object.defineProperty(exports, "positionCallout", ({ enumerable: true, get:
function () { return positioning_1.positionCallout; } }));
Object.defineProperty(exports, "positionCard", ({ enumerable: true, get: function
() { return positioning_1.positionCard; } }));
Object.defineProperty(exports, "positionElement", ({ enumerable: true, get:
function () { return positioning_1.positionElement; } }));
/***/ }),
/***/ 72966:
"use strict";
var _a;
exports.getBoundsFromTargetWindow = exports.getOppositeEdge = exports.getMaxHeight
= exports.positionCard = exports.positionCallout = exports.positionElement =
exports.__positioningTestPackage = void 0;
var positioning_types_1 = __webpack_require__(71905);
function _createPositionData(targetEdge, alignmentEdge, isAuto) {
return {
targetEdge: targetEdge,
alignmentEdge: alignmentEdge,
isAuto: isAuto,
};
}
// Currently the beakPercent is set to 50 for all positions meaning that it should
tend to the center of the target
var DirectionalDictionary = (_a = {},
_a[DirectionalHint_1.DirectionalHint.topLeftEdge] =
_createPositionData(positioning_types_1.RectangleEdge.top,
positioning_types_1.RectangleEdge.left),
_a[DirectionalHint_1.DirectionalHint.topCenter] =
_createPositionData(positioning_types_1.RectangleEdge.top),
_a[DirectionalHint_1.DirectionalHint.topRightEdge] =
_createPositionData(positioning_types_1.RectangleEdge.top,
positioning_types_1.RectangleEdge.right),
_a[DirectionalHint_1.DirectionalHint.topAutoEdge] =
_createPositionData(positioning_types_1.RectangleEdge.top, undefined, true),
_a[DirectionalHint_1.DirectionalHint.bottomLeftEdge] =
_createPositionData(positioning_types_1.RectangleEdge.bottom,
positioning_types_1.RectangleEdge.left),
_a[DirectionalHint_1.DirectionalHint.bottomCenter] =
_createPositionData(positioning_types_1.RectangleEdge.bottom),
_a[DirectionalHint_1.DirectionalHint.bottomRightEdge] =
_createPositionData(positioning_types_1.RectangleEdge.bottom,
positioning_types_1.RectangleEdge.right),
_a[DirectionalHint_1.DirectionalHint.bottomAutoEdge] =
_createPositionData(positioning_types_1.RectangleEdge.bottom, undefined, true),
_a[DirectionalHint_1.DirectionalHint.leftTopEdge] =
_createPositionData(positioning_types_1.RectangleEdge.left,
positioning_types_1.RectangleEdge.top),
_a[DirectionalHint_1.DirectionalHint.leftCenter] =
_createPositionData(positioning_types_1.RectangleEdge.left),
_a[DirectionalHint_1.DirectionalHint.leftBottomEdge] =
_createPositionData(positioning_types_1.RectangleEdge.left,
positioning_types_1.RectangleEdge.bottom),
_a[DirectionalHint_1.DirectionalHint.rightTopEdge] =
_createPositionData(positioning_types_1.RectangleEdge.right,
positioning_types_1.RectangleEdge.top),
_a[DirectionalHint_1.DirectionalHint.rightCenter] =
_createPositionData(positioning_types_1.RectangleEdge.right),
_a[DirectionalHint_1.DirectionalHint.rightBottomEdge] =
_createPositionData(positioning_types_1.RectangleEdge.right,
positioning_types_1.RectangleEdge.bottom),
_a);
function _isRectangleWithinBounds(rect, boundingRect) {
if (rect.top < boundingRect.top) {
return false;
}
if (rect.bottom > boundingRect.bottom) {
return false;
}
if (rect.left < boundingRect.left) {
return false;
}
if (rect.right > boundingRect.right) {
return false;
}
return true;
}
/**
* Gets all of the edges of a rectangle that are outside of the given bounds.
* If there are no out of bounds edges it returns an empty array.
*/
function _getOutOfBoundsEdges(rect, boundingRect) {
var outOfBounds = [];
if (rect.top < boundingRect.top) {
outOfBounds.push(positioning_types_1.RectangleEdge.top);
}
if (rect.bottom > boundingRect.bottom) {
outOfBounds.push(positioning_types_1.RectangleEdge.bottom);
}
if (rect.left < boundingRect.left) {
outOfBounds.push(positioning_types_1.RectangleEdge.left);
}
if (rect.right > boundingRect.right) {
outOfBounds.push(positioning_types_1.RectangleEdge.right);
}
return outOfBounds;
}
function _getEdgeValue(rect, edge) {
return rect[positioning_types_1.RectangleEdge[edge]];
}
function _setEdgeValue(rect, edge, value) {
rect[positioning_types_1.RectangleEdge[edge]] = value;
return rect;
}
/**
* Returns the middle value of an edge. Only returns 1 value rather than xy
coordinates as
* the itself already contains the other coordinate.
* For instance, a bottom edge's current value is it's y coordinate, so the number
returned is the x.
*/
function _getCenterValue(rect, edge) {
var edges = _getFlankingEdges(edge);
return (_getEdgeValue(rect, edges.positiveEdge) + _getEdgeValue(rect,
edges.negativeEdge)) / 2;
}
/**
* Flips the value depending on the edge.
* If the edge is a "positive" edge, Top or Left, then the value should stay as it
is.
* If the edge is a "negative" edge, Bottom or Right, then the value should be
flipped.
* This is to account for the fact that the coordinates are effectively reserved in
certain cases for the
* "negative" edges.
*
* For example, when testing to see if a bottom edge 1 is within the bounds of
another bottom edge 2:
* If edge 1 is greater than edge 2 then it is out of bounds. This is reversed for
top edge 1 and top edge 2.
* If top edge 1 is less than edge 2 then it is out of bounds.
*/
function _getRelativeEdgeValue(edge, value) {
if (edge > 0) {
return value;
}
else {
return value * -1;
}
}
function _getRelativeRectEdgeValue(edge, rect) {
return _getRelativeEdgeValue(edge, _getEdgeValue(rect, edge));
}
function _getRelativeEdgeDifference(rect, hostRect, edge) {
var edgeDifference = _getEdgeValue(rect, edge) - _getEdgeValue(hostRect, edge);
return _getRelativeEdgeValue(edge, edgeDifference);
}
/**
* Moves the edge of a rectangle to the value given. It only moves the edge in a
linear direction based on that edge.
* For example, if it's a bottom edge it will only change y coordinates.
* if maintainSize is set to false, it will only adjust the specified edge value
*/
function _moveEdge(rect, edge, newValue, maintainSize) {
if (maintainSize === void 0) { maintainSize = true; }
var difference = _getEdgeValue(rect, edge) - newValue;
var returnRect = _setEdgeValue(rect, edge, newValue);
if (maintainSize) {
returnRect = _setEdgeValue(rect, edge * -1, _getEdgeValue(rect, edge * -1)
- difference);
}
return returnRect;
}
/**
* Aligns the edge on the passed in rect to the target. If there is a gap then it
will have that space between the two.
*/
function _alignEdges(rect, target, edge, gap) {
if (gap === void 0) { gap = 0; }
return _moveEdge(rect, edge, _getEdgeValue(target, edge) +
_getRelativeEdgeValue(edge, gap));
}
/**
* Aligns the targetEdge on the passed in target to the rects corresponding
opposite edge.
* For instance if targetEdge is bottom, then the rects top will be moved to match
it.
*/
function _alignOppositeEdges(rect, target, targetEdge, gap) {
if (gap === void 0) { gap = 0; }
var oppositeEdge = targetEdge * -1;
var adjustedGap = _getRelativeEdgeValue(oppositeEdge, gap);
return _moveEdge(rect, targetEdge * -1, _getEdgeValue(target, targetEdge) +
adjustedGap);
}
/**
* Tests to see if the given edge is within the bounds of the given rectangle.
*/
function _isEdgeInBounds(rect, bounds, edge) {
var adjustedRectValue = _getRelativeRectEdgeValue(edge, rect);
return adjustedRectValue > _getRelativeRectEdgeValue(edge, bounds);
}
/**
* Returns a measure of how much a rectangle is out of bounds for a given
alignment;
* this can be used to compare which rectangle is more or less out of bounds.
* A value of 0 means the rectangle is entirely in bounds
*/
function _getOutOfBoundsDegree(rect, bounds) {
var breakingEdges = _getOutOfBoundsEdges(rect, bounds);
var total = 0;
for (var _i = 0, breakingEdges_1 = breakingEdges; _i < breakingEdges_1.length;
_i++) {
var edge = breakingEdges_1[_i];
total += Math.pow(_getRelativeEdgeDifference(rect, bounds, edge), 2);
}
return total;
}
/**
* Attempts to move the rectangle through various sides of the target to find a
place to fit.
* If no fit is found, the least bad option should be returned.
*/
function _flipToFit(rect, target, bounding, positionData, gap) {
if (gap === void 0) { gap = 0; }
var directions = [
positioning_types_1.RectangleEdge.left,
positioning_types_1.RectangleEdge.right,
positioning_types_1.RectangleEdge.bottom,
positioning_types_1.RectangleEdge.top,
];
// In RTL page, RectangleEdge.right has a higher priority than
RectangleEdge.left, so the order should be updated.
if (Utilities_1.getRTL()) {
directions[0] *= -1;
directions[1] *= -1;
}
var currentEstimate = rect;
var currentEdge = positionData.targetEdge;
var currentAlignment = positionData.alignmentEdge;
// keep track of least bad option, in case no sides fit
var oobDegree;
var bestEdge = currentEdge;
var bestAlignment = currentAlignment;
// Keep switching sides until one is found with enough space.
// If all sides don't fit then return the unmodified element.
for (var i = 0; i < 4; i++) {
if (!_isEdgeInBounds(currentEstimate, bounding, currentEdge)) {
// update least-bad edges
var currentOOBDegree = _getOutOfBoundsDegree(currentEstimate,
bounding);
if (!oobDegree || currentOOBDegree < oobDegree) {
oobDegree = currentOOBDegree;
bestEdge = currentEdge;
bestAlignment = currentAlignment;
}
directions.splice(directions.indexOf(currentEdge), 1);
if (directions.length > 0) {
if (directions.indexOf(currentEdge * -1) > -1) {
currentEdge = currentEdge * -1;
}
else {
currentAlignment = currentEdge;
currentEdge = directions.slice(-1)[0];
}
currentEstimate = _estimatePosition(rect, target, { targetEdge:
currentEdge, alignmentEdge: currentAlignment }, gap);
}
}
else {
return {
elementRectangle: currentEstimate,
targetEdge: currentEdge,
alignmentEdge: currentAlignment,
};
}
}
// nothing fits, use least-bad option
currentEstimate = _estimatePosition(rect, target, { targetEdge: bestEdge,
alignmentEdge: bestAlignment }, gap);
return {
elementRectangle: currentEstimate,
targetEdge: bestEdge,
alignmentEdge: bestAlignment,
};
}
/**
* Flips only the alignment edge of an element rectangle. This is used instead of
nudging the alignment edges
* into position, when àlignTargetEdge` is specified.
*/
function _flipAlignmentEdge(elementEstimate, target, gap, coverTarget) {
var alignmentEdge = elementEstimate.alignmentEdge, targetEdge =
elementEstimate.targetEdge, elementRectangle = elementEstimate.elementRectangle;
var oppositeEdge = alignmentEdge * -1;
var newEstimate = _estimatePosition(elementRectangle, target, { targetEdge:
targetEdge, alignmentEdge: oppositeEdge }, gap, coverTarget);
return {
elementRectangle: newEstimate,
alignmentEdge: oppositeEdge,
};
}
/**
* Adjusts a element rectangle to fit within the bounds given. If
directionalHintFixed or covertarget is passed in
* then the element will not flip sides on the target. They will, however, be
nudged to fit within the bounds given.
*/
function _adjustFitWithinBounds(element, target, bounding, positionData, gap,
directionalHintFixed, coverTarget) {
if (gap === void 0) { gap = 0; }
var alignmentEdge = positionData.alignmentEdge, alignTargetEdge =
positionData.alignTargetEdge;
var elementEstimate = {
elementRectangle: element,
targetEdge: positionData.targetEdge,
alignmentEdge: alignmentEdge,
};
if (!directionalHintFixed && !coverTarget) {
elementEstimate = _flipToFit(element, target, bounding, positionData, gap);
}
var outOfBounds = _getOutOfBoundsEdges(elementEstimate.elementRectangle,
bounding);
// if directionalHintFixed is specified, we need to force the target edge to
not change
// we need *-1 because targetEdge refers to the target's edge; the callout edge
is the opposite
var fixedEdge = directionalHintFixed ? -elementEstimate.targetEdge : undefined;
if (outOfBounds.length > 0) {
if (alignTargetEdge) {
// The edge opposite to the alignment edge might be out of bounds.
// Flip alignment to see if we can get it within bounds.
if (elementEstimate.alignmentEdge &&
outOfBounds.indexOf(elementEstimate.alignmentEdge * -1) > -1) {
var flippedElementEstimate = _flipAlignmentEdge(elementEstimate,
target, gap, coverTarget);
if
(_isRectangleWithinBounds(flippedElementEstimate.elementRectangle, bounding)) {
return flippedElementEstimate;
}
else {
// If the flipped elements edges are still out of bounds, try
nudging it.
elementEstimate =
_alignOutOfBoundsEdges(_getOutOfBoundsEdges(flippedElementEstimate.elementRectangle
, bounding), elementEstimate, bounding, fixedEdge);
}
}
else {
elementEstimate = _alignOutOfBoundsEdges(outOfBounds,
elementEstimate, bounding, fixedEdge);
}
}
else {
elementEstimate = _alignOutOfBoundsEdges(outOfBounds, elementEstimate,
bounding, fixedEdge);
}
}
return elementEstimate;
}
/**
* Iterates through a list of out of bounds edges and tries to nudge and align
them.
* @param outOfBoundsEdges - Array of edges that are out of bounds
* @param elementEstimate - The current element positioning estimate
* @param bounding - The current bounds
* @param preserveEdge - Specify an edge that should not be modified
*/
function _alignOutOfBoundsEdges(outOfBoundsEdges, elementEstimate, bounding,
preserveEdge) {
for (var _i = 0, outOfBoundsEdges_1 = outOfBoundsEdges; _i <
outOfBoundsEdges_1.length; _i++) {
var direction = outOfBoundsEdges_1[_i];
var edgeAttempt = void 0;
// if preserveEdge is specified, do not call _alignEdges, skip directly to
_moveEdge
// this is because _alignEdges will move the opposite edge
if (preserveEdge && preserveEdge === direction * -1) {
edgeAttempt = _moveEdge(elementEstimate.elementRectangle, direction,
_getEdgeValue(bounding, direction), false);
elementEstimate.forcedInBounds = true;
}
else {
edgeAttempt = _alignEdges(elementEstimate.elementRectangle, bounding,
direction);
var inBounds = _isEdgeInBounds(edgeAttempt, bounding, direction * -1);
// only update estimate if the attempt didn't break out of the opposite
bounding edge
if (!inBounds) {
edgeAttempt = _moveEdge(edgeAttempt, direction * -1,
_getEdgeValue(bounding, direction * -1), false);
elementEstimate.forcedInBounds = true;
}
}
elementEstimate.elementRectangle = edgeAttempt;
}
return elementEstimate;
}
/**
* Moves the middle point on an edge to the point given.
* Only moves in one direction. For instance if a bottom edge is passed in, then
* the bottom edge will be moved in the x axis to match the point.
*/
function _centerEdgeToPoint(rect, edge, point) {
var positiveEdge = _getFlankingEdges(edge).positiveEdge;
var elementMiddle = _getCenterValue(rect, edge);
var distanceToMiddle = elementMiddle - _getEdgeValue(rect, positiveEdge);
return _moveEdge(rect, positiveEdge, point - distanceToMiddle);
}
/**
* Moves the element rectangle to be appropriately positioned relative to a given
target.
* Does not flip or adjust the element.
*/
function _estimatePosition(elementToPosition, target, positionData, gap,
coverTarget) {
if (gap === void 0) { gap = 0; }
var estimatedElementPosition = new
Utilities_2.Rectangle(elementToPosition.left, elementToPosition.right,
elementToPosition.top, elementToPosition.bottom);
var alignmentEdge = positionData.alignmentEdge, targetEdge =
positionData.targetEdge;
var elementEdge = coverTarget ? targetEdge : targetEdge * -1;
estimatedElementPosition = coverTarget
? _alignEdges(estimatedElementPosition, target, targetEdge, gap)
: _alignOppositeEdges(estimatedElementPosition, target, targetEdge, gap);
// if no alignment edge is provided it's supposed to be centered.
if (!alignmentEdge) {
var targetMiddlePoint = _getCenterValue(target, targetEdge);
estimatedElementPosition = _centerEdgeToPoint(estimatedElementPosition,
elementEdge, targetMiddlePoint);
}
else {
estimatedElementPosition = _alignEdges(estimatedElementPosition, target,
alignmentEdge);
}
return estimatedElementPosition;
}
/**
* Returns the non-opposite edges of the target edge.
* For instance if bottom is passed in then left and right will be returned.
*/
function _getFlankingEdges(edge) {
if (edge === positioning_types_1.RectangleEdge.top || edge ===
positioning_types_1.RectangleEdge.bottom) {
return {
positiveEdge: positioning_types_1.RectangleEdge.left,
negativeEdge: positioning_types_1.RectangleEdge.right,
};
}
else {
return {
positiveEdge: positioning_types_1.RectangleEdge.top,
negativeEdge: positioning_types_1.RectangleEdge.bottom,
};
}
}
/**
* Retrieve the final value for the return edge of èlementRectangle`. If the
èlementRectangle` is closer to one side
* of the bounds versus the other, the return edge is flipped to grow inward.
*/
function _finalizeReturnEdge(elementRectangle, returnEdge, bounds) {
if (bounds &&
Math.abs(_getRelativeEdgeDifference(elementRectangle, bounds, returnEdge))
>
Math.abs(_getRelativeEdgeDifference(elementRectangle, bounds,
returnEdge * -1))) {
return returnEdge * -1;
}
return returnEdge;
}
/**
* Whether or not the considered edge of the elementRectangle is lying on the edge
of the bounds
* @param elementRectangle The rectangle whose edge we are considering
* @param bounds The rectangle marking the bounds
* @param edge The target edge we're considering
* @returns If the target edge of the elementRectangle is in the same location as
that edge of the bounds
*/
function _isEdgeOnBounds(elementRectangle, edge, bounds) {
return bounds !== undefined && _getEdgeValue(elementRectangle, edge) ===
_getEdgeValue(bounds, edge);
}
/**
* Finalizes the element position based on the hostElement. Only returns the
* rectangle values to position such that they are anchored to the target.
* This helps prevent resizing from looking very strange.
* For instance, if the target edge is top and aligned with the left side then
* the bottom and left values are returned so as the Callout shrinks it shrinks
towards that corner.
*/
function _finalizeElementPosition(elementRectangle, hostElement, targetEdge,
bounds, alignmentEdge, coverTarget, doNotFinalizeReturnEdge, forceWithinBounds) {
var returnValue = {};
var hostRect = _getRectangleFromElement(hostElement);
var elementEdge = coverTarget ? targetEdge : targetEdge * -1;
var returnEdge = alignmentEdge ? alignmentEdge :
_getFlankingEdges(targetEdge).positiveEdge;
// If we are finalizing the return edge, choose the edge such that we grow away
from the bounds
// If we are not finalizing the return edge but the opposite edge is flush
against the bounds,
// choose that as the anchor edge so the element rect can grow away from the
bounds' edge
// In this case there will not be a visual difference because there is no more
room for the elementRectangle to grow
// in the usual direction
if (!doNotFinalizeReturnEdge || _isEdgeOnBounds(elementRectangle,
getOppositeEdge(returnEdge), bounds)) {
returnEdge = _finalizeReturnEdge(elementRectangle, returnEdge, bounds);
}
returnValue[positioning_types_1.RectangleEdge[elementEdge]] =
_getRelativeEdgeDifference(elementRectangle, hostRect, elementEdge);
returnValue[positioning_types_1.RectangleEdge[returnEdge]] =
_getRelativeEdgeDifference(elementRectangle, hostRect, returnEdge);
// if the positioned element will still overflow, return all four edges with
in-bounds values
if (forceWithinBounds) {
returnValue[positioning_types_1.RectangleEdge[elementEdge * -1]] =
_getRelativeEdgeDifference(elementRectangle, hostRect, elementEdge * -1);
returnValue[positioning_types_1.RectangleEdge[returnEdge * -1]] =
_getRelativeEdgeDifference(elementRectangle, hostRect, returnEdge * -1);
}
return returnValue;
}
// Since the beak is rotated 45 degrees the actual height/width is the length of
the diagonal.
// We still want to position the beak based on it's midpoint which does not change.
It will
// be at (beakwidth / 2, beakwidth / 2)
function _calculateActualBeakWidthInPixels(beakWidth) {
return Math.sqrt(beakWidth * beakWidth * 2);
}
/**
* Returns the appropriate IPositionData based on the props altered for RTL.
* If directionalHintForRTL is passed in that is used if the page is RTL.
* If directionalHint is specified, no directionalHintForRTL is available, and the
page is RTL, the hint will be
* flipped (e.g. bottomLeftEdge would become bottomRightEdge).
*
* If there is no directionalHint passed in, bottomAutoEdge is chosen
automatically.
*/
function _getPositionData(directionalHint, directionalHintForRTL,
previousPositions) {
if (directionalHint === void 0) { directionalHint =
DirectionalHint_1.DirectionalHint.bottomAutoEdge; }
if (previousPositions) {
return {
alignmentEdge: previousPositions.alignmentEdge,
isAuto: previousPositions.isAuto,
targetEdge: previousPositions.targetEdge,
};
}
var positionInformation = tslib_1.__assign({},
DirectionalDictionary[directionalHint]);
if (Utilities_1.getRTL()) {
// If alignment edge exists and that alignment edge is -2 or 2, right or
left, then flip it.
if (positionInformation.alignmentEdge && positionInformation.alignmentEdge
% 2 === 0) {
positionInformation.alignmentEdge = positionInformation.alignmentEdge *
-1;
}
return directionalHintForRTL !== undefined ?
DirectionalDictionary[directionalHintForRTL] : positionInformation;
}
return positionInformation;
}
/**
* Gets the alignment data for the given information. This only really matters if
the positioning is Auto.
* If it is auto then the alignmentEdge should be chosen based on the target edge's
position relative to
* the center of the page.
*/
function _getAlignmentData(positionData, target, boundingRect, coverTarget,
alignTargetEdge) {
if (positionData.isAuto) {
positionData.alignmentEdge = getClosestEdge(positionData.targetEdge,
target, boundingRect);
}
positionData.alignTargetEdge = alignTargetEdge;
return positionData;
}
function getClosestEdge(targetEdge, target, boundingRect) {
var targetCenter = _getCenterValue(target, targetEdge);
var boundingCenter = _getCenterValue(boundingRect, targetEdge);
var _a = _getFlankingEdges(targetEdge), positiveEdge = _a.positiveEdge,
negativeEdge = _a.negativeEdge;
if (targetCenter <= boundingCenter) {
return positiveEdge;
}
else {
return negativeEdge;
}
}
function _positionElementWithinBounds(elementToPosition, target, bounding,
positionData, gap, directionalHintFixed, coverTarget) {
var estimatedElementPosition = _estimatePosition(elementToPosition, target,
positionData, gap, coverTarget);
if (_isRectangleWithinBounds(estimatedElementPosition, bounding)) {
return {
elementRectangle: estimatedElementPosition,
targetEdge: positionData.targetEdge,
alignmentEdge: positionData.alignmentEdge,
};
}
else {
return _adjustFitWithinBounds(estimatedElementPosition, target, bounding,
positionData, gap, directionalHintFixed, coverTarget);
}
}
function _finalizeBeakPosition(elementPosition, positionedBeak, bounds) {
var targetEdge = elementPosition.targetEdge * -1;
// The "host" element that we will use to help position the beak.
var actualElement = new Utilities_2.Rectangle(0,
elementPosition.elementRectangle.width, 0,
elementPosition.elementRectangle.height);
var returnValue = {};
var returnEdge = _finalizeReturnEdge(elementPosition.elementRectangle,
elementPosition.alignmentEdge ? elementPosition.alignmentEdge :
_getFlankingEdges(targetEdge).positiveEdge, bounds);
// only show the beak if the callout is not fully covering the target
var beakEdgeDifference =
_getRelativeEdgeDifference(elementPosition.elementRectangle,
elementPosition.targetRectangle, targetEdge);
var showBeak = beakEdgeDifference > Math.abs(_getEdgeValue(positionedBeak,
targetEdge));
returnValue[positioning_types_1.RectangleEdge[targetEdge]] =
_getEdgeValue(positionedBeak, targetEdge);
returnValue[positioning_types_1.RectangleEdge[returnEdge]] =
_getRelativeEdgeDifference(positionedBeak, actualElement, returnEdge);
return {
elementPosition: tslib_1.__assign({}, returnValue),
closestEdge: getClosestEdge(elementPosition.targetEdge, positionedBeak,
actualElement),
hideBeak: !showBeak,
};
}
function _positionBeak(beakWidth, elementPosition) {
var target = elementPosition.targetRectangle;
/**
* Note about beak positioning: The actual beak width only matters for getting
the gap between the callout and
* target, it does not impact the beak placement within the callout. For
example example, if the beakWidth is 8,
* then the actual beakWidth is sqrroot(8^2 + 8^2) = 11.31x11.31. So the
callout will need to be an extra 3 pixels
* away from its target. While the beak is being positioned in the callout it
still acts as though it were 8x8.
*/
var _a = _getFlankingEdges(elementPosition.targetEdge), positiveEdge =
_a.positiveEdge, negativeEdge = _a.negativeEdge;
var beakTargetPoint = _getCenterValue(target, elementPosition.targetEdge);
var elementBounds = new Utilities_2.Rectangle(beakWidth / 2,
elementPosition.elementRectangle.width - beakWidth / 2, beakWidth / 2,
elementPosition.elementRectangle.height - beakWidth / 2);
var beakPosition = new Utilities_2.Rectangle(0, beakWidth, 0, beakWidth);
beakPosition = _moveEdge(beakPosition, elementPosition.targetEdge * -1, -
beakWidth / 2);
beakPosition = _centerEdgeToPoint(beakPosition, elementPosition.targetEdge * -
1, beakTargetPoint - _getRelativeRectEdgeValue(positiveEdge,
elementPosition.elementRectangle));
if (!_isEdgeInBounds(beakPosition, elementBounds, positiveEdge)) {
beakPosition = _alignEdges(beakPosition, elementBounds, positiveEdge);
}
else if (!_isEdgeInBounds(beakPosition, elementBounds, negativeEdge)) {
beakPosition = _alignEdges(beakPosition, elementBounds, negativeEdge);
}
return beakPosition;
}
function _getRectangleFromElement(element) {
var clientRect = element.getBoundingClientRect();
return new Utilities_2.Rectangle(clientRect.left, clientRect.right,
clientRect.top, clientRect.bottom);
}
function _getRectangleFromIRect(rect) {
return new Utilities_2.Rectangle(rect.left, rect.right, rect.top, rect.bottom);
}
function _getTargetRect(bounds, target) {
var targetRectangle;
if (target) {
// eslint-disable-next-line no-extra-boolean-cast
if (!!target.preventDefault) {
var ev = target;
targetRectangle = new Utilities_2.Rectangle(ev.clientX, ev.clientX,
ev.clientY, ev.clientY);
// eslint-disable-next-line no-extra-boolean-cast
}
else if (!!target.getBoundingClientRect) {
targetRectangle = _getRectangleFromElement(target);
// HTMLImgElements can have x and y values. The check for it being a
point must go last.
}
else {
var rectOrPoint = target;
var left = rectOrPoint.left || rectOrPoint.x;
var top_1 = rectOrPoint.top || rectOrPoint.y;
var right = rectOrPoint.right || left;
var bottom = rectOrPoint.bottom || top_1;
targetRectangle = new Utilities_2.Rectangle(left, right, top_1,
bottom);
}
if (!_isRectangleWithinBounds(targetRectangle, bounds)) {
var outOfBounds = _getOutOfBoundsEdges(targetRectangle, bounds);
for (var _i = 0, outOfBounds_1 = outOfBounds; _i <
outOfBounds_1.length; _i++) {
var direction = outOfBounds_1[_i];
targetRectangle[positioning_types_1.RectangleEdge[direction]] =
bounds[positioning_types_1.RectangleEdge[direction]];
}
}
}
else {
targetRectangle = new Utilities_2.Rectangle(0, 0, 0, 0);
}
return targetRectangle;
}
/**
* If max height is less than zero it returns the bounds height instead.
*/
function _getMaxHeightFromTargetRectangle(targetRectangle, targetEdge, gapSpace,
bounds, coverTarget) {
var maxHeight = 0;
var directionalHint = DirectionalDictionary[targetEdge];
// If cover target is set, then the max height should be calculated using the
opposite of the target edge since
// that's the direction that the callout will expand in.
// For instance, if the directionalhint is bottomLeftEdge then the callout will
position so it's bottom edge
// is aligned with the bottom of the target and expand up towards the top of
the screen and the calculated max height
// is (bottom of target) - (top of screen) - gapSpace.
var target = coverTarget ? directionalHint.targetEdge * -1 :
directionalHint.targetEdge;
if (target === positioning_types_1.RectangleEdge.top) {
maxHeight = _getEdgeValue(targetRectangle, directionalHint.targetEdge) -
bounds.top - gapSpace;
}
else if (target === positioning_types_1.RectangleEdge.bottom) {
maxHeight = bounds.bottom - _getEdgeValue(targetRectangle,
directionalHint.targetEdge) - gapSpace;
}
else {
maxHeight = bounds.bottom - targetRectangle.top - gapSpace;
}
return maxHeight > 0 ? maxHeight : bounds.height;
}
function _positionElementRelative(props, elementToPosition, boundingRect,
previousPositions) {
var gap = props.gapSpace ? props.gapSpace : 0;
var targetRect = _getTargetRect(boundingRect, props.target);
var positionData = _getAlignmentData(_getPositionData(props.directionalHint,
props.directionalHintForRTL, previousPositions), targetRect, boundingRect,
props.coverTarget, props.alignTargetEdge);
var positionedElement =
_positionElementWithinBounds(_getRectangleFromElement(elementToPosition),
targetRect, boundingRect, positionData, gap, props.directionalHintFixed,
props.coverTarget);
return tslib_1.__assign(tslib_1.__assign({}, positionedElement),
{ targetRectangle: targetRect });
}
function _finalizePositionData(positionedElement, hostElement, bounds, coverTarget,
doNotFinalizeReturnEdge) {
var finalizedElement =
_finalizeElementPosition(positionedElement.elementRectangle, hostElement,
positionedElement.targetEdge, bounds, positionedElement.alignmentEdge, coverTarget,
doNotFinalizeReturnEdge, positionedElement.forcedInBounds);
return {
elementPosition: finalizedElement,
targetEdge: positionedElement.targetEdge,
alignmentEdge: positionedElement.alignmentEdge,
};
}
function _positionElement(props, hostElement, elementToPosition, previousPositions)
{
var boundingRect = props.bounds
? _getRectangleFromIRect(props.bounds)
: new Utilities_2.Rectangle(0, window.innerWidth -
Utilities_1.getScrollbarWidth(), 0, window.innerHeight);
var positionedElement = _positionElementRelative(props, elementToPosition,
boundingRect, previousPositions);
return _finalizePositionData(positionedElement, hostElement, boundingRect,
props.coverTarget);
}
function _positionCallout(props, hostElement, callout, previousPositions,
doNotFinalizeReturnEdge) {
var beakWidth = props.isBeakVisible ? props.beakWidth || 0 : 0;
var gap = _calculateActualBeakWidthInPixels(beakWidth) / 2 + (props.gapSpace ?
props.gapSpace : 0);
var positionProps = props;
positionProps.gapSpace = gap;
var boundingRect = props.bounds
? _getRectangleFromIRect(props.bounds)
var positionedElement = _positionElementRelative(positionProps, callout,
boundingRect, previousPositions);
var beakPositioned = _positionBeak(beakWidth, positionedElement);
var finalizedBeakPosition = _finalizeBeakPosition(positionedElement,
beakPositioned, boundingRect);
_finalizePositionData(positionedElement, hostElement, boundingRect,
props.coverTarget, doNotFinalizeReturnEdge)), { beakPosition: finalizedBeakPosition
});
}
function _positionCard(props, hostElement, callout, previousPositions) {
return _positionCallout(props, hostElement, callout, previousPositions, true);
}
// END PRIVATE FUNCTIONS
exports.__positioningTestPackage = {
_finalizePositionData: _finalizePositionData,
_finalizeBeakPosition: _finalizeBeakPosition,
_calculateActualBeakWidthInPixels: _calculateActualBeakWidthInPixels,
_positionElementWithinBounds: _positionElementWithinBounds,
_positionBeak: _positionBeak,
_getPositionData: _getPositionData,
_getMaxHeightFromTargetRectangle: _getMaxHeightFromTargetRectangle,
};
/**
* Used to position an element relative to the given positioning props.
* If positioning has been completed before, previousPositions can be passed to
ensure that the positioning element
* repositions based on its previous targets rather than starting with
directionalhint.
*/
function positionElement(props, hostElement, elementToPosition, previousPositions)
{
return _positionElement(props, hostElement, elementToPosition,
previousPositions);
}
exports.positionElement = positionElement;
function positionCallout(props, hostElement, elementToPosition, previousPositions)
{
return _positionCallout(props, hostElement, elementToPosition,
previousPositions);
}
exports.positionCallout = positionCallout;
function positionCard(props, hostElement, elementToPosition, previousPositions) {
return _positionCard(props, hostElement, elementToPosition, previousPositions);
}
exports.positionCard = positionCard;
/**
* Gets the maximum height that a rectangle can have in order to fit below or above
a target.
* If the directional hint specifies a left or right edge (i.e. leftCenter) it will
limit the height to the topBorder
* of the target given.
* If no bounds are provided then the window is treated as the bounds.
*/
function getMaxHeight(target, targetEdge, gapSpace, bounds, coverTarget) {
if (gapSpace === void 0) { gapSpace = 0; }
var mouseTarget = target;
var elementTarget = target;
var rectOrPointTarget = target;
var targetRect;
var boundingRectangle = bounds
? _getRectangleFromIRect(bounds)
var left = rectOrPointTarget.left || rectOrPointTarget.x;
var top = rectOrPointTarget.top || rectOrPointTarget.y;
var right = rectOrPointTarget.right || left;
var bottom = rectOrPointTarget.bottom || top;
// eslint-disable-next-line no-extra-boolean-cast -- may not actually be a
MouseEvent
if (!!mouseTarget.stopPropagation) {
targetRect = new Utilities_2.Rectangle(mouseTarget.clientX,
mouseTarget.clientX, mouseTarget.clientY, mouseTarget.clientY);
}
else if (left !== undefined && top !== undefined) {
targetRect = new Utilities_2.Rectangle(left, right, top, bottom);
}
else {
targetRect = _getRectangleFromElement(elementTarget);
}
return _getMaxHeightFromTargetRectangle(targetRect, targetEdge, gapSpace,
boundingRectangle, coverTarget);
}
exports.getMaxHeight = getMaxHeight;
/**
* Returns the opposite edge of the given RectangleEdge.
*/
function getOppositeEdge(edge) {
return edge * -1;
}
exports.getOppositeEdge = getOppositeEdge;
function _getBoundsFromTargetWindow(target, targetWindow) {
var segments = undefined;
if (targetWindow.getWindowSegments) {
segments = targetWindow.getWindowSegments();
}
// Identify if we're dealing with single screen scenarios.
if (segments === undefined || segments.length <= 1) {
return {
top: 0,
left: 0,
right: targetWindow.innerWidth,
bottom: targetWindow.innerHeight,
width: targetWindow.innerWidth,
height: targetWindow.innerHeight,
};
}
// Logic for determining dual screen scenarios.
var x = 0;
var y = 0;
// If the target is an Element get coordinates for its center.
if (target !== null && !!target.getBoundingClientRect) {
var clientRect = target.getBoundingClientRect();
x = (clientRect.left + clientRect.right) / 2;
y = (clientRect.top + clientRect.bottom) / 2;
}
// If the target is not null get x-axis and y-axis coordinates directly.
else if (target !== null) {
x = target.left || target.x;
y = target.top || target.y;
}
var bounds = { top: 0, left: 0, right: 0, bottom: 0, width: 0, height: 0 };
// Define which window segment are the coordinates in and calculate bounds
based on that.
for (var _i = 0, segments_1 = segments; _i < segments_1.length; _i++) {
var segment = segments_1[_i];
if (x && segment.left <= x && segment.right >= x && y && segment.top <= y
&& segment.bottom >= y) {
bounds = {
top: segment.top,
left: segment.left,
right: segment.right,
bottom: segment.bottom,
width: segment.width,
height: segment.height,
};
}
}
return bounds;
}
function getBoundsFromTargetWindow(target, targetWindow) {
return _getBoundsFromTargetWindow(target, targetWindow);
}
exports.getBoundsFromTargetWindow = getBoundsFromTargetWindow;
//# sourceMappingURL=positioning.js.map
/***/ }),
/***/ 71905:
"use strict";

exports.Position = exports.RectangleEdge = void 0;
var RectangleEdge;
(function (RectangleEdge) {
RectangleEdge[RectangleEdge["top"] = 1] = "top";
RectangleEdge[RectangleEdge["bottom"] = -1] = "bottom";
RectangleEdge[RectangleEdge["left"] = 2] = "left";
RectangleEdge[RectangleEdge["right"] = -2] = "right";
})(RectangleEdge = exports.RectangleEdge || (exports.RectangleEdge = {}));
var Position;
(function (Position) {
Position[Position["top"] = 0] = "top";
Position[Position["bottom"] = 1] = "bottom";
Position[Position["start"] = 2] = "start";
Position[Position["end"] = 3] = "end";
})(Position = exports.Position || (exports.Position = {}));
//# sourceMappingURL=positioning.types.js.map
/***/ }),
/***/ 60115:
"use strict";

//# sourceMappingURL=SelectableDroppableText.types.js.map
/***/ }),
/***/ 23767:
"use strict";
exports.getAllSelectedOptions = void 0;
function getAllSelectedOptions(options, selectedIndices) {
var selectedOptions = [];
for (var _i = 0, selectedIndices_1 = selectedIndices; _i <
selectedIndices_1.length; _i++) {
var index = selectedIndices_1[_i];
var option = options[index];
if (option) {
selectedOptions.push(option);
}
}
return selectedOptions;
}
exports.getAllSelectedOptions = getAllSelectedOptions;
//# sourceMappingURL=SelectableOption.js.map
/***/ }),
/***/ 20163:
"use strict";

exports.SelectableOptionMenuItemType = void 0;
var SelectableOptionMenuItemType;
(function (SelectableOptionMenuItemType) {
SelectableOptionMenuItemType[SelectableOptionMenuItemType["Normal"] = 0] =
"Normal";
SelectableOptionMenuItemType[SelectableOptionMenuItemType["Divider"] = 1] =
"Divider";
SelectableOptionMenuItemType[SelectableOptionMenuItemType["Header"] = 2] =
"Header";
SelectableOptionMenuItemType[SelectableOptionMenuItemType["SelectAll"] = 3] =
"SelectAll";
})(SelectableOptionMenuItemType = exports.SelectableOptionMenuItemType ||
(exports.SelectableOptionMenuItemType = {}));
//# sourceMappingURL=SelectableOption.types.js.map
/***/ }),
/***/ 90052:
"use strict";

/***/ }),
/***/ 6042:
"use strict";

exports.Selection = void 0;
return utilities_1.Selection; } }));
/***/ }),
/***/ 6871:
"use strict";

exports.SelectionZone = void 0;
var interfaces_1 = __webpack_require__(62880);
// Selection definitions:
//
// Anchor index: the point from which a range selection starts.
// Focus index: the point from which layout movement originates from.
//
// These two can differ. Tests:
//
// If you start at index 5
// Shift click to index 10
// The focus is 10, the anchor is 5.
// If you shift click at index 0
// The anchor remains at 5, the items between 0 and 5 are selected and
everything else is cleared.
// If you click index 8
// The anchor and focus are set to 8.
var SELECTION_DISABLED_ATTRIBUTE_NAME = 'data-selection-disabled';
var SELECTION_INDEX_ATTRIBUTE_NAME = 'data-selection-index';
var SELECTION_TOGGLE_ATTRIBUTE_NAME = 'data-selection-toggle';
var SELECTION_INVOKE_ATTRIBUTE_NAME = 'data-selection-invoke';
var SELECTION_INVOKE_TOUCH_ATTRIBUTE_NAME = 'data-selection-touch-invoke';
var SELECTALL_TOGGLE_ALL_ATTRIBUTE_NAME = 'data-selection-all-toggle';
var SELECTION_SELECT_ATTRIBUTE_NAME = 'data-selection-select';
/**
* {@docCategory Selection}
*/
var SelectionZone = /** @class */ (function (_super) {
tslib_1.__extends(SelectionZone, _super);
function SelectionZone(props) {
/**
* In some cases, the consuming scenario requires to set focus on a row
without having SelectionZone
* react to the event. Note that focus events in IE \<= 11 will occur
asynchronously after .focus() has
* been called on an element, so we need a flag to store the idea that we
will bypass the "next"
* focus event that occurs. This method does that.
*/
_this.ignoreNextFocus = function () {
_this._handleNextFocus(false);
};
_this._onSelectionChange = function () {
var isModal = selection.isModal && selection.isModal();
_this.setState({
isModal: isModal,
});
};
_this._onMouseDownCapture = function (ev) {
if (document.activeElement !== target && !
Utilities_1.elementContains(document.activeElement, target)) {
_this.ignoreNextFocus();
return;
}
if (!Utilities_1.elementContains(target, _this._root.current)) {
return;
}
while (target !== _this._root.current) {
if (_this._hasAttribute(target, SELECTION_INVOKE_ATTRIBUTE_NAME)) {
_this.ignoreNextFocus();
break;
}
}
};
/**
* When we focus an item, for single/multi select scenarios, we should try
to select it immediately
* as long as the focus did not originate from a mouse down/touch event.
For those cases, we handle them
* specially.
*/
var isToggleModifierPressed = _this._isCtrlPressed ||
_this._isMetaPressed;
var selectionMode = _this._getSelectionMode();
if (_this._shouldHandleFocus && selectionMode !==
interfaces_1.SelectionMode.none) {
var isToggle = _this._hasAttribute(target,
SELECTION_TOGGLE_ATTRIBUTE_NAME);
var itemRoot = _this._findItemRoot(target);
if (!isToggle && itemRoot) {
var index = _this._getItemIndex(itemRoot);
if (isToggleModifierPressed) {
// set anchor only.
selection.setIndexSelected(index,
selection.isIndexSelected(index), true);
if (_this.props.enterModalOnTouch && _this._isTouch &&
selection.setModal) {
selection.setModal(true);
_this._setIsTouch(false);
}
}
else {
if (_this.props.isSelectedOnFocus) {
_this._onItemSurfaceClick(ev, index);
}
}
}
}
_this._handleNextFocus(false);
};
_this._updateModifiers(ev);
// No-op if selection is disabled
if (_this._isSelectionDisabled(target)) {
return;
}
if (_this._hasAttribute(target,
SELECTALL_TOGGLE_ALL_ATTRIBUTE_NAME)) {
break;
}
else if (itemRoot) {
SELECTION_TOGGLE_ATTRIBUTE_NAME)) {
break;
}
else if (_this._hasAttribute(target,
SELECTION_INVOKE_ATTRIBUTE_NAME)) {
break;
}
else if ((target === itemRoot ||
_this._shouldAutoSelect(target)) &&
!_this._isShiftPressed &&
!_this._isCtrlPressed &&
!_this._isMetaPressed &&
!_this.props.toggleWithoutModifierPressed) {
_this._onInvokeMouseDown(ev,
_this._getItemIndex(itemRoot));
break;
}
else if (_this.props.disableAutoSelectOnInputElements &&
(target.tagName === 'A' || target.tagName === 'BUTTON' ||
target.tagName === 'INPUT')) {
return;
}
}
}
};
_this._onTouchStartCapture = function (ev) {
_this._setIsTouch(true);
};
var _a = _this.props.enableTouchInvocationTarget,
enableTouchInvocationTarget = _a === void 0 ? false : _a;
var isSelectionDisabled = _this._isSelectionDisabled(target);
SELECTALL_TOGGLE_ALL_ATTRIBUTE_NAME)) {
if (!isSelectionDisabled) {
_this._onToggleAllClick(ev);
}
break;
}
else if (itemRoot) {
if (_this._isShiftPressed) {
}
else {
_this._onToggleClick(ev, index);
}
}
break;
}
else if ((_this._isTouch &&
enableTouchInvocationTarget &&
_this._hasAttribute(target,
SELECTION_INVOKE_TOUCH_ATTRIBUTE_NAME)) ||
// Items should be invokable even if selection is disabled.
_this._onInvokeClick(ev, index);
break;
}
else if (target === itemRoot) {
}
break;
}
else if (target.tagName === 'A' || target.tagName === 'BUTTON'
|| target.tagName === 'INPUT') {
return;
}
}
}
};
_this._onContextMenu = function (ev) {
var _a = _this.props, onItemContextMenu = _a.onItemContextMenu,
selection = _a.selection;
if (onItemContextMenu) {
if (itemRoot) {
_this._onInvokeMouseDown(ev, index);
var skipPreventDefault = onItemContextMenu(selection.getItems()
[index], index, ev.nativeEvent);
// In order to keep back compat, if the value here is
undefined, then we should still
// call preventDefault(). Only in the case where true is
explicitly returned should
// the call be skipped.
if (!skipPreventDefault) {
}
}
}
};
/**
* In multi selection, if you double click within an item's root (but not
within the invoke element or
* input elements), we should execute the invoke handler.
*/
_this._onDoubleClick = function (ev) {
var onItemInvoked = _this.props.onItemInvoked;
if (itemRoot && onItemInvoked && !_this._isInputElement(target)) {
SELECTION_TOGGLE_ATTRIBUTE_NAME) ||
break;
}
break;
}
}
}
};
_this._onKeyDownCapture = function (ev) {
_this._handleNextFocus(true);
};
var isSelectionDisabled = _this._isSelectionDisabled(target);
var _a = _this.props, selection = _a.selection,
selectionClearedOnEscapePress = _a.selectionClearedOnEscapePress;
var isSelectAllKey = ev.which === Utilities_1.KeyCodes.a &&
(_this._isCtrlPressed || _this._isMetaPressed);
var isClearSelectionKey = ev.which === Utilities_1.KeyCodes.escape;
// Ignore key downs from input elements.
if (_this._isInputElement(target)) {
// A key was pressed while an item in this zone was focused.
return;
}
var selectionMode = _this._getSelectionMode();
// If ctrl-a is pressed, select all (if all are not already selected.)
if (isSelectAllKey && selectionMode ===
interfaces_1.SelectionMode.multiple && !selection.isAllSelected()) {
selection.setAllSelected(true);
}
return;
}
// If escape is pressed and the component is configured to clear on
escape press,
// clear selection (if any are selected.)
if (selectionClearedOnEscapePress && isClearSelectionKey &&
selection.getSelectedCount() > 0) {
}
return;
}
// If a key was pressed within an item, we should treat "enters" as
invokes and "space" as toggle
if (itemRoot) {
// For toggle elements, assuming they are rendered as
buttons, they will generate a click event,
// so we can no-op for any keydowns in this case.
break;
}
else if (_this._shouldAutoSelect(target)) {
// If the event went to an element which should trigger
auto-select, select it and then let
// the default behavior kick in.
_this._onInvokeMouseDown(ev, index);
}
break;
}
else if (
(ev.which === Utilities_1.KeyCodes.enter || ev.which ===
Utilities_1.KeyCodes.space) &&
(target.tagName === 'BUTTON' || target.tagName === 'A' ||
target.tagName === 'INPUT')) {
return false;
}
// Items should be invokable even if selection is
disabled.
return;
}
else if (ev.which === Utilities_1.KeyCodes.space) {
_this._onToggleClick(ev, index);
}
return;
}
break;
}
}
}
};
// Reflect the initial modal state of selection into the state.
_this.state = {
isModal: isModal,
};
return _this;
}
SelectionZone.getDerivedStateFromProps = function (nextProps, prevState) {
var isModal = nextProps.selection.isModal && nextProps.selection.isModal();
return tslib_1.__assign(tslib_1.__assign({}, prevState), { isModal: isModal
});
};
SelectionZone.prototype.componentDidMount = function () {
// Track the latest modifier keys globally.
this._events.on(win, 'keydown, keyup', this._updateModifiers, true);
this._events.on(document, 'click',
this._findScrollParentAndTryClearOnEmptyClick);
this._events.on(document.body, 'touchstart', this._onTouchStartCapture,
true);
this._events.on(document.body, 'touchend', this._onTouchStartCapture,
true);
// Subscribe to the selection to keep modal state updated.
this._events.on(this.props.selection, 'change', this._onSelectionChange);
};
SelectionZone.prototype.render = function () {
var isModal = this.state.isModal;
SelectionZone', this.props.className, {
'ms-SelectionZone--modal': !!isModal,
}), ref: this._root, onKeyDown: this._onKeyDown, onMouseDown:
this._onMouseDown, onKeyDownCapture: this._onKeyDownCapture, onClick:
this._onClick, role: "presentation", onDoubleClick: this._onDoubleClick,
onContextMenu: this._onContextMenu, onMouseDownCapture: this._onMouseDownCapture,
onFocusCapture: this._onFocus, "data-selection-is-modal": isModal ? true :
undefined },
this.props.children,
React.createElement(Utilities_1.FocusRects, null)));
};
SelectionZone.prototype.componentDidUpdate = function (previousProps) {
if (selection !== previousProps.selection) {
// Whenever selection changes, update the subscripton to keep modal
state updated.
this._events.off(previousProps.selection);
this._events.on(selection, 'change', this._onSelectionChange);
}
};
SelectionZone.prototype.componentWillUnmount = function () {
};
SelectionZone.prototype._isSelectionDisabled = function (target) {
if (this._getSelectionMode() === interfaces_1.SelectionMode.none) {
return true;
}
while (target !== this._root.current) {
if (this._hasAttribute(target, SELECTION_DISABLED_ATTRIBUTE_NAME)) {
return true;
}
}
return false;
};
SelectionZone.prototype._onToggleAllClick = function (ev) {
var selectionMode = this._getSelectionMode();
if (selectionMode === interfaces_1.SelectionMode.multiple) {
selection.toggleAllSelected();
}
};
SelectionZone.prototype._onToggleClick = function (ev, index) {
if (this.props.enterModalOnTouch && this._isTouch && !
selection.isIndexSelected(index) && selection.setModal) {
this._setIsTouch(false);
}
selection.toggleIndexSelected(index);
}
else if (selectionMode === interfaces_1.SelectionMode.single) {
var isSelected = selection.isIndexSelected(index);
selection.setIndexSelected(index, !isSelected, true);
if (isModal && selection.setModal) {
// Since the above call to setAllSelected(false) clears modal
state,
// restore it. This occurs because the SelectionMode of the
Selection
// may differ from the SelectionZone.
}
}
else {
return;
}
// NOTE: ev.preventDefault is not called for toggle clicks, because this
will kill the browser behavior
// for checkboxes if you use a checkbox for the toggle.
};
SelectionZone.prototype._onInvokeClick = function (ev, index) {
var _a = this.props, selection = _a.selection, onItemInvoked =
_a.onItemInvoked;
if (onItemInvoked) {
onItemInvoked(selection.getItems()[index], index, ev.nativeEvent);
}
};
SelectionZone.prototype._onItemSurfaceClick = function (ev, index) {
var _a = this.props, selection = _a.selection, toggleWithoutModifierPressed
= _a.toggleWithoutModifierPressed;
var isToggleModifierPressed = this._isCtrlPressed || this._isMetaPressed;
if (this._isShiftPressed && !this._isTabPressed) {
selection.selectToIndex(index, !isToggleModifierPressed);
}
else if (isToggleModifierPressed || toggleWithoutModifierPressed) {
selection.toggleIndexSelected(index);
}
else {
this._clearAndSelectIndex(index);
}
}
else if (selectionMode === interfaces_1.SelectionMode.single) {
}
};
SelectionZone.prototype._onInvokeMouseDown = function (ev, index) {
// Only do work if item is not selected.
if (selection.isIndexSelected(index)) {
return;
}
};
/**
* To avoid high startup cost of traversing the DOM on component mount,
* defer finding the scrollable parent until a click interaction.
*
* The styles will probably already calculated since we're running in a click
handler,
* so this is less likely to cause layout thrashing then doing it in mount.
*/
SelectionZone.prototype._findScrollParentAndTryClearOnEmptyClick = function
(ev) {
var scrollParent = Utilities_1.findScrollableParent(this._root.current);
// unbind this handler and replace binding with a binding on the actual
scrollable parent
this._events.off(document, 'click',
this._findScrollParentAndTryClearOnEmptyClick);
this._events.on(scrollParent, 'click', this._tryClearOnEmptyClick);
// If we clicked inside the scrollable parent, call through to the handler
on this click.
if ((scrollParent && ev.target instanceof Node &&
scrollParent.contains(ev.target)) || scrollParent === ev.target) {
this._tryClearOnEmptyClick(ev);
}
};
SelectionZone.prototype._tryClearOnEmptyClick = function (ev) {
if (!this.props.selectionPreservedOnEmptyClick &&
this._isNonHandledClick(ev.target)) {
this.props.selection.setAllSelected(false);
}
};
SelectionZone.prototype._clearAndSelectIndex = function (index) {
var _a = this.props, selection = _a.selection, _b =
_a.selectionClearedOnSurfaceClick, selectionClearedOnSurfaceClick = _b === void 0 ?
true : _b;
var isAlreadySingleSelected = selection.getSelectedCount() === 1 &&
selection.isIndexSelected(index);
if (!isAlreadySingleSelected && selectionClearedOnSurfaceClick) {
selection.setIndexSelected(index, true, true);
if (isModal || (this.props.enterModalOnTouch && this._isTouch)) {
if (selection.setModal) {
}
if (this._isTouch) {
this._setIsTouch(false);
}
}
}
};
/**
* We need to track the modifier key states so that when focus events occur,
which do not contain
* modifier states in the Event object, we know how to behave.
*/
SelectionZone.prototype._updateModifiers = function (ev) {
this._isShiftPressed = ev.shiftKey;
this._isCtrlPressed = ev.ctrlKey;
this._isMetaPressed = ev.metaKey;
var keyCode = ev.keyCode;
this._isTabPressed = keyCode ? keyCode === Utilities_1.KeyCodes.tab :
false;
};
SelectionZone.prototype._findItemRoot = function (target) {
while (target !== this._root.current) {
var indexValue = target.getAttribute(SELECTION_INDEX_ATTRIBUTE_NAME);
var index = Number(indexValue);
if (indexValue !== null && index >= 0 && index <
selection.getItems().length) {
break;
}
}
if (target === this._root.current) {
return undefined;
}
return target;
};
SelectionZone.prototype._getItemIndex = function (itemRoot) {
return Number(itemRoot.getAttribute(SELECTION_INDEX_ATTRIBUTE_NAME));
};
SelectionZone.prototype._shouldAutoSelect = function (element) {
return this._hasAttribute(element, SELECTION_SELECT_ATTRIBUTE_NAME);
};
SelectionZone.prototype._hasAttribute = function (element, attributeName) {
var isToggle = false;
while (!isToggle && element !== this._root.current) {
isToggle = element.getAttribute(attributeName) === 'true';
element = Utilities_1.getParent(element);
}
return isToggle;
};
SelectionZone.prototype._isInputElement = function (element) {
return (element.tagName === 'INPUT' ||
element.tagName === 'TEXTAREA' ||
element.getAttribute('contenteditable') === 'true' ||
element.getAttribute('contenteditable') === '');
};
SelectionZone.prototype._isNonHandledClick = function (element) {
if (doc && element) {
while (element && element !== doc.documentElement) {
if (Utilities_1.isElementTabbable(element)) {
return false;
}
element = Utilities_1.getParent(element);
}
}
return true;
};
SelectionZone.prototype._handleNextFocus = function (handleFocus) {
var _this = this;
if (this._shouldHandleFocusTimeoutId) {
this._async.clearTimeout(this._shouldHandleFocusTimeoutId);
this._shouldHandleFocusTimeoutId = undefined;
}
this._shouldHandleFocus = handleFocus;
if (handleFocus) {
_this._shouldHandleFocus = false;
}, 100);
}
};
SelectionZone.prototype._setIsTouch = function (isTouch) {
var _this = this;
if (this._isTouchTimeoutId) {
this._async.clearTimeout(this._isTouchTimeoutId);
this._isTouchTimeoutId = undefined;
}
this._isTouch = true;
if (isTouch) {
}, 300);
}
};
SelectionZone.prototype._getSelectionMode = function () {
var _a = this.props.selectionMode, selectionMode = _a === void 0 ?
selection ? selection.mode : interfaces_1.SelectionMode.none : _a;
return selectionMode;
};
SelectionZone.defaultProps = {
isSelectedOnFocus: true,
toggleWithoutModifierPressed: false,
selectionMode: interfaces_1.SelectionMode.multiple,
selectionClearedOnEscapePress: true,
};
return SelectionZone;
exports.SelectionZone = SelectionZone;
//# sourceMappingURL=SelectionZone.js.map
/***/ }),
/***/ 82478:
"use strict";

/***/ }),
/***/ 62880:
"use strict";

exports.SelectionMode = exports.SelectionDirection = exports.SELECTION_CHANGE =
void 0;
function () { return utilities_1.SELECTION_CHANGE; } }));
function () { return utilities_1.SelectionDirection; } }));
() { return utilities_1.SelectionMode; } }));
/***/ }),
/***/ 97211:
"use strict";

exports.useOverflow = void 0;
var observeResize_1 = __webpack_require__(71752);
/**
* Track whether any items don't fit within their container, and move them to the
overflow menu.
* Items are moved into the overflow menu from back to front, excluding pinned
items.
*
* The overflow menu button must be the last sibling of all of the items that can
be put into the overflow, and it
* must be hooked up to the `setMenuButtonRef` setter function that's returned by
ùseOverflow`:
* ```ts
* const overflow = useOverflow(...);
* ```
* ```jsx
* <Container>
* <Item /> // Index 0
* <Item /> // Index 1
* ...
* <Button ref={overflow.setMenuButtonRef} /> // Can be any React.Component or
HTMLElement
* </Container>
* ```
*/
var useOverflow = function (_a) {
var onOverflowItemsChanged = _a.onOverflowItemsChanged, rtl = _a.rtl,
pinnedIndex = _a.pinnedIndex;
var updateOverflowRef = React.useRef();
var containerWidthRef = React.useRef();
// Attach a resize observer to the container
var containerRef = react_hooks_1.useRefEffect(function (container) {
var cleanupObserver = observeResize_1.observeResize(container, function
(entries) {
containerWidthRef.current = entries ? entries[0].contentRect.width :
container.clientWidth;
if (updateOverflowRef.current) {
updateOverflowRef.current();
}
});
cleanupObserver();
containerWidthRef.current = undefined;
};
});
var menuButtonRef = react_hooks_1.useRefEffect(function (menuButton) {
containerRef(menuButton.parentElement);
return function () { return containerRef(null); };
});
var container = containerRef.current;
var menuButton = menuButtonRef.current;
if (!container || !menuButton) {
return;
}
// items contains the container's children, excluding the overflow menu
button itself
var items = [];
for (var i = 0; i < container.children.length; i++) {
var item = container.children[i];
if (item instanceof HTMLElement && item !== menuButton) {
items.push(item);
}
}
// Keep track of the minimum width of the container to fit each child
index.
// This cache is an integral part of the algorithm and not just a
performance optimization: it allows us to
// recalculate the overflowIndex on subsequent resizes even if some items
are already inside the overflow.
var minContainerWidth = [];
var extraWidth = 0; // The accumulated width of items that don't move into
the overflow
updateOverflowRef.current = function () {
var containerWidth = containerWidthRef.current;
if (containerWidth === undefined) {
return;
}
// Iterate the items in reverse order until we find one that fits
within the bounds of the container
for (var i = items.length - 1; i >= 0; i--) {
// Calculate the min container width for this item if we haven't
done so yet
if (minContainerWidth[i] === undefined) {
var itemOffsetEnd = rtl ? containerWidth -
items[i].offsetLeft : items[i].offsetLeft + items[i].offsetWidth;
// If the item after this one is pinned, reserve space for it
if (i + 1 < items.length && i + 1 === pinnedIndex) {
// Use distance between the end of the previous item and
this one (rather than the
// pinned item's offsetWidth), to account for any margin
between the items.
extraWidth = minContainerWidth[i + 1] - itemOffsetEnd;
}
// Reserve space for the menu button after the first item was
added to the overflow
if (i === items.length - 2) {
extraWidth += menuButton.offsetWidth;
}
minContainerWidth[i] = itemOffsetEnd + extraWidth;
}
if (containerWidth > minContainerWidth[i]) {
setOverflowIndex(i + 1);
return;
}
}
// If we got here, nothing fits outside the overflow
setOverflowIndex(0);
};
var prevOverflowIndex = items.length;
var setOverflowIndex = function (overflowIndex) {
if (prevOverflowIndex !== overflowIndex) {
prevOverflowIndex = overflowIndex;
onOverflowItemsChanged(overflowIndex, items.map(function (ele,
index) { return ({
ele: ele,
isOverflowing: index >= overflowIndex && index !== pinnedIndex,
}); }));
}
};
var cancelAnimationFrame = undefined;
// If the container width is already known from a previous render, update
the overflow with its width.
// Do this in an animation frame to avoid forcing layout to happen early.
if (containerWidthRef.current !== undefined) {
var win_1 = utilities_1.getWindow(container);
if (win_1) {
var animationFrameId_1 =
win_1.requestAnimationFrame(updateOverflowRef.current);
cancelAnimationFrame = function () { return
win_1.cancelAnimationFrame(animationFrameId_1); };
}
}
if (cancelAnimationFrame) {
cancelAnimationFrame();
}
// On cleanup, need to remove all items from the overflow
// so they don't have stale properties on the next render
setOverflowIndex(items.length);
updateOverflowRef.current = undefined;
};
});
return { menuButtonRef: menuButtonRef };
};
exports.useOverflow = useOverflow;
//# sourceMappingURL=useOverflow.js.map
/***/ }),
/***/ 90733:
"use strict";

set_version_1.setVersion('@fluentui/react', '8.77.0');
/***/ }),
/***/ 28385:
"use strict";
/*! *****************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k];
} });
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}
/***/ }),
/***/ 74984:
"use strict";

exports.setVersion = void 0;
var setVersion_1 = __webpack_require__(91659);
Object.defineProperty(exports, "setVersion", ({ enumerable: true, get: function ()
{ return setVersion_1.setVersion; } }));
setVersion_1.setVersion('@fluentui/set-version', '6.0.0');
/***/ }),
/***/ 91659:
"use strict";

exports.setVersion = void 0;
// A packages cache that makes sure that we don't inject the same packageName twice
in the same bundle -
// this cache is local to the module closure inside this bundle
var packagesCache = {};
// Cache access to window to avoid IE11 memory leak.
var _win = undefined;
try {
_win = window;
}
catch (e) {
/* no-op */
}
function setVersion(packageName, packageVersion) {
if (typeof _win !== 'undefined') {
var packages = (_win.__packages__ = _win.__packages__ || {});
// We allow either the global packages or local packages caches to
invalidate so testing can
// just clear the global to set this state
if (!packages[packageName] || !packagesCache[packageName]) {
packagesCache[packageName] = packageVersion;
var versions = (packages[packageName] = packages[packageName] || []);
versions.push(packageVersion);
}
}
}
exports.setVersion = setVersion;
//# sourceMappingURL=setVersion.js.map
/***/ }),
/***/ 42182:
"use strict";

exports.mergeStyles = exports.mergeStyleSets = exports.keyframes = exports.fontFace
= exports.concatStyleSetsWithProps = exports.concatStyleSets = exports.Stylesheet =
exports.InjectionMode = void 0;
Object.defineProperty(exports, "InjectionMode", ({ enumerable: true, get: function
() { return merge_styles_1.InjectionMode; } }));
Object.defineProperty(exports, "Stylesheet", ({ enumerable: true, get: function ()
{ return merge_styles_1.Stylesheet; } }));
function () { return merge_styles_1.concatStyleSets; } }));
get: function () { return merge_styles_1.concatStyleSetsWithProps; } }));
{ return merge_styles_1.fontFace; } }));
return merge_styles_1.keyframes; } }));
() { return merge_styles_1.mergeStyleSets; } }));
{ return merge_styles_1.mergeStyles; } }));
//# sourceMappingURL=MergeStyles.js.map
/***/ }),
/***/ 84651:
"use strict";

exports.AnimationClassNames = void 0;
/**
* {@docCategory AnimationClassNames}
*/
exports.AnimationClassNames = index_1.buildClassMap(index_2.AnimationStyles);
//# sourceMappingURL=AnimationClassNames.js.map
/***/ }),
/***/ 50251:
"use strict";

exports.ColorClassNames = void 0;
var DefaultPalette_1 = __webpack_require__(76153);
exports.ColorClassNames = {};
for (var colorName in DefaultPalette_1.DefaultPalette) {
if (DefaultPalette_1.DefaultPalette.hasOwnProperty(colorName)) {
// Foreground color
_defineGetter(exports.ColorClassNames, colorName, '', false, 'color');
// Hover color
_defineGetter(exports.ColorClassNames, colorName, 'Hover', true, 'color');
// Background color
_defineGetter(exports.ColorClassNames, colorName, 'Background', false,
'background');
// Background hover
_defineGetter(exports.ColorClassNames, colorName, 'BackgroundHover', true,
'background');
// Border color
_defineGetter(exports.ColorClassNames, colorName, 'Border', false,
'borderColor');
// Border hover color
_defineGetter(exports.ColorClassNames, colorName, 'BorderHover', true,
'borderColor');
}
}
/**
* Defines a getter for the given class configuration.
*/
function _defineGetter(obj, colorName, suffix, isHover, cssProperty) {
Object.defineProperty(obj, colorName + suffix, {
get: function () {
var _a;
var style = (_a = {}, _a[cssProperty] =
index_1.getTheme().palette[colorName], _a);
return merge_styles_1.mergeStyles(isHover ? { selectors: { ':hover':
style } } : style).toString();
},
enumerable: true,
configurable: true,
});
}
//# sourceMappingURL=ColorClassNames.js.map
/***/ }),
/***/ 78340:
"use strict";

exports.FontClassNames = void 0;
var buildClassMap_1 = __webpack_require__(35621);
var DefaultFontStyles_1 = __webpack_require__(50059);
/**
* {@docCategory FontClassNames}
*/
exports.FontClassNames =
buildClassMap_1.buildClassMap(DefaultFontStyles_1.DefaultFontStyles);
//# sourceMappingURL=FontClassNames.js.map
/***/ }),
/***/ 98164:
"use strict";

exports.ColorClassNames = exports.FontClassNames = exports.AnimationClassNames =
void 0;
var AnimationClassNames_1 = __webpack_require__(84651);
Object.defineProperty(exports, "AnimationClassNames", ({ enumerable: true, get:
function () { return AnimationClassNames_1.AnimationClassNames; } }));
var FontClassNames_1 = __webpack_require__(78340);
Object.defineProperty(exports, "FontClassNames", ({ enumerable: true, get: function
() { return FontClassNames_1.FontClassNames; } }));
var ColorClassNames_1 = __webpack_require__(50251);
Object.defineProperty(exports, "ColorClassNames", ({ enumerable: true, get:
function () { return ColorClassNames_1.ColorClassNames; } }));
/***/ }),
/***/ 29840:
"use strict";

// Ensure theme is initialized when this package is referenced.
theme_1.initializeThemeInCustomizations();
/***/ }),
/***/ 60905:
"use strict";

/***/ }),
/***/ 35217:
"use strict";

exports.AnimationVariables = exports.AnimationStyles = void 0;
function () { return theme_1.AnimationStyles; } }));
function () { return theme_1.AnimationVariables; } }));
//# sourceMappingURL=AnimationStyles.js.map
/***/ }),
/***/ 96991:
"use strict";

exports.getEdgeChromiumNoHighContrastAdjustSelector =
exports.getHighContrastNoAdjustStyle = exports.getScreenSelector =
exports.ScreenWidthMinUhfMobile = exports.ScreenWidthMaxXXLarge =
exports.ScreenWidthMaxXLarge = exports.ScreenWidthMaxLarge =
exports.ScreenWidthMaxMedium = exports.ScreenWidthMaxSmall =
exports.ScreenWidthMinXXXLarge = exports.ScreenWidthMinXXLarge =
exports.ScreenWidthMinXLarge = exports.ScreenWidthMinLarge =
exports.ScreenWidthMinMedium = exports.ScreenWidthMinSmall =
exports.EdgeChromiumHighContrastSelector = exports.HighContrastSelectorBlack =
exports.HighContrastSelectorWhite = exports.HighContrastSelector = void 0;
exports.HighContrastSelector = '@media screen and (-ms-high-contrast: active),
@media screen and (forced-colors: active)';
exports.HighContrastSelectorWhite =
'@media screen and (-ms-high-contrast: black-on-white), @media screen and (forced-
colors: active) and (prefers-color-scheme: light)';
exports.HighContrastSelectorBlack =
'@media screen and (-ms-high-contrast: white-on-black), @media screen and (forced-
colors: active) and (prefers-color-scheme: dark)';
/**
* @deprecated Use `HighContrastSelector`
*/
exports.EdgeChromiumHighContrastSelector = '@media screen and (-ms-high-contrast:
active), @media screen and (forced-colors: active)';
exports.ScreenWidthMinSmall = 320;
exports.ScreenWidthMinMedium = 480;
exports.ScreenWidthMinLarge = 640;
exports.ScreenWidthMinXLarge = 1024;
exports.ScreenWidthMinXXLarge = 1366;
exports.ScreenWidthMinXXXLarge = 1920;
exports.ScreenWidthMaxSmall = exports.ScreenWidthMinMedium - 1;
exports.ScreenWidthMaxMedium = exports.ScreenWidthMinLarge - 1;
exports.ScreenWidthMaxLarge = exports.ScreenWidthMinXLarge - 1;
exports.ScreenWidthMaxXLarge = exports.ScreenWidthMinXXLarge - 1;
exports.ScreenWidthMaxXXLarge = exports.ScreenWidthMinXXXLarge - 1;
exports.ScreenWidthMinUhfMobile = 768;
function getScreenSelector(min, max) {
var minSelector = typeof min === 'number' ? " and (min-width: " + min + "px)" :
'';
var maxSelector = typeof max === 'number' ? " and (max-width: " + max + "px)" :
'';
return "@media only screen" + minSelector + maxSelector;
}
exports.getScreenSelector = getScreenSelector;
/**
* The style which turns off high contrast adjustment in browsers.
*/
function getHighContrastNoAdjustStyle() {
return {
MsHighContrastAdjust: 'none',
};
}
exports.getHighContrastNoAdjustStyle = getHighContrastNoAdjustStyle;
/**
* The style which turns off high contrast adjustment in (only) Edge Chromium
browser.
* @deprecated Use `getHighContrastNoAdjustStyle`
*/
function getEdgeChromiumNoHighContrastAdjustSelector() {
var _a;
return _a = {},
_a[exports.EdgeChromiumHighContrastSelector] = {
MsHighContrastAdjust: 'none',
},
_a;
}
exports.getEdgeChromiumNoHighContrastAdjustSelector =
getEdgeChromiumNoHighContrastAdjustSelector;
//# sourceMappingURL=CommonStyles.js.map
/***/ }),
/***/ 15084:
"use strict";

exports.DefaultEffects = void 0;
() { return theme_1.DefaultEffects; } }));
//# sourceMappingURL=DefaultEffects.js.map
/***/ }),
/***/ 50059:
"use strict";

exports.registerDefaultFontFaces = exports.DefaultFontStyles = void 0;
function () { return theme_1.DefaultFontStyles; } }));
//# sourceMappingURL=DefaultFontStyles.js.map
/***/ }),
/***/ 76153:
"use strict";

exports.DefaultPalette = void 0;
() { return theme_1.DefaultPalette; } }));
//# sourceMappingURL=DefaultPalette.js.map
/***/ }),
/***/ 96955:
"use strict";

exports.noWrap = exports.normalize = void 0;
// This file mimics styles and mixins from _General.Mixins.scss
exports.normalize = {
boxShadow: 'none',
margin: 0,
padding: 0,
};
exports.noWrap = {
overflow: 'hidden',
};
//# sourceMappingURL=GeneralStyles.js.map
/***/ }),
/***/ 22768:
"use strict";

exports.PulsingBeaconAnimationStyles = void 0;
var DEFAULT_DURATION = '14s';
var DEFAULT_DELAY = '2s';
var DEFAULT_ITERATION_COUNT = '1';
function _continuousPulseStepOne(beaconColorOne, innerDimension) {
return {
borderColor: beaconColorOne,
borderWidth: '0px',
width: innerDimension,
height: innerDimension,
};
}
function _continuousPulseStepTwo(borderWidth) {
return {
opacity: 1,
borderWidth: borderWidth,
};
}
function _continuousPulseStepThree() {
return {
opacity: 1,
};
}
function _continuousPulseStepFour(beaconColorTwo, outerDimension) {
return {
borderWidth: '0',
width: outerDimension,
height: outerDimension,
opacity: 0,
borderColor: beaconColorTwo,
};
}
function _continuousPulseStepFive(beaconColorOne, innerDimension) {
_continuousPulseStepOne(beaconColorOne, innerDimension)), {
opacity: 0,
});
}
function _continuousPulseAnimationDouble(beaconColorOne, beaconColorTwo,
innerDimension, outerDimension, borderWidth) {
return merge_styles_1.keyframes({
'0%': _continuousPulseStepOne(beaconColorOne, innerDimension),
'1.42%': _continuousPulseStepTwo(borderWidth),
'3.57%': _continuousPulseStepThree(),
'7.14%': _continuousPulseStepFour(beaconColorTwo, outerDimension),
'8%': _continuousPulseStepFive(beaconColorOne, innerDimension),
'29.99%': _continuousPulseStepFive(beaconColorOne, innerDimension),
'38%': _continuousPulseStepFive(beaconColorOne, innerDimension),
'79.42%': _continuousPulseStepFive(beaconColorOne, innerDimension),
'79.43': _continuousPulseStepOne(beaconColorOne, innerDimension),
'81.85': _continuousPulseStepTwo(borderWidth),
'83.42': _continuousPulseStepThree(),
'87%': _continuousPulseStepFour(beaconColorTwo, outerDimension),
'100%': {},
});
}
function _continuousPulseAnimationSingle(beaconColorOne, beaconColorTwo,
innerDimension, outerDimension, borderWidth) {
'100%': {},
});
}
function _createDefaultAnimation(animationName, delayLength) {
return {
animationName: animationName,
animationIterationCount: DEFAULT_ITERATION_COUNT,
animationDuration: DEFAULT_DURATION,
animationDelay: delayLength || DEFAULT_DELAY,
};
}
exports.PulsingBeaconAnimationStyles = {
continuousPulseAnimationDouble: _continuousPulseAnimationDouble,
continuousPulseAnimationSingle: _continuousPulseAnimationSingle,
createDefaultAnimation: _createDefaultAnimation,
};
//# sourceMappingURL=PulsingBeaconAnimationStyles.js.map
/***/ }),
/***/ 29910:
"use strict";

exports.createFontStyles = exports.IconFontSizes = exports.FontWeights =
exports.FontSizes = exports.LocalizedFontFamilies = exports.LocalizedFontNames =
void 0;
function () { return theme_1.LocalizedFontNames; } }));
function () { return theme_1.LocalizedFontFamilies; } }));
return theme_1.FontSizes; } }));
{ return theme_1.FontWeights; } }));
() { return theme_1.IconFontSizes; } }));
function () { return theme_1.createFontStyles; } }));
//# sourceMappingURL=fonts.js.map
/***/ }),
/***/ 1792:
"use strict";

exports.getFadedOverflowStyle = void 0;
var DEFAULT_HEIGHT = '50%';
var DEFAULT_WIDTH = 20;
/**
* - Generates a style used to fade out an overflowing content by defining a style
for an :after pseudo element.
* - Apply it to the :after selector for all combination of states the parent of
content might have (normal, hover,
* selected, focus).
* - Requires the target to have position set to relative and overflow set to
hidden.
*
* @example
* ```tsx
* // Assuming the following DOM structure and the different background colors
coming from
* // the parent holding the content.
* <div className={classNames.parent}>
* <span className={classNames.content}>Overflown Content</span>
* </div>
* ```
* ```ts
* // This is how the style set would look in Component.styles.ts
* const { bodyBackground } = theme.semanticColors;
* const { neutralLighter } = theme.palette;
*
* // The second argument of getFadedOverflowStyle function is a string
representing a key of
* // ISemanticColors or IPalette.
*
* const styles = {
* parent: [
* backgroundColor: bodyBackground,
* selectors: {
* '&:hover: {
* backgroundColor: neutralLighter
* },
* '$content:after': {
* ...getFadedOverflowStyle(theme, 'bodyBackground')
* },
* '&:hover $content:after': {
* ...getFadedOverflowStyle(theme, 'neutralLighter')
* }
* }
* ],
* content: [
* width: '100%',
* display: 'inline-block',
* position: 'relative',
* overflow: 'hidden'
* ]
* }
* ```
* @param theme - The theme object to use.
* @param color - The background color to fade out to. Accepts only keys of
ISemanticColors or IPalette.
* Defaults to 'bodyBackground'.
* @param direction - The direction of the overflow. Defaults to horizontal.
* @param width - The width of the fading overflow. Vertical direction defaults it
to 100% vs 20px when horizontal.
* @param height - The Height of the fading overflow. Vertical direction defaults
it to 50% vs 100% when horizontal.
* @returns The style object.
*/
function getFadedOverflowStyle(theme, color, direction, width, height) {
if (color === void 0) { color = 'bodyBackground'; }
if (direction === void 0) { direction = 'horizontal'; }
if (width === void 0) { width = getDefaultValue('width', direction); }
if (height === void 0) { height = getDefaultValue('height', direction); }
// Get the color value string from the theme semanticColors or palette.
var colorValue = theme.semanticColors[color] || theme.palette[color];
// Get the red, green, blue values of the colorValue.
var rgbColor = color2rgb(colorValue);
// Apply opacity 0 to serve as a start color of the gradient.
var rgba = "rgba(" + rgbColor.r + ", " + rgbColor.g + ", " + rgbColor.b + ",
0)";
// Get the direction of the gradient. (mergeStyles takes care of RTL direction)
var gradientDirection = direction === 'vertical' ? 'to bottom' : 'to right';
return {
content: '""',
right: 0,
bottom: 0,
width: width,
height: height,
backgroundImage: "linear-gradient(" + gradientDirection + ", " + rgba + "
0%, " + colorValue + " 100%)",
};
}
exports.getFadedOverflowStyle = getFadedOverflowStyle;
// TODO consider moving this to a separate module along with some more color
functions from OUFR/utilities.
/**
* Helper function to convert a string hex color to an RGB object.
*
* @param colorValue - Color to be converted from hex to rgba.
*/
function color2rgb(colorValue) {
if (colorValue[0] === '#') {
// If it's a hex code
return {
r: parseInt(colorValue.slice(1, 3), 16),
g: parseInt(colorValue.slice(3, 5), 16),
b: parseInt(colorValue.slice(5, 7), 16),
};
}
else if (colorValue.indexOf('rgba(') === 0) {
// If it's an rgba color string
colorValue = colorValue.match(/rgba$([^)]+)$/)[1];
var parts = colorValue.split(/ *, */).map(Number);
return {
r: parts[0],
g: parts[1],
b: parts[2],
};
}
// The only remaining possibility is transparent.
return {
r: 255,
g: 255,
b: 255,
};
}
/**
* Helper function to get the default values for parameters of main function.
*
* @param style - Which style to get the default value for.
* @param direction - What direction to take into consideration.
*/
function getDefaultValue(style, direction) {
if (style === 'width') {
return direction === 'horizontal' ? DEFAULT_WIDTH : '100%';
}
else {
return direction === 'vertical' ? DEFAULT_HEIGHT : '100%';
}
}
//# sourceMappingURL=getFadedOverflowStyle.js.map
/***/ }),
/***/ 90420:
"use strict";

exports.getInputFocusStyle = exports.getFocusOutlineStyle = exports.focusClear =
exports.getFocusStyle = void 0;
var CommonStyles_1 = __webpack_require__(96991);
var zIndexes_1 = __webpack_require__(28492);
function getFocusStyle(theme, insetOrOptions, position, highContrastStyle,
borderColor, outlineColor, isFocusedOnly) {
if (typeof insetOrOptions === 'number' || !insetOrOptions) {
return _getFocusStyleInternal(theme, {
inset: insetOrOptions,
position: position,
highContrastStyle: highContrastStyle,
borderColor: borderColor,
outlineColor: outlineColor,
isFocusedOnly: isFocusedOnly,
});
}
else {
return _getFocusStyleInternal(theme, insetOrOptions);
}
}
exports.getFocusStyle = getFocusStyle;
function _getFocusStyleInternal(theme, options) {
var _a, _b;
var _c = options.inset, inset = _c === void 0 ? 0 : _c, _d = options.width,
width = _d === void 0 ? 1 : _d, _e = options.position, position = _e === void 0 ?
'relative' : _e, highContrastStyle = options.highContrastStyle, _f =
options.borderColor, borderColor = _f === void 0 ? theme.palette.white : _f, _g =
options.outlineColor, outlineColor = _g === void 0 ? theme.palette.neutralSecondary
: _g, _h = options.isFocusedOnly, isFocusedOnly = _h === void 0 ? true : _h;
return {
// Clear browser-specific focus styles and use 'transparent' as placeholder
for focus style.
// Requirement because pseudo-element is absolutely positioned.
position: position,
selectors: (_a = {
// Clear the focus border in Firefox.
// Reference: http://stackoverflow.com/a/199319/1436671
'::-moz-focus-inner': {
border: '0',
}
},
// When the element that uses this mixin is in a :focus state, add a
pseudo-element to
// create a border.
_a["." + utilities_1.IsFocusVisibleClassName + " &" + (isFocusedOnly ?
':focus' : '') + ":after"] = {
content: '""',
left: inset + 1,
top: inset + 1,
bottom: inset + 1,
right: inset + 1,
border: width + "px solid " + borderColor,
outline: width + "px solid " + outlineColor,
zIndex: zIndexes_1.ZIndexes.FocusStyle,
_b[CommonStyles_1.HighContrastSelector] = highContrastStyle,
_b),
},
_a),
};
}
/**
* Generates style to clear browser specific focus styles.
*/
function focusClear() {
return {
selectors: {
'&::-moz-focus-inner': {
// Clear the focus border in Firefox. Reference:
http://stackoverflow.com/a/199319/1436671
border: 0,
},
'&': {
// Clear browser specific focus styles and use transparent as
placeholder for focus style
},
},
};
}
exports.focusClear = focusClear;
/**
* Generates a style which can be used to set a border on focus.
*
* @param theme - The theme object to use.
* @param inset - The number of pixels to inset the border (default 0)
* @param width - The border width in pixels (default 1)
* @param color - Color of the outline (default `theme.palette.neutralSecondary`)
*/
function getFocusOutlineStyle(theme, inset, width, color) {
var _a;
if (inset === void 0) { inset = 0; }
if (width === void 0) { width = 1; }
return {
_a[":global(" + utilities_1.IsFocusVisibleClassName + ") &:focus"] = {
outline: width + " solid " + (color ||
theme.palette.neutralSecondary),
outlineOffset: -inset + "px",
},
_a),
};
}
exports.getFocusOutlineStyle = getFocusOutlineStyle;
/**
* Generates text input border styles on focus.
*
* @param borderColor - Color of the border.
* @param borderRadius - Radius of the border.
* @param borderType - Type of the border.
* @param borderPosition - Position of the border relative to the input element
(default to -1
* as it's the most common border width of the input element)
*/
var getInputFocusStyle = function (borderColor, borderRadius, borderType,
borderPosition) {
var _a, _b, _c;
if (borderType === void 0) { borderType = 'border'; }
if (borderPosition === void 0) { borderPosition = -1; }
var isBorderBottom = borderType === 'borderBottom';
return {
borderColor: borderColor,
selectors: {
':after': (_a = {
content: "''",
left: isBorderBottom ? 0 : borderPosition,
top: borderPosition,
bottom: borderPosition,
right: isBorderBottom ? 0 : borderPosition
},
_a[borderType] = "2px solid " + borderColor,
_a.borderRadius = borderRadius,
_a.width = borderType === 'borderBottom' ? '100%' : undefined,
_a.selectors = (_b = {},
_b[CommonStyles_1.HighContrastSelector] = (_c = {},
_c[borderType === 'border' ? 'borderColor' :
'borderBottomColor'] = 'Highlight',
_c),
_b),
_a),
},
};
};
exports.getInputFocusStyle = getInputFocusStyle;
//# sourceMappingURL=getFocusStyle.js.map
/***/ }),
/***/ 27520:
"use strict";

exports.getGlobalClassNames = void 0;
/**
* Internal memoized function which simply takes in the class map and the
* disable boolean. These immutable values can be memoized.
*/
var _getGlobalClassNames = utilities_1.memoizeFunction(function (classNames,
disableGlobalClassNames) {
var styleSheet = merge_styles_1.Stylesheet.getInstance();
if (disableGlobalClassNames) {
// disable global classnames
return Object.keys(classNames).reduce(function (acc, className) {
acc[className] = styleSheet.getClassName(classNames[className]);
return acc;
}, {});
}
// use global classnames
return classNames;
});
/**
* Checks for the `disableGlobalClassNames` property on the `theme` to determine if
it should return `classNames`
* Note that calls to this function are memoized.
*
* @param classNames - The collection of global class names that apply when the
flag is false. Make sure to pass in
* the same instance on each call to benefit from memoization.
* @param theme - The theme to check the flag on
* @param disableGlobalClassNames - Optional. Explicitly opt in/out of disabling
global classnames. Defaults to false.
*/
function getGlobalClassNames(classNames, theme, disableGlobalClassNames) {
return _getGlobalClassNames(classNames, disableGlobalClassNames !== undefined ?
disableGlobalClassNames : theme.disableGlobalClassNames);
}
exports.getGlobalClassNames = getGlobalClassNames;
//# sourceMappingURL=getGlobalClassNames.js.map
/***/ }),
/***/ 89999:
"use strict";

exports.getPlaceholderStyles = void 0;
/**
* Generates placeholder style for each of the browsers supported by
`@fluentui/react`.
* @param styles - The style to use.
* @returns The placeholder style object for each browser depending on the
placeholder directive it uses.
*/
function getPlaceholderStyles(styles) {
return {
selectors: {
'::placeholder': styles,
':-ms-input-placeholder': styles,
'::-ms-input-placeholder': styles, // Edge
},
};
}
exports.getPlaceholderStyles = getPlaceholderStyles;
//# sourceMappingURL=getPlaceholderStyles.js.map
/***/ }),
/***/ 82649:
"use strict";

exports.hiddenContentStyle = void 0;
exports.hiddenContentStyle = {
width: 1,
height: 1,
margin: -1,
padding: 0,
border: 0,
overflow: 'hidden',
};
//# sourceMappingURL=hiddenContentStyle.js.map
/***/ }),
/***/ 84137:
"use strict";

exports.removeOnThemeChangeCallback = exports.registerOnThemeChangeCallback =
exports.createTheme = exports.loadTheme = exports.getTheme =
exports.ThemeSettingName = exports.getGlobalClassNames =
exports.PulsingBeaconAnimationStyles = exports.hiddenContentStyle =
exports.createFontStyles = exports.IconFontSizes = exports.FontWeights =
exports.FontSizes = exports.registerDefaultFontFaces = exports.DefaultFontStyles =
exports.DefaultEffects = exports.DefaultPalette = exports.AnimationVariables =
exports.AnimationStyles = void 0;
var AnimationStyles_1 = __webpack_require__(35217);
function () { return AnimationStyles_1.AnimationStyles; } }));
function () { return AnimationStyles_1.AnimationVariables; } }));
() { return DefaultPalette_1.DefaultPalette; } }));
var DefaultEffects_1 = __webpack_require__(15084);
() { return DefaultEffects_1.DefaultEffects; } }));
function () { return DefaultFontStyles_1.DefaultFontStyles; } }));
get: function () { return DefaultFontStyles_1.registerDefaultFontFaces; } }));
var fonts_1 = __webpack_require__(29910);
return fonts_1.FontSizes; } }));
{ return fonts_1.FontWeights; } }));
() { return fonts_1.IconFontSizes; } }));
function () { return fonts_1.createFontStyles; } }));
var hiddenContentStyle_1 = __webpack_require__(82649);
Object.defineProperty(exports, "hiddenContentStyle", ({ enumerable: true, get:
function () { return hiddenContentStyle_1.hiddenContentStyle; } }));
var PulsingBeaconAnimationStyles_1 = __webpack_require__(22768);
Object.defineProperty(exports, "PulsingBeaconAnimationStyles", ({ enumerable: true,
PulsingBeaconAnimationStyles_1.PulsingBeaconAnimationStyles; } }));
var getGlobalClassNames_1 = __webpack_require__(27520);
Object.defineProperty(exports, "getGlobalClassNames", ({ enumerable: true, get:
function () { return getGlobalClassNames_1.getGlobalClassNames; } }));
Object.defineProperty(exports, "ThemeSettingName", ({ enumerable: true, get:
function () { return theme_1.ThemeSettingName; } }));
Object.defineProperty(exports, "getTheme", ({ enumerable: true, get: function ()
{ return theme_1.getTheme; } }));
Object.defineProperty(exports, "loadTheme", ({ enumerable: true, get: function () {
return theme_1.loadTheme; } }));
Object.defineProperty(exports, "registerOnThemeChangeCallback", ({ enumerable:
true, get: function () { return theme_1.registerOnThemeChangeCallback; } }));
Object.defineProperty(exports, "removeOnThemeChangeCallback", ({ enumerable: true,
get: function () { return theme_1.removeOnThemeChangeCallback; } }));
/***/ }),
/***/ 39677:
"use strict";

exports.getThemedContext = void 0;
/**
* @internal
* This function is still in experimental phase in support of Foundation
experimental development.
* Its API signature and existence are subject to change.
*
* Modify context to activate the specified scheme or theme. For schemes, look in
context (if available) and fall back
* to global Customizations. If both scheme and theme are specified, scheme will be
looked up in theme. In this case,
* scheme must be present in theme arg, otherwise new context will default to theme
arg (there is no fallback to
* settings to look up scheme.)
*
* @param context - Context in which to get schemed customizations.
* @param scheme - Scheme to get customizations for from theme arg (if supplied) OR
from context and global settings.
* @param theme - Theme to merge into context.
* @returns modified schemed context if scheme is valid and not already applied,
unmodified context otherwise.
*/
function getThemedContext(context, scheme, theme) {
var newContext = context;
var newSettings;
// Only fall back to context and customizations when theme arg is not provided.
var schemeSource = theme || utilities_1.Customizations.getSettings(['theme'],
undefined, context.customizations).theme;
if (theme) {
newSettings = { theme: theme };
}
var schemeTheme = scheme && schemeSource && schemeSource.schemes &&
schemeSource.schemes[scheme];
// These first two checks are logically redundant but TS doesn't infer
schemeSource.schemes is defined
// when schemeTheme is defined.
if (schemeSource && schemeTheme && schemeSource !== schemeTheme) {
newSettings = { theme: schemeTheme };
newSettings.theme.schemes = schemeSource.schemes;
}
if (newSettings) {
newContext = {
customizations: {
settings:
utilities_1.mergeSettings(context.customizations.settings, newSettings),
scopedSettings: context.customizations.scopedSettings,
},
};
}
return newContext;
}
exports.getThemedContext = getThemedContext;
//# sourceMappingURL=scheme.js.map
/***/ }),
/***/ 24656:
"use strict";

exports.loadTheme = exports.removeOnThemeChangeCallback =
exports.registerOnThemeChangeCallback = exports.getTheme =
exports.initializeThemeInCustomizations = exports.ThemeSettingName =
exports.createTheme = void 0;
var _theme = theme_1.createTheme({});
var _onThemeChangeCallbacks = [];
exports.ThemeSettingName = 'theme';
function initializeThemeInCustomizations() {
var _a;
var _b, _c;
if ((_b = win === null || win === void 0 ? void 0 : win.FabricConfig) === null
|| _b === void 0 ? void 0 : _b.legacyTheme) {
// does everything the èlse` clause does and more, such as invoke legacy
theming
loadTheme(win.FabricConfig.legacyTheme);
}
else if (!
utilities_1.Customizations.getSettings([exports.ThemeSettingName]).theme) {
if ((_c = win === null || win === void 0 ? void 0 : win.FabricConfig) ===
null || _c === void 0 ? void 0 : _c.theme) {
_theme = theme_1.createTheme(win.FabricConfig.theme);
}
// Set the default theme.
utilities_1.Customizations.applySettings((_a = {},
_a[exports.ThemeSettingName] = _theme, _a));
}
}
exports.initializeThemeInCustomizations = initializeThemeInCustomizations;
initializeThemeInCustomizations();
/**
* Gets the theme object
* @param depComments - Whether to include deprecated tags as comments for
deprecated slots.
*/
function getTheme(depComments) {
if (depComments === void 0) { depComments = false; }
if (depComments === true) {
_theme = theme_1.createTheme({}, depComments);
}
return _theme;
}
exports.getTheme = getTheme;
/**
* Registers a callback that gets called whenever the theme changes.
* This should only be used when the component cannot automatically get theme
changes through its state.
* This will not register duplicate callbacks.
*/
function registerOnThemeChangeCallback(callback) {
if (_onThemeChangeCallbacks.indexOf(callback) === -1) {
_onThemeChangeCallbacks.push(callback);
}
}
exports.registerOnThemeChangeCallback = registerOnThemeChangeCallback;
/**
* See registerOnThemeChangeCallback().
* Removes previously registered callbacks.
*/
function removeOnThemeChangeCallback(callback) {
var i = _onThemeChangeCallbacks.indexOf(callback);
if (i === -1) {
return;
}
_onThemeChangeCallbacks.splice(i, 1);
}
exports.removeOnThemeChangeCallback = removeOnThemeChangeCallback;
/**
* Applies the theme, while filling in missing slots.
* @param theme - Partial theme object.
deprecated slots.
*/
function loadTheme(theme, depComments) {
var _a;
_theme = theme_1.createTheme(theme, depComments);
// Invoke the legacy method of theming the page as well.
load_themed_styles_1.loadTheme(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(t
slib_1.__assign({}, _theme.palette), _theme.semanticColors), _theme.effects),
_loadFonts(_theme)));
utilities_1.Customizations.applySettings((_a = {}, _a[exports.ThemeSettingName]
= _theme, _a));
_onThemeChangeCallbacks.forEach(function (callback) {
try {
callback(_theme);
}
catch (e) {
// don't let a bad callback break everything else
}
});
return _theme;
}
exports.loadTheme = loadTheme;
/**
* Loads font variables into a JSON object.
* @param theme - The theme object
*/
function _loadFonts(theme) {
var lines = {};
for (var _i = 0, _a = Object.keys(theme.fonts); _i < _a.length; _i++) {
var fontName = _a[_i];
var font = theme.fonts[fontName];
for (var _b = 0, _c = Object.keys(font); _b < _c.length; _b++) {
var propName = _c[_b];
var name_1 = fontName + propName.charAt(0).toUpperCase() +
propName.slice(1);
var value = font[propName];
if (propName === 'fontSize' && typeof value === 'number') {
// if it's a number, convert it to px by default like our theming
system does
value = value + 'px';
}
lines[name_1] = value;
}
}
return lines;
}
//# sourceMappingURL=theme.js.map
/***/ }),
/***/ 28492:
"use strict";

exports.ZIndexes = void 0;
var ZIndexes;
(function (ZIndexes) {
ZIndexes.Nav = 1;
/**
* @deprecated Do not use
*/
ZIndexes.ScrollablePane = 1;
ZIndexes.FocusStyle = 1;
ZIndexes.Coachmark = 1000;
ZIndexes.Layer = 1000000;
ZIndexes.KeytipLayer = 1000001;
})(ZIndexes = exports.ZIndexes || (exports.ZIndexes = {}));
//# sourceMappingURL=zIndexes.js.map
/***/ }),
/***/ 35621:
"use strict";

exports.buildClassMap = void 0;
var MergeStyles_1 = __webpack_require__(42182);
/**
* Builds a class names object from a given map.
*
* @param styles - Map of unprocessed styles.
* @returns Map of property name to class name.
*/
function buildClassMap(styles) {
var classes = {};
var _loop_1 = function (styleName) {
if (styles.hasOwnProperty(styleName)) {
var className_1;
Object.defineProperty(classes, styleName, {
get: function () {
if (className_1 === undefined) {
// eslint-disable-next-line @typescript-eslint/no-explicit-
any
className_1 =
MergeStyles_1.mergeStyles(styles[styleName]).toString();
}
return className_1;
},
enumerable: true,
configurable: true,
});
}
};
for (var styleName in styles) {
_loop_1(styleName);
}
return classes;
}
exports.buildClassMap = buildClassMap;
//# sourceMappingURL=buildClassMap.js.map
/***/ }),
/***/ 578:
"use strict";

exports.getIconClassName = void 0;
var icons_1 = __webpack_require__(20467);
var defaultIconStyles = {
};
/**
* Gets an icon classname. You should be able to add this classname to an I tag
with no
* additional classnames, and render the icon.
*
* @public
*/
function getIconClassName(name) {
var className = '';
var icon = icons_1.getIcon(name);
if (icon) {
className = merge_styles_1.mergeStyles(icon.subset.className,
defaultIconStyles, {
selectors: {
'::before': {
content: "\"" + icon.code + "\"",
},
},
});
}
return className;
}
exports.getIconClassName = getIconClassName;
//# sourceMappingURL=getIconClassName.js.map
/***/ }),
/***/ 20467:
"use strict";

exports.setIconOptions = exports.getIcon = exports.registerIconAlias =
exports.unregisterIcons = exports.registerIcons = void 0;
var ICON_SETTING_NAME = 'icons';
var _iconSettings = utilities_1.GlobalSettings.getValue(ICON_SETTING_NAME, {
__options: {
disableWarnings: false,
warnOnMissingIcons: true,
},
__remapped: {},
});
// Reset icon registration on stylesheet resets.
var stylesheet = merge_styles_1.Stylesheet.getInstance();
if (stylesheet && stylesheet.onReset) {
stylesheet.onReset(function () {
for (var name_1 in _iconSettings) {
if (_iconSettings.hasOwnProperty(name_1) && !!
_iconSettings[name_1].subset) {
_iconSettings[name_1].subset.className = undefined;
}
}
});
}
/**
* Normalizes an icon name for consistent mapping.
* Current implementation is to convert the icon name to lower case.
*
* @param name - Icon name to normalize.
* @returns {string} Normalized icon name to use for indexing and mapping.
*/
var normalizeIconName = function (name) { return name.toLowerCase(); };
/**
* Registers a given subset of icons.
*
* @param iconSubset - the icon subset definition.
*/
function registerIcons(iconSubset, options) {
var subset = tslib_1.__assign(tslib_1.__assign({}, iconSubset), { isRegistered:
false, className: undefined });
var icons = iconSubset.icons;
// Grab options, optionally mix user provided ones on top.
options = options ? tslib_1.__assign(tslib_1.__assign({},
_iconSettings.__options), options) : _iconSettings.__options;
for (var iconName in icons) {
if (icons.hasOwnProperty(iconName)) {
var code = icons[iconName];
var normalizedIconName = normalizeIconName(iconName);
if (_iconSettings[normalizedIconName]) {
_warnDuplicateIcon(iconName);
}
else {
_iconSettings[normalizedIconName] = {
code: code,
subset: subset,
};
}
}
}
}
exports.registerIcons = registerIcons;
/**
* Unregisters icons by name.
*
* @param iconNames - List of icons to unregister.
*/
function unregisterIcons(iconNames) {
var options = _iconSettings.__options;
var _loop_1 = function (iconName) {
var normalizedIconName = normalizeIconName(iconName);
if (_iconSettings[normalizedIconName]) {
delete _iconSettings[normalizedIconName];
}
else {
// Warn that we are trying to delete an icon that doesn't exist
if (!options.disableWarnings) {
utilities_1.warn("The icon \"" + iconName + "\" tried to unregister
but was not registered.");
}
}
// Delete any aliases for this iconName
if (_iconSettings.__remapped[normalizedIconName]) {
delete _iconSettings.__remapped[normalizedIconName];
}
// Delete any items that were an alias for this iconName
Object.keys(_iconSettings.__remapped).forEach(function (key) {
if (_iconSettings.__remapped[key] === normalizedIconName) {
delete _iconSettings.__remapped[key];
}
});
};
for (var _i = 0, iconNames_1 = iconNames; _i < iconNames_1.length; _i++) {
var iconName = iconNames_1[_i];
_loop_1(iconName);
}
}
exports.unregisterIcons = unregisterIcons;
/**
* Remaps one icon name to another.
*/
function registerIconAlias(iconName, mappedToName) {
_iconSettings.__remapped[normalizeIconName(iconName)] =
normalizeIconName(mappedToName);
}
exports.registerIconAlias = registerIconAlias;
/**
* Gets an icon definition. If an icon is requested but the subset has yet to be
registered,
* it will get registered immediately.
*
* @public
* @param name - Name of icon.
*/
function getIcon(name) {
var icon = undefined;
name = name ? normalizeIconName(name) : '';
name = _iconSettings.__remapped[name] || name;
if (name) {
icon = _iconSettings[name];
if (icon) {
var subset = icon.subset;
if (subset && subset.fontFace) {
if (!subset.isRegistered) {
merge_styles_1.fontFace(subset.fontFace);
subset.isRegistered = true;
}
if (!subset.className) {
subset.className = merge_styles_1.mergeStyles(subset.style, {
fontFamily: subset.fontFace.fontFamily,
fontWeight: subset.fontFace.fontWeight || 'normal',
fontStyle: subset.fontFace.fontStyle || 'normal',
});
}
}
}
else {
if (!options.disableWarnings && options.warnOnMissingIcons) {
utilities_1.warn("The icon \"" + name + "\" was used but not
registered. See https://github.com/microsoft/fluentui/wiki/Using-icons for more
information.");
}
}
}
return icon;
}
exports.getIcon = getIcon;
/**
* Sets the icon options.
*
* @public
*/
function setIconOptions(options) {
_iconSettings.__options = tslib_1.__assign(tslib_1.__assign({},
_iconSettings.__options), options);
}
exports.setIconOptions = setIconOptions;
var _missingIcons = [];
var _missingIconsTimer = undefined;
function _warnDuplicateIcon(iconName) {
var warningDelay = 2000;
var maxIconsInMessage = 10;
if (!options.disableWarnings) {
_missingIcons.push(iconName);
if (_missingIconsTimer === undefined) {
_missingIconsTimer = setTimeout(function () {
utilities_1.warn("Some icons were re-registered. Applications
should only call registerIcons for any given " +
"icon once. Redefining what an icon is may have unintended
consequences. Duplicates " +
"include: \n" +
_missingIcons.slice(0, maxIconsInMessage).join(', ') +
(_missingIcons.length > maxIconsInMessage ? " (+ " +
(_missingIcons.length - maxIconsInMessage) + " more)" : ''));
_missingIconsTimer = undefined;
_missingIcons = [];
}, warningDelay);
}
}
}
//# sourceMappingURL=icons.js.map
/***/ }),
/***/ 10334:
"use strict";

exports.getIconClassName = exports.setIconOptions = exports.unregisterIcons =
exports.registerIconAlias = exports.registerIcons = exports.getIcon =
exports.buildClassMap = void 0;
var buildClassMap_1 = __webpack_require__(35621);
Object.defineProperty(exports, "buildClassMap", ({ enumerable: true, get: function
() { return buildClassMap_1.buildClassMap; } }));
var icons_1 = __webpack_require__(20467);
Object.defineProperty(exports, "getIcon", ({ enumerable: true, get: function ()
{ return icons_1.getIcon; } }));
Object.defineProperty(exports, "registerIcons", ({ enumerable: true, get: function
() { return icons_1.registerIcons; } }));
Object.defineProperty(exports, "registerIconAlias", ({ enumerable: true, get:
function () { return icons_1.registerIconAlias; } }));
Object.defineProperty(exports, "unregisterIcons", ({ enumerable: true, get:
function () { return icons_1.unregisterIcons; } }));
Object.defineProperty(exports, "setIconOptions", ({ enumerable: true, get: function
() { return icons_1.setIconOptions; } }));
var getIconClassName_1 = __webpack_require__(578);
Object.defineProperty(exports, "getIconClassName", ({ enumerable: true, get:
function () { return getIconClassName_1.getIconClassName; } }));
/***/ }),
/***/ 66686:
"use strict";

set_version_1.setVersion('@fluentui/style-utilities', '8.7.0');
/***/ }),
/***/ 34886:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 60234:
"use strict";

exports.FluentTheme = void 0;
var createTheme_1 = __webpack_require__(27298);
exports.FluentTheme = createTheme_1.createTheme({});
//# sourceMappingURL=FluentTheme.js.map
/***/ }),
/***/ 25323:
"use strict";

// When adding or removing a color, make sure you keep this consistent with
IColorClassNames
// by adding the color variants.
exports.DefaultPalette = {
themeDarker: '#004578',
themeDark: '#005a9e',
themeDarkAlt: '#106ebe',
themePrimary: '#0078d4',
themeSecondary: '#2b88d8',
themeTertiary: '#71afe5',
themeLight: '#c7e0f4',
themeLighter: '#deecf9',
themeLighterAlt: '#eff6fc',
black: '#000000',
blackTranslucent40: 'rgba(0,0,0,.4)',
neutralDark: '#201f1e',
neutralPrimary: '#323130',
neutralPrimaryAlt: '#3b3a39',
neutralSecondary: '#605e5c',
neutralSecondaryAlt: '#8a8886',
neutralTertiary: '#a19f9d',
neutralTertiaryAlt: '#c8c6c4',
neutralQuaternary: '#d2d0ce',
neutralQuaternaryAlt: '#e1dfdd',
neutralLight: '#edebe9',
neutralLighter: '#f3f2f1',
neutralLighterAlt: '#faf9f8',
accent: '#0078d4',
white: '#ffffff',
whiteTranslucent40: 'rgba(255,255,255,.4)',
yellowDark: '#d29200',
yellow: '#ffb900',
yellowLight: '#fff100',
orange: '#d83b01',
orangeLight: '#ea4300',
orangeLighter: '#ff8c00',
redDark: '#a4262c',
red: '#e81123',
magentaDark: '#5c005c',
magenta: '#b4009e',
magentaLight: '#e3008c',
purpleDark: '#32145a',
purple: '#5c2d91',
purpleLight: '#b4a0ff',
blueDark: '#002050',
blueMid: '#00188f',
blue: '#0078d4',
blueLight: '#00bcf2',
tealDark: '#004b50',
teal: '#008272',
tealLight: '#00b294',
greenDark: '#004b1c',
green: '#107c10',
greenLight: '#bad80a',
};
//# sourceMappingURL=DefaultPalette.js.map
/***/ }),
/***/ 15577:
"use strict";

exports.SharedColors = exports.NeutralColors = exports.CommunicationColors = void
0;
var CommunicationColors;
(function (CommunicationColors) {
CommunicationColors.shade30 = '#004578';
CommunicationColors.shade20 = '#005a9e';
CommunicationColors.shade10 = '#106ebe';
CommunicationColors.primary = '#0078d4';
CommunicationColors.tint10 = '#2b88d8';
CommunicationColors.tint20 = '#c7e0f4';
CommunicationColors.tint30 = '#deecf9';
CommunicationColors.tint40 = '#eff6fc';
})(CommunicationColors = exports.CommunicationColors ||
(exports.CommunicationColors = {}));
var NeutralColors;
(function (NeutralColors) {
NeutralColors.black = '#000000';
NeutralColors.gray220 = '#11100f';
NeutralColors.gray210 = '#161514';
NeutralColors.gray200 = '#1b1a19';
NeutralColors.gray190 = '#201f1e';
NeutralColors.gray150 = '#3b3a39';
NeutralColors.gray130 = '#605e5c';
NeutralColors.gray110 = '#8a8886';
NeutralColors.gray90 = '#a19f9d';
NeutralColors.gray80 = '#b3b0ad';
NeutralColors.gray70 = '#bebbb8';
NeutralColors.gray60 = '#c8c6c4';
NeutralColors.gray50 = '#d2d0ce';
NeutralColors.gray40 = '#e1dfdd';
NeutralColors.gray30 = '#edebe9';
NeutralColors.gray20 = '#f3f2f1';
NeutralColors.gray10 = '#faf9f8';
NeutralColors.white = '#ffffff';
})(NeutralColors = exports.NeutralColors || (exports.NeutralColors = {}));
var SharedColors;
(function (SharedColors) {
SharedColors.pinkRed10 = '#750b1c';
SharedColors.red20 = '#a4262c';
SharedColors.red10 = '#d13438';
SharedColors.redOrange20 = '#603d30';
SharedColors.redOrange10 = '#da3b01';
SharedColors.orange30 = '#8e562e';
SharedColors.orange20 = '#ca5010';
SharedColors.orange10 = '#ffaa44';
SharedColors.yellow10 = '#fce100';
SharedColors.orangeYellow20 = '#986f0b';
SharedColors.orangeYellow10 = '#c19c00';
SharedColors.yellowGreen10 = '#8cbd18';
SharedColors.green20 = '#0b6a0b';
SharedColors.green10 = '#498205';
SharedColors.greenCyan10 = '#00ad56';
SharedColors.cyan40 = '#005e50';
SharedColors.cyan30 = '#005b70';
SharedColors.cyan20 = '#038387';
SharedColors.cyan10 = '#00b7c3';
SharedColors.cyanBlue20 = '#004e8c';
SharedColors.cyanBlue10 = '#0078d4';
SharedColors.blue10 = '#4f6bed';
SharedColors.blueMagenta40 = '#373277';
SharedColors.blueMagenta30 = '#5c2e91';
SharedColors.blueMagenta20 = '#8764b8';
SharedColors.blueMagenta10 = '#8378de';
SharedColors.magenta20 = '#881798';
SharedColors.magenta10 = '#c239b3';
SharedColors.magentaPink20 = '#9b0062';
SharedColors.magentaPink10 = '#e3008c';
SharedColors.gray40 = '#393939';
SharedColors.gray30 = '#7a7574';
SharedColors.gray20 = '#69797e';
SharedColors.gray10 = '#a0aeb2';
})(SharedColors = exports.SharedColors || (exports.SharedColors = {}));
//# sourceMappingURL=FluentColors.js.map
/***/ }),
/***/ 65202:
"use strict";

() { return DefaultPalette_1.DefaultPalette; } }));
/***/ }),
/***/ 27298:
"use strict";

exports.createTheme = void 0;
var mergeThemes_1 = __webpack_require__(31683);
var makeSemanticColors_1 = __webpack_require__(59298);
/**
* Creates a custom theme definition.
* @param theme - Partial theme object.
deprecated slots.
*/
function createTheme(theme, depComments) {
if (theme === void 0) { theme = {}; }
var isInverted = !!theme.isInverted;
var baseTheme = {
palette: index_1.DefaultPalette,
effects: index_2.DefaultEffects,
fonts: index_3.DefaultFontStyles,
spacing: index_4.DefaultSpacing,
isInverted: isInverted,
disableGlobalClassNames: false,
semanticColors:
makeSemanticColors_1.makeSemanticColors(index_1.DefaultPalette,
index_2.DefaultEffects, undefined, isInverted, depComments),
rtl: undefined,
};
return mergeThemes_1.mergeThemes(baseTheme, theme);
}
exports.createTheme = createTheme;
//# sourceMappingURL=createTheme.js.map
/***/ }),
/***/ 37784:
"use strict";

exports.DefaultEffects = void 0;
var FluentDepths_1 = __webpack_require__(49285);
exports.DefaultEffects = {
elevation4: FluentDepths_1.Depths.depth4,
roundedCorner2: '2px',
};
//# sourceMappingURL=DefaultEffects.js.map
/***/ }),
/***/ 49285:
"use strict";

exports.Depths = void 0;
var Depths;
(function (Depths) {
Depths.depth0 = '0 0 0 0 transparent';
Depths.depth4 = '0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0,
0, 0, 0.108)';
Depths.depth8 = '0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0,
0, 0, 0.108)';
Depths.depth16 = '0 6.4px 14.4px 0 rgba(0, 0, 0, 0.132), 0 1.2px 3.6px 0
rgba(0, 0, 0, 0.108)';
Depths.depth64 = '0 25.6px 57.6px 0 rgba(0, 0, 0, 0.22), 0 4.8px 14.4px 0
rgba(0, 0, 0, 0.18)';
})(Depths = exports.Depths || (exports.Depths = {}));
//# sourceMappingURL=FluentDepths.js.map
/***/ }),
/***/ 80570:
"use strict";

exports.Depths = exports.DefaultEffects = void 0;
var DefaultEffects_1 = __webpack_require__(37784);
() { return DefaultEffects_1.DefaultEffects; } }));
var FluentDepths_1 = __webpack_require__(49285);
{ return FluentDepths_1.Depths; } }));
/***/ }),
/***/ 27736:
"use strict";

exports.registerDefaultFontFaces = exports.DefaultFontStyles = void 0;
var FluentFonts_1 = __webpack_require__(15695);
var createFontStyles_1 = __webpack_require__(96070);
// Default urls.
var DefaultBaseUrl = 'https://static2.sharepointonline.com/files/fabric/assets';
// Standard font styling.
exports.DefaultFontStyles =
createFontStyles_1.createFontStyles(utilities_1.getLanguage());
function _registerFontFace(fontFamily, url, fontWeight, localFontName) {
fontFamily = "'" + fontFamily + "'";
var localFontSrc = localFontName !== undefined ? "local('" + localFontName +
"')," : '';
merge_styles_1.fontFace({
fontFamily: fontFamily,
src: localFontSrc + ("url('" + url + ".woff2') format('woff2'),") +
("url('" + url + ".woff') format('woff')"),
fontWeight: fontWeight,
fontDisplay: 'swap',
});
}
function _registerFontFaceSet(baseUrl, fontFamily, cdnFolder, cdnFontName,
localFontName) {
if (cdnFontName === void 0) { cdnFontName = 'segoeui'; }
var urlBase = baseUrl + "/" + cdnFolder + "/" + cdnFontName;
_registerFontFace(fontFamily, urlBase + '-light',
FluentFonts_1.FontWeights.light, localFontName && localFontName + ' Light');
_registerFontFace(fontFamily, urlBase + '-semilight',
FluentFonts_1.FontWeights.semilight, localFontName && localFontName + '
SemiLight');
_registerFontFace(fontFamily, urlBase + '-regular',
FluentFonts_1.FontWeights.regular, localFontName);
_registerFontFace(fontFamily, urlBase + '-semibold',
FluentFonts_1.FontWeights.semibold, localFontName && localFontName + ' SemiBold');
_registerFontFace(fontFamily, urlBase + '-bold',
FluentFonts_1.FontWeights.bold, localFontName && localFontName + ' Bold');
}
function registerDefaultFontFaces(baseUrl) {
if (baseUrl) {
var fontUrl = baseUrl + "/fonts";
// Produce @font-face definitions for all supported web fonts.
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Thai,
'leelawadeeui-thai', 'leelawadeeui');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Arabic,
'segoeui-arabic');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Cyrillic,
'segoeui-cyrillic');
_registerFontFaceSet(fontUrl,
FluentFonts_1.LocalizedFontNames.EastEuropean, 'segoeui-easteuropean');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Greek,
'segoeui-greek');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Hebrew,
'segoeui-hebrew');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Vietnamese,
'segoeui-vietnamese');
_registerFontFaceSet(fontUrl,
FluentFonts_1.LocalizedFontNames.WestEuropean, 'segoeui-westeuropean', 'segoeui',
'Segoe UI');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontFamilies.Selawik,
'selawik', 'selawik');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Armenian,
'segoeui-armenian');
_registerFontFaceSet(fontUrl, FluentFonts_1.LocalizedFontNames.Georgian,
'segoeui-georgian');
// Leelawadee UI (Thai) does not have a 'light' weight, so we override
// the font-face generated above to use the 'semilight' weight instead.
_registerFontFace('Leelawadee UI Web', fontUrl +
"/leelawadeeui-thai/leelawadeeui-semilight", FluentFonts_1.FontWeights.light);
// Leelawadee UI (Thai) does not have a 'semibold' weight, so we override
// the font-face generated above to use the 'bold' weight instead.
_registerFontFace('Leelawadee UI Web', fontUrl +
"/leelawadeeui-thai/leelawadeeui-bold", FluentFonts_1.FontWeights.semibold);
}
}
exports.registerDefaultFontFaces = registerDefaultFontFaces;
/**
* Reads the fontBaseUrl from window.FabricConfig.fontBaseUrl or falls back to a
default.
*/
function _getFontBaseUrl() {
var _a, _b;
var fabricConfig = (_a = utilities_1.getWindow()) === null || _a === void 0 ?
void 0 : _a.FabricConfig;
return (_b = fabricConfig === null || fabricConfig === void 0 ? void 0 :
fabricConfig.fontBaseUrl) !== null && _b !== void 0 ? _b : DefaultBaseUrl;
}
/**
* Register the font faces.
*/
registerDefaultFontFaces(_getFontBaseUrl());
//# sourceMappingURL=DefaultFontStyles.js.map
/***/ }),
/***/ 15695:
"use strict";

exports.IconFontSizes = exports.FontWeights = exports.FontSizes =
exports.LocalizedFontFamilies = exports.LocalizedFontNames = void 0;
// Font face names to be registered.
var LocalizedFontNames;
(function (LocalizedFontNames) {
LocalizedFontNames.Arabic = 'Segoe UI Web (Arabic)';
LocalizedFontNames.Cyrillic = 'Segoe UI Web (Cyrillic)';
LocalizedFontNames.EastEuropean = 'Segoe UI Web (East European)';
LocalizedFontNames.Greek = 'Segoe UI Web (Greek)';
LocalizedFontNames.Hebrew = 'Segoe UI Web (Hebrew)';
LocalizedFontNames.Thai = 'Leelawadee UI Web';
LocalizedFontNames.Vietnamese = 'Segoe UI Web (Vietnamese)';
LocalizedFontNames.WestEuropean = 'Segoe UI Web (West European)';
LocalizedFontNames.Selawik = 'Selawik Web';
LocalizedFontNames.Armenian = 'Segoe UI Web (Armenian)';
LocalizedFontNames.Georgian = 'Segoe UI Web (Georgian)';
})(LocalizedFontNames = exports.LocalizedFontNames || (exports.LocalizedFontNames =
{}));
// Font families with fallbacks, for the general regions.
var LocalizedFontFamilies;
(function (LocalizedFontFamilies) {
LocalizedFontFamilies.Arabic = "'" + LocalizedFontNames.Arabic + "'";
LocalizedFontFamilies.ChineseSimplified = "'Microsoft Yahei UI', Verdana,
Simsun";
LocalizedFontFamilies.ChineseTraditional = "'Microsoft Jhenghei UI', Pmingliu";
LocalizedFontFamilies.Cyrillic = "'" + LocalizedFontNames.Cyrillic + "'";
LocalizedFontFamilies.EastEuropean = "'" + LocalizedFontNames.EastEuropean +
"'";
LocalizedFontFamilies.Greek = "'" + LocalizedFontNames.Greek + "'";
LocalizedFontFamilies.Hebrew = "'" + LocalizedFontNames.Hebrew + "'";
LocalizedFontFamilies.Hindi = "'Nirmala UI'";
LocalizedFontFamilies.Japanese = "'Yu Gothic UI', 'Meiryo UI', Meiryo, 'MS
Pgothic', Osaka";
LocalizedFontFamilies.Korean = "'Malgun Gothic', Gulim";
LocalizedFontFamilies.Selawik = "'" + LocalizedFontNames.Selawik + "'";
LocalizedFontFamilies.Thai = "'Leelawadee UI Web', 'Kmer UI'";
LocalizedFontFamilies.Vietnamese = "'" + LocalizedFontNames.Vietnamese + "'";
LocalizedFontFamilies.WestEuropean = "'" + LocalizedFontNames.WestEuropean +
"'";
LocalizedFontFamilies.Armenian = "'" + LocalizedFontNames.Armenian + "'";
LocalizedFontFamilies.Georgian = "'" + LocalizedFontNames.Georgian + "'";
})(LocalizedFontFamilies = exports.LocalizedFontFamilies ||
(exports.LocalizedFontFamilies = {}));
// Standard font sizes.
var FontSizes;
(function (FontSizes) {
FontSizes.size10 = '10px';
FontSizes.mini = '10px';
FontSizes.xSmall = '10px';
FontSizes.small = '12px';
FontSizes.smallPlus = '12px';
FontSizes.medium = '14px';
FontSizes.mediumPlus = '16px';
FontSizes.icon = '16px';
FontSizes.large = '18px';
FontSizes.xLarge = '20px';
FontSizes.xLargePlus = '24px';
FontSizes.xxLarge = '28px';
FontSizes.xxLargePlus = '32px';
FontSizes.superLarge = '42px';
FontSizes.mega = '68px';
})(FontSizes = exports.FontSizes || (exports.FontSizes = {}));
// Standard font weights.
var FontWeights;
(function (FontWeights) {
FontWeights.light = 100;
FontWeights.semilight = 300;
FontWeights.regular = 400;
FontWeights.semibold = 600;
FontWeights.bold = 700;
})(FontWeights = exports.FontWeights || (exports.FontWeights = {}));
// Standard Icon Sizes.
var IconFontSizes;
(function (IconFontSizes) {
IconFontSizes.xSmall = '10px';
IconFontSizes.small = '12px';
IconFontSizes.medium = '16px';
IconFontSizes.large = '20px';
})(IconFontSizes = exports.IconFontSizes || (exports.IconFontSizes = {}));
//# sourceMappingURL=FluentFonts.js.map
/***/ }),
/***/ 96070:
"use strict";

exports.createFontStyles = void 0;
var FluentFonts_1 = __webpack_require__(15695);
// Fallback fonts, if specified system or web fonts are unavailable.
var FontFamilyFallbacks = "'Segoe UI', -apple-system, BlinkMacSystemFont, 'Roboto',
'Helvetica Neue', sans-serif";
// By default, we favor system fonts for the default.
// All localized fonts use a web font and never use the system font.
var defaultFontFamily = "'Segoe UI', '" +
FluentFonts_1.LocalizedFontNames.WestEuropean + "'";
// Mapping of language prefix to to font family.
var LanguageToFontMap = {
ar: FluentFonts_1.LocalizedFontFamilies.Arabic,
bg: FluentFonts_1.LocalizedFontFamilies.Cyrillic,
cs: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
el: FluentFonts_1.LocalizedFontFamilies.Greek,
et: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
he: FluentFonts_1.LocalizedFontFamilies.Hebrew,
hi: FluentFonts_1.LocalizedFontFamilies.Hindi,
hr: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
hu: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
ja: FluentFonts_1.LocalizedFontFamilies.Japanese,
kk: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
ko: FluentFonts_1.LocalizedFontFamilies.Korean,
lt: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
lv: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
pl: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
ru: FluentFonts_1.LocalizedFontFamilies.Cyrillic,
sk: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
'sr-latn': FluentFonts_1.LocalizedFontFamilies.EastEuropean,
th: FluentFonts_1.LocalizedFontFamilies.Thai,
tr: FluentFonts_1.LocalizedFontFamilies.EastEuropean,
uk: FluentFonts_1.LocalizedFontFamilies.Cyrillic,
vi: FluentFonts_1.LocalizedFontFamilies.Vietnamese,
'zh-hans': FluentFonts_1.LocalizedFontFamilies.ChineseSimplified,
'zh-hant': FluentFonts_1.LocalizedFontFamilies.ChineseTraditional,
hy: FluentFonts_1.LocalizedFontFamilies.Armenian,
ka: FluentFonts_1.LocalizedFontFamilies.Georgian,
};
function _fontFamilyWithFallbacks(fontFamily) {
return fontFamily + ", " + FontFamilyFallbacks;
}
/**
* If there is a localized font for this language, return that.
* Returns undefined if there is no localized font for that language.
*/
function _getLocalizedFontFamily(language) {
for (var lang in LanguageToFontMap) {
if (LanguageToFontMap.hasOwnProperty(lang) && language &&
lang.indexOf(language) === 0) {
return LanguageToFontMap[lang];
}
}
return defaultFontFamily;
}
function _createFont(size, weight, fontFamily) {
return {
fontFamily: fontFamily,
fontSize: size,
fontWeight: weight,
};
}
function createFontStyles(localeCode) {
var localizedFont = _getLocalizedFontFamily(localeCode);
var fontFamilyWithFallback = _fontFamilyWithFallbacks(localizedFont);
var fontStyles = {
tiny: _createFont(FluentFonts_1.FontSizes.mini,
FluentFonts_1.FontWeights.regular, fontFamilyWithFallback),
xSmall: _createFont(FluentFonts_1.FontSizes.xSmall,
small: _createFont(FluentFonts_1.FontSizes.small,
smallPlus: _createFont(FluentFonts_1.FontSizes.smallPlus,
medium: _createFont(FluentFonts_1.FontSizes.medium,
mediumPlus: _createFont(FluentFonts_1.FontSizes.mediumPlus,
large: _createFont(FluentFonts_1.FontSizes.large,
xLarge: _createFont(FluentFonts_1.FontSizes.xLarge,
FluentFonts_1.FontWeights.semibold, fontFamilyWithFallback),
xLargePlus: _createFont(FluentFonts_1.FontSizes.xLargePlus,
xxLarge: _createFont(FluentFonts_1.FontSizes.xxLarge,
xxLargePlus: _createFont(FluentFonts_1.FontSizes.xxLargePlus,
superLarge: _createFont(FluentFonts_1.FontSizes.superLarge,
mega: _createFont(FluentFonts_1.FontSizes.mega,
};
return fontStyles;
}
exports.createFontStyles = createFontStyles;
//# sourceMappingURL=createFontStyles.js.map
/***/ }),
/***/ 69490:
"use strict";

exports.registerDefaultFontFaces = exports.DefaultFontStyles =
exports.createFontStyles = void 0;
var createFontStyles_1 = __webpack_require__(96070);
function () { return createFontStyles_1.createFontStyles; } }));
function () { return DefaultFontStyles_1.DefaultFontStyles; } }));
get: function () { return DefaultFontStyles_1.registerDefaultFontFaces; } }));
/***/ }),
/***/ 44337:
"use strict";

exports.FluentTheme = void 0;
var FluentTheme_1 = __webpack_require__(60234);
{ return FluentTheme_1.FluentTheme; } }));
/***/ }),
/***/ 31683:
"use strict";

exports.mergeThemes = void 0;
var makeSemanticColors_1 = __webpack_require__(59298);
/**
* Merge a partial/full theme into a full theme and returns a merged full theme.
*/
function mergeThemes(theme, partialTheme) {
var _a, _b, _c;
if (partialTheme === void 0) { partialTheme = {}; }
var mergedTheme = utilities_1.merge({}, theme, partialTheme, {
semanticColors:
makeSemanticColors_1.getSemanticColors(partialTheme.palette, partialTheme.effects,
partialTheme.semanticColors, partialTheme.isInverted === undefined ?
theme.isInverted : partialTheme.isInverted),
});
if (((_a = partialTheme.palette) === null || _a === void 0 ? void 0 :
_a.themePrimary) && !((_b = partialTheme.palette) === null || _b === void 0 ? void
0 : _b.accent)) {
mergedTheme.palette.accent = partialTheme.palette.themePrimary;
}
if (partialTheme.defaultFontStyle) {
for (var _i = 0, _d = Object.keys(mergedTheme.fonts); _i < _d.length; _i++)
{
var fontStyle = _d[_i];
mergedTheme.fonts[fontStyle] =
utilities_1.merge(mergedTheme.fonts[fontStyle], partialTheme.defaultFontStyle, (_c
= partialTheme === null || partialTheme === void 0 ? void 0 : partialTheme.fonts)
=== null || _c === void 0 ? void 0 : _c[fontStyle]);
}
}
return mergedTheme;
}
exports.mergeThemes = mergeThemes;
//# sourceMappingURL=mergeThemes.js.map
/***/ }),
/***/ 22913:
"use strict";

exports.AnimationStyles = exports.AnimationVariables = void 0;
/* Register the keyframes */
var EASING_FUNCTION_1 = 'cubic-bezier(.1,.9,.2,1)';
var EASING_FUNCTION_2 = 'cubic-bezier(.1,.25,.75,.9)';
var DURATION_1 = '0.167s';
var FADE_IN = merge_styles_1.keyframes({
to: { opacity: 1 },
});
var FADE_OUT = merge_styles_1.keyframes({
to: { opacity: 0, visibility: 'hidden' },
});
var SLIDE_RIGHT_IN10 = _createSlideInX(-10);
var SLIDE_LEFT_IN10 = _createSlideInX(10);
var SLIDE_UP_IN10 = _createSlideInY(10);
var SLIDE_UP_IN20 = _createSlideInY(20);
var SLIDE_DOWN_IN10 = _createSlideInY(-10);
var SLIDE_DOWN_IN20 = _createSlideInY(-20);
var SLIDE_RIGHT_OUT10 = _createSlideOutX(10);
var SLIDE_LEFT_OUT10 = _createSlideOutX(-10);
var SLIDE_UP_OUT10 = _createSlideOutY(-10);
var SLIDE_UP_OUT20 = _createSlideOutY(-20);
var SLIDE_DOWN_OUT10 = _createSlideOutY(10);
var SLIDE_DOWN_OUT20 = _createSlideOutY(20);
var SCALE_UP100 = merge_styles_1.keyframes({
from: { transform: 'scale3d(.98,.98,1)' },
to: { transform: 'scale3d(1,1,1)' },
});
var SCALE_DOWN98 = merge_styles_1.keyframes({
from: { transform: 'scale3d(1,1,1)' },
to: { transform: 'scale3d(.98,.98,1)' },
});
var SCALE_DOWN100 = merge_styles_1.keyframes({
from: { transform: 'scale3d(1.03,1.03,1)' },
to: { transform: 'scale3d(1,1,1)' },
});
var SCALE_UP103 = merge_styles_1.keyframes({
from: { transform: 'scale3d(1,1,1)' },
to: { transform: 'scale3d(1.03,1.03,1)' },
});
var ROTATE90 = merge_styles_1.keyframes({
from: { transform: 'rotateZ(0deg)' },
to: { transform: 'rotateZ(90deg)' },
});
var ROTATE_N90 = merge_styles_1.keyframes({
from: { transform: 'rotateZ(0deg)' },
to: { transform: 'rotateZ(-90deg)' },
});
/**
* Exporting raw duraction values and easing functions to be used in custom
animations
*/
exports.AnimationVariables = {
easeFunction1: EASING_FUNCTION_1,
easeFunction2: EASING_FUNCTION_2,
durationValue1: DURATION_1,
};
/**
* All Fabric standard animations, exposed as json objects referencing predefined
* keyframes. These objects can be mixed in with other class definitions.
*/
exports.AnimationStyles = {
slideRightIn10: _createAnimation(FADE_IN + "," + SLIDE_RIGHT_IN10, DURATION_3,
EASING_FUNCTION_1),
EASING_FUNCTION_1),
EASING_FUNCTION_1),
slideRightIn400: _createAnimation(FADE_IN + "," + SLIDE_RIGHT_IN400,
DURATION_3, EASING_FUNCTION_1),
slideLeftIn10: _createAnimation(FADE_IN + "," + SLIDE_LEFT_IN10, DURATION_3,
EASING_FUNCTION_1),
EASING_FUNCTION_1),
EASING_FUNCTION_1),
EASING_FUNCTION_1),
slideUpIn10: _createAnimation(FADE_IN + "," + SLIDE_UP_IN10, DURATION_3,
EASING_FUNCTION_1),
slideUpIn20: _createAnimation(FADE_IN + "," + SLIDE_UP_IN20, DURATION_3,
EASING_FUNCTION_1),
slideDownIn10: _createAnimation(FADE_IN + "," + SLIDE_DOWN_IN10, DURATION_3,
EASING_FUNCTION_1),
slideDownIn20: _createAnimation(FADE_IN + "," + SLIDE_DOWN_IN20, DURATION_3,
EASING_FUNCTION_1),
slideRightOut10: _createAnimation(FADE_OUT + "," + SLIDE_RIGHT_OUT10,
slideLeftOut10: _createAnimation(FADE_OUT + "," + SLIDE_LEFT_OUT10, DURATION_3,
EASING_FUNCTION_1),
EASING_FUNCTION_1),
EASING_FUNCTION_1),
slideLeftOut400: _createAnimation(FADE_OUT + "," + SLIDE_LEFT_OUT400,
slideUpOut10: _createAnimation(FADE_OUT + "," + SLIDE_UP_OUT10, DURATION_3,
EASING_FUNCTION_1),
slideUpOut20: _createAnimation(FADE_OUT + "," + SLIDE_UP_OUT20, DURATION_3,
EASING_FUNCTION_1),
slideDownOut10: _createAnimation(FADE_OUT + "," + SLIDE_DOWN_OUT10, DURATION_3,
EASING_FUNCTION_1),
slideDownOut20: _createAnimation(FADE_OUT + "," + SLIDE_DOWN_OUT20, DURATION_3,
EASING_FUNCTION_1),
scaleUpIn100: _createAnimation(FADE_IN + "," + SCALE_UP100, DURATION_3,
EASING_FUNCTION_1),
scaleDownIn100: _createAnimation(FADE_IN + "," + SCALE_DOWN100, DURATION_3,
EASING_FUNCTION_1),
scaleUpOut103: _createAnimation(FADE_OUT + "," + SCALE_UP103, DURATION_1,
EASING_FUNCTION_2),
scaleDownOut98: _createAnimation(FADE_OUT + "," + SCALE_DOWN98, DURATION_1,
EASING_FUNCTION_2),
fadeIn100: _createAnimation(FADE_IN, DURATION_1, EASING_FUNCTION_2),
fadeOut100: _createAnimation(FADE_OUT, DURATION_1, EASING_FUNCTION_2),
rotate90deg: _createAnimation(ROTATE90, '0.1s', EASING_FUNCTION_2),
rotateN90deg: _createAnimation(ROTATE_N90, '0.1s', EASING_FUNCTION_2),
// expandCollapse 100/200/400, delay 100/200
};
function _createAnimation(animationName, animationDuration,
animationTimingFunction) {
return {
animationName: animationName,
animationDuration: animationDuration,
animationTimingFunction: animationTimingFunction,
animationFillMode: 'both',
};
}
function _createSlideInX(fromX) {
from: { transform: "translate3d(" + fromX + "px,0,0)", pointerEvents:
'none' },
to: { transform: "translate3d(0,0,0)", pointerEvents: 'auto' },
});
}
function _createSlideInY(fromY) {
from: { transform: "translate3d(0," + fromY + "px,0)", pointerEvents:
'none' },
to: { transform: "translate3d(0,0,0)", pointerEvents: 'auto' },
});
}
function _createSlideOutX(toX) {
from: { transform: "translate3d(0,0,0)" },
to: { transform: "translate3d(" + toX + "px,0,0)" },
});
}
function _createSlideOutY(toY) {
from: { transform: "translate3d(0,0,0)" },
to: { transform: "translate3d(0," + toY + "px,0)" },
});
}
//# sourceMappingURL=AnimationStyles.js.map
/***/ }),
/***/ 93177:
"use strict";

exports.MotionAnimations = exports.MotionTimings = exports.MotionDurations = void
0;
var fadeInAnimationName = merge_styles_1.keyframes({
to: { opacity: 1 },
});
var fadeOutAnimationName = merge_styles_1.keyframes({
to: { opacity: 0 },
});
var scaleDownInAnimationName = merge_styles_1.keyframes({
from: { transform: 'scale3d(1.15, 1.15, 1)' },
to: { transform: 'scale3d(1, 1, 1)' },
});
var scaleDownOutAnimationName = merge_styles_1.keyframes({
from: { transform: 'scale3d(1, 1, 1)' },
to: { transform: 'scale3d(0.9, 0.9, 1)' },
});
var slideLeftOutAnimationName = merge_styles_1.keyframes({
from: { transform: 'translate3d(0, 0, 0)' },
to: { transform: 'translate3d(-48px, 0, 0)' },
});
var slideRightOutAnimationName = merge_styles_1.keyframes({
to: { transform: 'translate3d(48px, 0, 0)' },
});
var slideLeftInAnimationName = merge_styles_1.keyframes({
from: { transform: 'translate3d(48px, 0, 0)' },
to: { transform: 'translate3d(0, 0, 0)' },
});
var slideRightInAnimationName = merge_styles_1.keyframes({
from: { transform: 'translate3d(-48px, 0, 0)' },
});
var slideUpOutAnimationName = merge_styles_1.keyframes({
to: { transform: 'translate3d(0, -48px, 0)' },
});
var slideDownOutAnimationName = merge_styles_1.keyframes({
to: { transform: 'translate3d(0, 48px, 0)' },
});
var slideUpInAnimationName = merge_styles_1.keyframes({
from: { transform: 'translate3d(0, 48px, 0)' },
});
var slideDownInAnimationName = merge_styles_1.keyframes({
from: { transform: 'translate3d(0, -48px, 0)' },
});
var MotionDurations;
(function (MotionDurations) {
MotionDurations.duration1 = '100ms';
})(MotionDurations = exports.MotionDurations || (exports.MotionDurations = {}));
var MotionTimings;
(function (MotionTimings) {
MotionTimings.accelerate = 'cubic-bezier(0.9, 0.1, 1, 0.2)';
MotionTimings.decelerate = 'cubic-bezier(0.1, 0.9, 0.2, 1)';
MotionTimings.linear = 'cubic-bezier(0, 0, 1, 1)';
MotionTimings.standard = 'cubic-bezier(0.8, 0, 0.2, 1)';
})(MotionTimings = exports.MotionTimings || (exports.MotionTimings = {}));
function _createAnimation(animationName, animationDuration,
animationTimingFunction) {
return animationName + " " + animationDuration + " " + animationTimingFunction;
}
var MotionAnimations;
(function (MotionAnimations) {
MotionAnimations.fadeIn = _createAnimation(fadeInAnimationName,
MotionDurations.duration1, MotionTimings.linear);
MotionAnimations.fadeOut = _createAnimation(fadeOutAnimationName,
MotionDurations.duration1, MotionTimings.linear);
MotionAnimations.scaleDownIn = _createAnimation(scaleDownInAnimationName,
MotionDurations.duration3, MotionTimings.decelerate);
MotionAnimations.scaleDownOut = _createAnimation(scaleDownOutAnimationName,
MotionAnimations.slideLeftOut = _createAnimation(slideLeftOutAnimationName,
MotionDurations.duration1, MotionTimings.accelerate);
MotionAnimations.slideRightOut = _createAnimation(slideRightOutAnimationName,
MotionAnimations.slideLeftIn = _createAnimation(slideLeftInAnimationName,
MotionAnimations.slideRightIn = _createAnimation(slideRightInAnimationName,
MotionAnimations.slideUpOut = _createAnimation(slideUpOutAnimationName,
MotionAnimations.slideDownOut = _createAnimation(slideDownOutAnimationName,
MotionAnimations.slideUpIn = _createAnimation(slideUpInAnimationName,
MotionAnimations.slideDownIn = _createAnimation(slideDownInAnimationName,
})(MotionAnimations = exports.MotionAnimations || (exports.MotionAnimations = {}));
//# sourceMappingURL=FluentMotion.js.map
/***/ }),
/***/ 17861:
"use strict";

/***/ }),
/***/ 62765:
"use strict";

exports.DefaultSpacing = void 0;
exports.DefaultSpacing = {
s2: '4px',
s1: '8px',
m: '16px',
l1: '20px',
l2: '32px',
};
//# sourceMappingURL=DefaultSpacing.js.map
/***/ }),
/***/ 60896:
"use strict";

exports.DefaultSpacing = void 0;
var DefaultSpacing_1 = __webpack_require__(62765);
() { return DefaultSpacing_1.DefaultSpacing; } }));
/***/ }),
/***/ 30576:
"use strict";

//# sourceMappingURL=Theme.js.map
/***/ }),
/***/ 28230:
"use strict";
/***/ }),
/***/ 59298:
"use strict";

exports.getSemanticColors = exports.makeSemanticColors = void 0;
/** Generates all the semantic slot colors based on the theme so far
* We'll use these as fallbacks for semantic slots that the passed in theme did not
define.
* The caller must still mix in the customized semantic slots at the end.
*/
function makeSemanticColors(p, e, s, isInverted, depComments) {
var semanticColors = tslib_1.__assign({ primaryButtonBorder: 'transparent',
errorText: !isInverted ? '#a4262c' : '#F1707B', messageText: !isInverted ?
'#323130' : '#F3F2F1', messageLink: !isInverted ? '#005A9E' : '#6CB8F6',
messageLinkHovered: !isInverted ? '#004578' : '#82C7FF', infoIcon: !isInverted ?
'#605e5c' : '#C8C6C4', errorIcon: !isInverted ? '#A80000' : '#F1707B',
blockingIcon: !isInverted ? '#FDE7E9' : '#442726', warningIcon: !isInverted ?
'#797775' : '#C8C6C4', severeWarningIcon: !isInverted ? '#D83B01' : '#FCE100',
successIcon: !isInverted ? '#107C10' : '#92C353', infoBackground: !isInverted ?
'#f3f2f1' : '#323130', errorBackground: !isInverted ? '#FDE7E9' : '#442726',
blockingBackground: !isInverted ? '#FDE7E9' : '#442726', warningBackground: !
isInverted ? '#FFF4CE' : '#433519', severeWarningBackground: !isInverted ?
'#FED9CC' : '#4F2A0F', successBackground: !isInverted ? '#DFF6DD' : '#393D1B',
// deprecated
warningHighlight: !isInverted ? '#ffb900' : '#fff100', successText: !
isInverted ? '#107C10' : '#92c353' }, s);
var fullSemanticColors = getSemanticColors(p, e, semanticColors, isInverted);
return _fixDeprecatedSlots(fullSemanticColors, depComments);
}
exports.makeSemanticColors = makeSemanticColors;
/**
* Map partial platte and effects to partial semantic colors.
*/
function getSemanticColors(p, e, s, isInverted, depComments) {
var result = {};
// map palette
var _a = p || {}, white = _a.white, black = _a.black, themePrimary =
_a.themePrimary, themeDark = _a.themeDark, themeDarker = _a.themeDarker,
themeDarkAlt = _a.themeDarkAlt, themeLighter = _a.themeLighter, neutralLight =
_a.neutralLight, neutralLighter = _a.neutralLighter, neutralDark = _a.neutralDark,
neutralQuaternary = _a.neutralQuaternary, neutralQuaternaryAlt =
_a.neutralQuaternaryAlt, neutralPrimary = _a.neutralPrimary, neutralSecondary =
_a.neutralSecondary, neutralSecondaryAlt = _a.neutralSecondaryAlt, neutralTertiary
= _a.neutralTertiary, neutralTertiaryAlt = _a.neutralTertiaryAlt, neutralLighterAlt
= _a.neutralLighterAlt, accent = _a.accent;
if (white) {
result.bodyBackground = white;
result.bodyFrameBackground = white;
result.accentButtonText = white;
result.buttonBackground = white;
result.primaryButtonText = white;
result.primaryButtonTextHovered = white;
result.primaryButtonTextPressed = white;
result.inputBackground = white;
result.inputForegroundChecked = white;
result.listBackground = white;
result.menuBackground = white;
result.cardStandoutBackground = white;
}
if (black) {
result.bodyTextChecked = black;
result.buttonTextCheckedHovered = black;
}
if (themePrimary) {
result.link = themePrimary;
result.primaryButtonBackground = themePrimary;
result.inputBackgroundChecked = themePrimary;
result.inputIcon = themePrimary;
result.inputFocusBorderAlt = themePrimary;
result.menuIcon = themePrimary;
result.menuHeader = themePrimary;
result.accentButtonBackground = themePrimary;
}
if (themeDark) {
result.primaryButtonBackgroundPressed = themeDark;
result.inputBackgroundCheckedHovered = themeDark;
result.inputIconHovered = themeDark;
}
if (themeDarker) {
result.linkHovered = themeDarker;
}
if (themeDarkAlt) {
result.primaryButtonBackgroundHovered = themeDarkAlt;
}
if (themeLighter) {
result.inputPlaceholderBackgroundChecked = themeLighter;
}
if (neutralLight) {
result.bodyBackgroundChecked = neutralLight;
result.bodyFrameDivider = neutralLight;
result.bodyDivider = neutralLight;
result.variantBorder = neutralLight;
result.buttonBackgroundCheckedHovered = neutralLight;
result.buttonBackgroundPressed = neutralLight;
result.listItemBackgroundChecked = neutralLight;
result.listHeaderBackgroundPressed = neutralLight;
result.menuItemBackgroundPressed = neutralLight;
result.menuItemBackgroundChecked = neutralLight;
}
if (neutralLighter) {
result.bodyBackgroundHovered = neutralLighter;
result.buttonBackgroundHovered = neutralLighter;
result.buttonBackgroundDisabled = neutralLighter;
result.buttonBorderDisabled = neutralLighter;
result.primaryButtonBackgroundDisabled = neutralLighter;
result.disabledBackground = neutralLighter;
result.listItemBackgroundHovered = neutralLighter;
result.listHeaderBackgroundHovered = neutralLighter;
result.menuItemBackgroundHovered = neutralLighter;
}
if (neutralQuaternary) {
result.primaryButtonTextDisabled = neutralQuaternary;
result.disabledSubtext = neutralQuaternary;
}
if (neutralQuaternaryAlt) {
result.listItemBackgroundCheckedHovered = neutralQuaternaryAlt;
}
if (neutralTertiary) {
result.disabledBodyText = neutralTertiary;
result.variantBorderHovered = (s === null || s === void 0 ? void 0 :
s.variantBorderHovered) || neutralTertiary;
result.buttonTextDisabled = neutralTertiary;
result.inputIconDisabled = neutralTertiary;
result.disabledText = neutralTertiary;
}
if (neutralPrimary) {
result.bodyText = neutralPrimary;
result.actionLink = neutralPrimary;
result.buttonText = neutralPrimary;
result.inputBorderHovered = neutralPrimary;
result.inputText = neutralPrimary;
result.listText = neutralPrimary;
result.menuItemText = neutralPrimary;
}
if (neutralLighterAlt) {
result.bodyStandoutBackground = neutralLighterAlt;
result.defaultStateBackground = neutralLighterAlt;
}
if (neutralDark) {
result.actionLinkHovered = neutralDark;
result.buttonTextHovered = neutralDark;
result.buttonTextChecked = neutralDark;
result.buttonTextPressed = neutralDark;
result.inputTextHovered = neutralDark;
result.menuItemTextHovered = neutralDark;
}
if (neutralSecondary) {
result.bodySubtext = neutralSecondary;
result.focusBorder = neutralSecondary;
result.inputBorder = neutralSecondary;
result.smallInputBorder = neutralSecondary;
result.inputPlaceholderText = neutralSecondary;
}
if (neutralSecondaryAlt) {
result.buttonBorder = neutralSecondaryAlt;
}
if (neutralTertiaryAlt) {
result.disabledBodySubtext = neutralTertiaryAlt;
result.disabledBorder = neutralTertiaryAlt;
result.buttonBackgroundChecked = neutralTertiaryAlt;
result.menuDivider = neutralTertiaryAlt;
}
if (accent) {
result.accentButtonBackground = accent;
}
// map effects
if (e === null || e === void 0 ? void 0 : e.elevation4) {
result.cardShadow = e.elevation4;
}
if (!isInverted && (e === null || e === void 0 ? void 0 : e.elevation8)) {
result.cardShadowHovered = e.elevation8;
}
else if (result.variantBorderHovered) {
result.cardShadowHovered = '0 0 1px ' + result.variantBorderHovered;
}
result = tslib_1.__assign(tslib_1.__assign({}, result), s);
return result;
}
exports.getSemanticColors = getSemanticColors;
function _fixDeprecatedSlots(s, depComments) {
// Add @deprecated tag as comment if enabled
var dep = '';
if (depComments === true) {
dep = ' /* @deprecated */';
}
s.listTextColor = s.listText + dep;
s.menuItemBackgroundChecked += dep;
s.warningHighlight += dep;
s.warningText = s.messageText + dep;
s.successText += dep;
return s;
}
//# sourceMappingURL=makeSemanticColors.js.map
/***/ }),
/***/ 48760:
"use strict";

set_version_1.setVersion('@fluentui/theme', '2.6.6');
/***/ }),
/***/ 16755:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}
defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 13482:
"use strict";

exports.Async = void 0;
var getWindow_1 = __webpack_require__(17746);
/**
* Bugs often appear in async code when stuff gets disposed, but async operations
don't get canceled.
* This Async helper class solves these issues by tying async code to the lifetime
of a disposable object.
*
* Usage: Anything class extending from BaseModel can access this helper via
this.async. Otherwise create a
* new instance of the class and remember to call dispose() during your code's
dispose handler.
*
* @public
*/
var Async = /** @class */ (function () {
function Async(parent, onError) {
this._timeoutIds = null;
this._immediateIds = null;
this._intervalIds = null;
this._animationFrameIds = null;
this._isDisposed = false;
this._parent = parent || null;
this._onErrorHandler = onError;
this._noop = function () {
/* do nothing */
};
}
/**
* Dispose function, clears all async operations.
*/
Async.prototype.dispose = function () {
var id;
this._isDisposed = true;
this._parent = null;
// Clear timeouts.
if (this._timeoutIds) {
for (id in this._timeoutIds) {
if (this._timeoutIds.hasOwnProperty(id)) {
this.clearTimeout(parseInt(id, 10));
}
}
this._timeoutIds = null;
}
// Clear immediates.
if (this._immediateIds) {
for (id in this._immediateIds) {
if (this._immediateIds.hasOwnProperty(id)) {
this.clearImmediate(parseInt(id, 10));
}
}
this._immediateIds = null;
}
// Clear intervals.
if (this._intervalIds) {
for (id in this._intervalIds) {
if (this._intervalIds.hasOwnProperty(id)) {
this.clearInterval(parseInt(id, 10));
}
}
this._intervalIds = null;
}
// Clear animation frames.
if (this._animationFrameIds) {
for (id in this._animationFrameIds) {
if (this._animationFrameIds.hasOwnProperty(id)) {
this.cancelAnimationFrame(parseInt(id, 10));
}
}
this._animationFrameIds = null;
}
};
/**
* SetTimeout override, which will auto cancel the timeout during dispose.
* @param callback - Callback to execute.
* @param duration - Duration in milliseconds.
* @returns The setTimeout id.
*/
Async.prototype.setTimeout = function (callback, duration) {
var _this = this;
var timeoutId = 0;
if (!this._isDisposed) {
if (!this._timeoutIds) {
this._timeoutIds = {};
}
timeoutId = setTimeout(function () {
// Time to execute the timeout, enqueue it as a foreground task to
be executed.
try {
// Now delete the record and call the callback.
if (_this._timeoutIds) {
delete _this._timeoutIds[timeoutId];
}
callback.apply(_this._parent);
}
catch (e) {
_this._logError(e);
}
}, duration);
this._timeoutIds[timeoutId] = true;
}
return timeoutId;
};
/**
* Clears the timeout.
* @param id - Id to cancel.
*/
Async.prototype.clearTimeout = function (id) {
if (this._timeoutIds && this._timeoutIds[id]) {
clearTimeout(id);
delete this._timeoutIds[id];
}
};
/**
* SetImmediate override, which will auto cancel the immediate during dispose.
* @param targetElement - Optional target element to use for identifying the
correct window.
*/
Async.prototype.setImmediate = function (callback, targetElement) {
var _this = this;
var immediateId = 0;
var win = getWindow_1.getWindow(targetElement);
if (!this._immediateIds) {
this._immediateIds = {};
}
var setImmediateCallback = function () {
// Time to execute the timeout, enqueue it as a foreground task to
be executed.
try {
if (_this._immediateIds) {
delete _this._immediateIds[immediateId];
}
}
catch (e) {
_this._logError(e);
}
};
immediateId = win.setTimeout(setImmediateCallback, 0);
this._immediateIds[immediateId] = true;
}
return immediateId;
};
/**
* Clears the immediate.
* @param targetElement - Optional target element to use for identifying the
correct window.
*/
Async.prototype.clearImmediate = function (id, targetElement) {
if (this._immediateIds && this._immediateIds[id]) {
win.clearTimeout(id);
delete this._immediateIds[id];
}
};
/**
* SetInterval override, which will auto cancel the timeout during dispose.
* @param duration - Duration in milliseconds.
*/
Async.prototype.setInterval = function (callback, duration) {
var _this = this;
var intervalId = 0;
if (!this._intervalIds) {
this._intervalIds = {};
}
intervalId = setInterval(function () {
// Time to execute the interval callback, enqueue it as a
foreground task to be executed.
try {
}
catch (e) {
_this._logError(e);
}
}, duration);
this._intervalIds[intervalId] = true;
}
return intervalId;
};
/**
* Clears the interval.
*/
Async.prototype.clearInterval = function (id) {
if (this._intervalIds && this._intervalIds[id]) {
clearInterval(id);
delete this._intervalIds[id];
}
};
/**
* Creates a function that, when executed, will only call the func function at
most once per
* every wait milliseconds. Provide an options object to indicate that func
should be invoked
* on the leading and/or trailing edge of the wait timeout. Subsequent calls to
the throttled
* function will return the result of the last func call.
*
* Note: If leading and trailing options are true func will be called on the
trailing edge of
* the timeout only if the throttled function is invoked more than once during
the wait timeout.
*
* @param func - The function to throttle.
* @param wait - The number of milliseconds to throttle executions to. Defaults
to 0.
* @param options - The options object.
* @returns The new throttled function.
*/
Async.prototype.throttle = function (func, wait, options) {
var _this = this;
if (this._isDisposed) {
return this._noop;
}
var waitMS = wait || 0;
var leading = true;
var trailing = true;
var lastExecuteTime = 0;
var lastResult;
var lastArgs;
var timeoutId = null;
if (options && typeof options.leading === 'boolean') {
leading = options.leading;
}
if (options && typeof options.trailing === 'boolean') {
trailing = options.trailing;
}
var callback = function (userCall) {
var now = Date.now();
var delta = now - lastExecuteTime;
var waitLength = leading ? waitMS - delta : waitMS;
if (delta >= waitMS && (!userCall || leading)) {
lastExecuteTime = now;
if (timeoutId) {
_this.clearTimeout(timeoutId);
timeoutId = null;
}
lastResult = func.apply(_this._parent, lastArgs);
}
else if (timeoutId === null && trailing) {
timeoutId = _this.setTimeout(callback, waitLength);
}
return lastResult;
};
var resultFunction = (function () {
var args = [];
}
lastArgs = args;
return callback(true);
});
return resultFunction;
};
/**
* Creates a function that will delay the execution of func until after wait
milliseconds have
* elapsed since the last time it was invoked. Provide an options object to
indicate that func
* should be invoked on the leading and/or trailing edge of the wait timeout.
Subsequent calls
* to the debounced function will return the result of the last func call.
*
* Note: If leading and trailing options are true func will be called on the
trailing edge of
* the timeout only if the debounced function is invoked more than once during
the wait
* timeout.
*
* @param func - The function to debounce.
* @param wait - The number of milliseconds to delay.
* @param options - The options object.
* @returns The new debounced function.
*/
Async.prototype.debounce = function (func, wait, options) {
var _this = this;
if (this._isDisposed) {
var noOpFunction = (function () {
/** Do nothing */
});
noOpFunction.cancel = function () {
return;
};
noOpFunction.flush = (function () { return null; });
noOpFunction.pending = function () { return false; };
return noOpFunction;
}
var waitMS = wait || 0;
var leading = false;
var trailing = true;
var maxWait = null;
var lastCallTime = 0;
var lastExecuteTime = Date.now();
var lastResult;
var lastArgs;
var timeoutId = null;
if (options && typeof options.leading === 'boolean') {
leading = options.leading;
}
if (options && typeof options.trailing === 'boolean') {
trailing = options.trailing;
}
if (options && typeof options.maxWait === 'number' && !
isNaN(options.maxWait)) {
maxWait = options.maxWait;
}
var markExecuted = function (time) {
if (timeoutId) {
_this.clearTimeout(timeoutId);
timeoutId = null;
}
lastExecuteTime = time;
};
var invokeFunction = function (time) {
markExecuted(time);
lastResult = func.apply(_this._parent, lastArgs);
};
var callback = function (userCall) {
var now = Date.now();
var executeImmediately = false;
if (userCall) {
if (leading && now - lastCallTime >= waitMS) {
executeImmediately = true;
}
lastCallTime = now;
}
var delta = now - lastCallTime;
var waitLength = waitMS - delta;
var maxWaitDelta = now - lastExecuteTime;
var maxWaitExpired = false;
if (maxWait !== null) {
// maxWait only matters when there is a pending callback
if (maxWaitDelta >= maxWait && timeoutId) {
maxWaitExpired = true;
}
else {
waitLength = Math.min(waitLength, maxWait - maxWaitDelta);
}
}
if (delta >= waitMS || maxWaitExpired || executeImmediately) {
invokeFunction(now);
}
else if ((timeoutId === null || !userCall) && trailing) {
timeoutId = _this.setTimeout(callback, waitLength);
}
return lastResult;
};
var pending = function () {
return !!timeoutId;
};
var cancel = function () {
if (pending()) {
// Mark the debounced function as having executed
markExecuted(Date.now());
}
};
var flush = function () {
if (pending()) {
invokeFunction(Date.now());
}
return lastResult;
};
var resultFunction = (function () {
var args = [];
}
lastArgs = args;
return callback(true);
});
resultFunction.cancel = cancel;
resultFunction.flush = flush;
resultFunction.pending = pending;
return resultFunction;
};
Async.prototype.requestAnimationFrame = function (callback, targetElement) {
var _this = this;
var animationFrameId = 0;
if (!this._animationFrameIds) {
this._animationFrameIds = {};
}
var animationFrameCallback = function () {
try {
if (_this._animationFrameIds) {
delete _this._animationFrameIds[animationFrameId];
}
}
catch (e) {
_this._logError(e);
}
};
animationFrameId = win.requestAnimationFrame
? win.requestAnimationFrame(animationFrameCallback)
: win.setTimeout(animationFrameCallback, 0);
this._animationFrameIds[animationFrameId] = true;
}
return animationFrameId;
};
Async.prototype.cancelAnimationFrame = function (id, targetElement) {
if (this._animationFrameIds && this._animationFrameIds[id]) {
win.cancelAnimationFrame ? win.cancelAnimationFrame(id) :
win.clearTimeout(id);
delete this._animationFrameIds[id];
}
};
Async.prototype._logError = function (e) {
if (this._onErrorHandler) {
this._onErrorHandler(e);
}
};
return Async;
}());
exports.Async = Async;
//# sourceMappingURL=Async.js.map
/***/ }),
/***/ 72418:
"use strict";

exports.AutoScroll = void 0;
var EventGroup_1 = __webpack_require__(69797);
var scroll_1 = __webpack_require__(99264);
var getRect_1 = __webpack_require__(37978);
var SCROLL_ITERATION_DELAY = 16;
var SCROLL_GUTTER = 100;
var MAX_SCROLL_VELOCITY = 15;
/**
* AutoScroll simply hooks up mouse events given a parent element, and scrolls the
container
* up/down depending on how close the mouse is to the top/bottom of the container.
*
* Once you don't want autoscroll any more, just dispose the helper and it will
unhook events.
*
* @public
* {@docCategory AutoScroll}
*/
var AutoScroll = /** @class */ (function () {
function AutoScroll(element) {
this._events = new EventGroup_1.EventGroup(this);
this._scrollableParent = scroll_1.findScrollableParent(element);
this._incrementScroll = this._incrementScroll.bind(this);
this._scrollRect = getRect_1.getRect(this._scrollableParent);
if (this._scrollableParent === window) {
this._scrollableParent = document.body;
}
if (this._scrollableParent) {
this._events.on(window, 'mousemove', this._onMouseMove, true);
this._events.on(window, 'touchmove', this._onTouchMove, true);
}
}
AutoScroll.prototype.dispose = function () {
this._stopScroll();
};
AutoScroll.prototype._onMouseMove = function (ev) {
this._computeScrollVelocity(ev);
};
AutoScroll.prototype._onTouchMove = function (ev) {
if (ev.touches.length > 0) {
this._computeScrollVelocity(ev);
}
};
AutoScroll.prototype._computeScrollVelocity = function (ev) {
if (!this._scrollRect) {
return;
}
var clientX;
var clientY;
if ('clientX' in ev) {
clientX = ev.clientX;
clientY = ev.clientY;
}
else {
clientX = ev.touches[0].clientX;
clientY = ev.touches[0].clientY;
}
var scrollRectTop = this._scrollRect.top;
var scrollRectLeft = this._scrollRect.left;
var scrollClientBottom = scrollRectTop + this._scrollRect.height -
SCROLL_GUTTER;
var scrollClientRight = scrollRectLeft + this._scrollRect.width -
SCROLL_GUTTER;
// variables to use for alternating scroll direction
var scrollRect;
var clientDirection;
var scrollClient;
// if either of these conditions are met we are scrolling vertically else
horizontally
if (clientY < scrollRectTop + SCROLL_GUTTER || clientY >
scrollClientBottom) {
clientDirection = clientY;
scrollRect = scrollRectTop;
scrollClient = scrollClientBottom;
this._isVerticalScroll = true;
}
else {
clientDirection = clientX;
scrollRect = scrollRectLeft;
scrollClient = scrollClientRight;
this._isVerticalScroll = false;
}
// calculate scroll velocity and direction
if (clientDirection < scrollRect + SCROLL_GUTTER) {
this._scrollVelocity = Math.max(-MAX_SCROLL_VELOCITY, -
MAX_SCROLL_VELOCITY * ((SCROLL_GUTTER - (clientDirection - scrollRect)) /
SCROLL_GUTTER));
}
else if (clientDirection > scrollClient) {
this._scrollVelocity = Math.min(MAX_SCROLL_VELOCITY,
MAX_SCROLL_VELOCITY * ((clientDirection - scrollClient) / SCROLL_GUTTER));
}
else {
this._scrollVelocity = 0;
}
if (this._scrollVelocity) {
this._startScroll();
}
else {
this._stopScroll();
}
};
AutoScroll.prototype._startScroll = function () {
if (!this._timeoutId) {
this._incrementScroll();
}
};
AutoScroll.prototype._incrementScroll = function () {
if (this._scrollableParent) {
if (this._isVerticalScroll) {
this._scrollableParent.scrollTop +=
Math.round(this._scrollVelocity);
}
else {
this._scrollableParent.scrollLeft +=
Math.round(this._scrollVelocity);
}
}
this._timeoutId = setTimeout(this._incrementScroll,
SCROLL_ITERATION_DELAY);
};
AutoScroll.prototype._stopScroll = function () {
if (this._timeoutId) {
clearTimeout(this._timeoutId);
delete this._timeoutId;
}
};
return AutoScroll;
}());
exports.AutoScroll = AutoScroll;
//# sourceMappingURL=AutoScroll.js.map
/***/ }),
/***/ 97442:
"use strict";

exports.nullRender = exports.BaseComponent = void 0;
var Async_1 = __webpack_require__(13482);
var warnConditionallyRequiredProps_1 = __webpack_require__(9931);
var warnMutuallyExclusive_1 = __webpack_require__(17269);
var warnDeprecations_1 = __webpack_require__(68100);
/**
* BaseComponent class, which provides basic helpers for all components.
*
* @public
* {@docCategory BaseComponent}
*
* @deprecated Do not use. We are moving away from class component.
*/
var BaseComponent = /** @class */ (function (_super) {
tslib_1.__extends(BaseComponent, _super);
/**
* BaseComponent constructor
* @param props - The props for the component.
* @param context - The context for the component.
*/
function BaseComponent(props, context) {
var _this = _super.call(this, props, context) || this;
_makeAllSafe(_this, BaseComponent.prototype, [
'componentDidMount',
'shouldComponentUpdate',
'getSnapshotBeforeUpdate',
'render',
'componentDidUpdate',
'componentWillUnmount',
]);
return _this;
}
/**
* When the component receives props, make sure the componentRef is updated.
*/
BaseComponent.prototype.componentDidUpdate = function (prevProps, prevState) {
this._updateComponentRef(prevProps, this.props);
};
/**
* When the component has mounted, update the componentRef.
*/
BaseComponent.prototype.componentDidMount = function () {
this._setComponentRef(this.props.componentRef, this);
};
/**
* If we have disposables, dispose them automatically on unmount.
*/
BaseComponent.prototype.componentWillUnmount = function () {
this._setComponentRef(this.props.componentRef, null);
if (this.__disposables) {
for (var i = 0, len = this._disposables.length; i < len; i++) {
var disposable = this.__disposables[i];
if (disposable.dispose) {
disposable.dispose();
}
}
this.__disposables = null;
}
};
Object.defineProperty(BaseComponent.prototype, "className", {
/**
* Gets the object's class name.
*/
get: function () {
if (!this.__className) {
var funcNameRegex = /function (.{1,})\(/;
var results = funcNameRegex.exec(this.constructor.toString());
this.__className = results && results.length > 1 ? results[1] : '';
}
return this.__className;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseComponent.prototype, "_disposables", {
/**
* Allows subclasses to push things to this._disposables to be auto
disposed.
*/
get: function () {
if (!this.__disposables) {
this.__disposables = [];
}
return this.__disposables;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseComponent.prototype, "_async", {
/**
* Gets the async instance associated with the component, created on
demand. The async instance gives
* subclasses a way to execute setTimeout/setInterval async calls safely,
where the callbacks
* will be cleared/ignored automatically after unmounting. The helpers
within the async object also
* preserve the this pointer so that you don't need to "bind" the
callbacks.
*/
get: function () {
if (!this.__async) {
this.__async = new Async_1.Async(this);
this._disposables.push(this.__async);
}
return this.__async;
},
enumerable: false,
configurable: true
});
Object.defineProperty(BaseComponent.prototype, "_events", {
/**
* Gets the event group instance assocaited with the component, created on
demand. The event instance
* provides on/off methods for listening to DOM (or regular javascript
object) events. The event callbacks
* will be automatically disconnected after unmounting. The helpers within
the events object also
* preserve the this reference so that you don't need to "bind" the
callbacks.
*/
get: function () {
if (!this.__events) {
this.__events = new EventGroup_1.EventGroup(this);
this._disposables.push(this.__events);
}
return this.__events;
},
enumerable: false,
configurable: true
});
/**
* Helper to return a memoized ref resolver function.
* @param refName - Name of the member to assign the ref to.
* @returns A function instance keyed from the given refname.
* @deprecated Use `createRef` from React.createRef.
*/
BaseComponent.prototype._resolveRef = function (refName) {
var _this = this;
if (!this.__resolves) {
this.__resolves = {};
}
if (!this.__resolves[refName]) {
this.__resolves[refName] = function (ref) {
return (_this[refName] = ref);
};
}
return this.__resolves[refName];
};
/**
* Updates the componentRef (by calling it with "this" when necessary.)
*/
BaseComponent.prototype._updateComponentRef = function (currentProps, newProps)
{
if (newProps === void 0) { newProps = {}; }
// currentProps *should* always be defined, but verify that just in case a
subclass is manually
// calling a lifecycle method with no parameters (which has happened) or
other odd usage.
if (currentProps && newProps && currentProps.componentRef !==
newProps.componentRef) {
this._setComponentRef(currentProps.componentRef, null);
this._setComponentRef(newProps.componentRef, this);
}
};
/**
* Warns when a deprecated props are being used.
*
* @param deprecationMap - The map of deprecations, where key is the prop name
and the value is
* either null or a replacement prop name.
*/
BaseComponent.prototype._warnDeprecations = function (deprecationMap) {
warnDeprecations_1.warnDeprecations(this.className, this.props,
deprecationMap);
};
/**
* Warns when props which are mutually exclusive with each other are both used.
*
* @param mutuallyExclusiveMap - The map of mutually exclusive props.
*/
BaseComponent.prototype._warnMutuallyExclusive = function
(mutuallyExclusiveMap) {
warnMutuallyExclusive_1.warnMutuallyExclusive(this.className, this.props,
mutuallyExclusiveMap);
};
/**
* Warns when props are required if a condition is met.
*
* @param requiredProps - The name of the props that are required when the
condition is met.
* @param conditionalPropName - The name of the prop that the condition is
based on.
* @param condition - Whether the condition is met.
*/
BaseComponent.prototype._warnConditionallyRequiredProps = function
(requiredProps, conditionalPropName, condition) {
warnConditionallyRequiredProps_1.warnConditionallyRequiredProps(this.className,
this.props, requiredProps, conditionalPropName, condition);
};
BaseComponent.prototype._setComponentRef = function (ref, value) {
if (!this._skipComponentRefResolution && ref) {
ref(value);
}
if (typeof ref === 'object') {
}
}
};
return BaseComponent;
exports.BaseComponent = BaseComponent;
/**
* Helper to override a given method with a wrapper method that can try/catch the
original, but also
* ensures that the BaseComponent's methods are called before the subclass's. This
ensures that
* componentWillUnmount in the base is called and that things in the _disposables
array are disposed.
*/
function _makeAllSafe(obj, prototype, methodNames) {
for (var i = 0, len = methodNames.length; i < len; i++) {
_makeSafe(obj, prototype, methodNames[i]);
}
}
function _makeSafe(obj, prototype, methodName) {
/* eslint-disable @typescript-eslint/no-explicit-any */
var classMethod = obj[methodName];
var prototypeMethod = prototype[methodName];
if (classMethod || prototypeMethod) {
obj[methodName] = function () {
var args = [];
}
/* eslint-enable @typescript-eslint/no-explicit-any */
var retVal;
if (prototypeMethod) {
retVal = prototypeMethod.apply(this, args);
}
if (classMethod !== prototypeMethod) {
retVal = classMethod.apply(this, args);
}
return retVal;
};
}
}
/**
* Simple constant function for returning null, used to render empty templates in
JSX.
*
* @public
*/
function nullRender() {
return null;
}
exports.nullRender = nullRender;
//# sourceMappingURL=BaseComponent.js.map
/***/ }),
/***/ 87065:
"use strict";

exports.DelayedRender = void 0;
/**
* Utility component for delaying the render of a child component after a given
delay. This component
* requires a single child component; don't pass in many components. Wrap multiple
components in a DIV
* if necessary.
*
* @public
* {@docCategory DelayedRender}
*/
var DelayedRender = /** @class */ (function (_super) {
tslib_1.__extends(DelayedRender, _super);
function DelayedRender(props) {
_this.state = {
isRendered: getWindow_1.getWindow() === undefined,
};
return _this;
}
DelayedRender.prototype.componentDidMount = function () {
var _this = this;
var delay = this.props.delay;
this._timeoutId = window.setTimeout(function () {
_this.setState({
isRendered: true,
});
}, delay);
};
DelayedRender.prototype.componentWillUnmount = function () {
if (this._timeoutId) {
clearTimeout(this._timeoutId);
}
};
DelayedRender.prototype.render = function () {
return this.state.isRendered ? React.Children.only(this.props.children) :
null;
};
DelayedRender.defaultProps = {
delay: 0,
};
return DelayedRender;
exports.DelayedRender = DelayedRender;
//# sourceMappingURL=DelayedRender.js.map
/***/ }),
/***/ 69797:
"use strict";

exports.EventGroup = void 0;
var object_1 = __webpack_require__(28164);
/** An instance of EventGroup allows anything with a handle to it to trigger events
on it.
* If the target is an HTMLElement, the event will be attached to the element and
can be
* triggered as usual (like clicking for onClick).
* The event can be triggered by calling EventGroup.raise() here. If the target is
an
* HTMLElement, the event gets raised and is handled by the browser. Otherwise, it
gets
* handled here in EventGroup, and the handler is called in the context of the
parent
* (which is passed in in the constructor).
*
* @public
* {@docCategory EventGroup}
*/
var EventGroup = /** @class */ (function () {
/** parent: the context in which events attached to non-HTMLElements are called
*/
function EventGroup(parent) {
this._id = EventGroup._uniqueId++;
this._parent = parent;
this._eventRecords = [];
}
/** For IE8, bubbleEvent is ignored here and must be dealt with by the handler.
* Events raised here by default have bubbling set to false and cancelable set
to true.
* This applies also to built-in events being raised manually here on
HTMLElements,
* which may lead to unexpected behavior if it differs from the defaults.
*
*/
EventGroup.raise = function (target, eventName, eventArgs, bubbleEvent) {
var retVal;
if (EventGroup._isElement(target)) {
if (typeof document !== 'undefined' && document.createEvent) {
var ev = document.createEvent('HTMLEvents');
ev.initEvent(eventName, bubbleEvent || false, true);
object_1.assign(ev, eventArgs);
retVal = target.dispatchEvent(ev);
}
else if (typeof document !== 'undefined' && document.createEventObject)
{
// IE8
var evObj = document.createEventObject(eventArgs);
// cannot set cancelBubble on evObj, fireEvent will overwrite it
target.fireEvent('on' + eventName, evObj);
}
}
else {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore -- FIXME: strictBindCallApply error -
while (target && retVal !== false) {
var events = target.__events__;
var eventRecords = events ? events[eventName] : null;
if (eventRecords) {
for (var id in eventRecords) {
if (eventRecords.hasOwnProperty(id)) {
var eventRecordList = eventRecords[id];
// eslint-disable-next-line @typescript-eslint/ban-ts-
comment
for (var listIndex = 0; retVal !== false && listIndex <
eventRecordList.length; listIndex++) {
var record = eventRecordList[listIndex];
if (record.objectCallback) {
retVal =
record.objectCallback.call(record.parent, eventArgs);
}
}
}
}
}
// If the target has a parent, bubble the event up.
target = bubbleEvent ? target.parent : null;
}
}
return retVal;
};
EventGroup.isObserved = function (target, eventName) {
var events = target && target.__events__;
return !!events && !!events[eventName];
};
/** Check to see if the target has declared support of the given event. */
EventGroup.isDeclared = function (target, eventName) {
var declaredEvents = target && target.__declaredEvents;
return !!declaredEvents && !!declaredEvents[eventName];
};
EventGroup.stopPropagation = function (event) {
if (event.stopPropagation) {
}
else {
// IE8
event.cancelBubble = true;
}
};
EventGroup._isElement = function (target) {
return (!!target && (!!target.addEventListener || (typeof HTMLElement !==
'undefined' && target instanceof HTMLElement)));
};
EventGroup.prototype.dispose = function () {
this._isDisposed = true;
this.off();
this._parent = null;
}
};
/** On the target, attach a set of events, where the events object is a name to
function mapping. */
EventGroup.prototype.onAll = function (target, events, useCapture) {
for (var eventName in events) {
if (events.hasOwnProperty(eventName)) {
this.on(target, eventName, events[eventName], useCapture);
}
}
};
/**
* On the target, attach an event whose handler will be called in the context
of the parent
* of this instance of EventGroup.
*/
EventGroup.prototype.on = function (target, eventName, callback, options) {
var _this = this;
if (eventName.indexOf(',') > -1) {
var events = eventName.split(/[ ,]+/);
for (var i = 0; i < events.length; i++) {
this.on(target, events[i], callback, options);
}
}
else {
var parent_1 = this._parent;
var eventRecord = {
target: target,
eventName: eventName,
parent: parent_1,
callback: callback,
options: options,
};
// Initialize and wire up the record on the target, so that it can call
the callback if the event fires.
var events = (target.__events__ = target.__events__ || {});
events[eventName] =
events[eventName] ||
{
count: 0,
};
events[eventName][this._id] = events[eventName][this._id] || [];
events[eventName][this._id].push(eventRecord);
events[eventName].count++;
if (EventGroup._isElement(target)) {
var processElementEvent = function () {
var args = [];
}
if (_this._isDisposed) {
return;
}
var result;
try {
result = callback.apply(parent_1, args);
// eslint-disable-next-line @typescript-eslint/ban-ts-
comment
if (result === false && args[0]) {
var e = args[0];
if (e.preventDefault) {
e.preventDefault();
}
if (e.stopPropagation) {
e.stopPropagation();
}
e.cancelBubble = true;
}
}
catch (e) {
// ignore
}
return result;
};
eventRecord.elementCallback = processElementEvent;
if (target.addEventListener) {
target.addEventListener(eventName, processElementEvent,
options);
}
else if (target.attachEvent) {
// IE8
target.attachEvent('on' + eventName, processElementEvent);
}
}
else {
var processObjectEvent = function () {
var args = [];
}
if (_this._isDisposed) {
return;
}
return callback.apply(parent_1, args);
};
eventRecord.objectCallback = processObjectEvent;
}
// Remember the record locally, so that it can be removed.
this._eventRecords.push(eventRecord);
}
};
EventGroup.prototype.off = function (target, eventName, callback, options) {
for (var i = 0; i < this._eventRecords.length; i++) {
var eventRecord = this._eventRecords[i];
if ((!target || target === eventRecord.target) &&
(!eventName || eventName === eventRecord.eventName) &&
(!callback || callback === eventRecord.callback) &&
(typeof options !== 'boolean' || options === eventRecord.options))
{
var events = eventRecord.target.__events__;
var targetArrayLookup = events[eventRecord.eventName];
var targetArray = targetArrayLookup ? targetArrayLookup[this._id] :
null;
// We may have already target's entries, so check for null.
if (targetArray) {
if (targetArray.length === 1 || !callback) {
targetArrayLookup.count -= targetArray.length;
delete events[eventRecord.eventName][this._id];
}
else {
targetArrayLookup.count--;
targetArray.splice(targetArray.indexOf(eventRecord), 1);
}
if (!targetArrayLookup.count) {
delete events[eventRecord.eventName];
}
}
if (eventRecord.elementCallback) {
if (eventRecord.target.removeEventListener) {
eventRecord.target.removeEventListener(eventRecord.eventName,
eventRecord.elementCallback, eventRecord.options);
}
else if (eventRecord.target.detachEvent) {
// IE8
eventRecord.target.detachEvent('on' +
eventRecord.eventName, eventRecord.elementCallback);
}
}
this._eventRecords.splice(i--, 1);
}
}
};
/** Trigger the given event in the context of this instance of EventGroup. */
EventGroup.prototype.raise = function (eventName, eventArgs, bubbleEvent) {
return EventGroup.raise(this._parent, eventName, eventArgs, bubbleEvent);
};
/** Declare an event as being supported by this instance of EventGroup. */
EventGroup.prototype.declare = function (event) {
var declaredEvents = (this._parent.__declaredEvents =
this._parent.__declaredEvents || {});
if (typeof event === 'string') {
declaredEvents[event] = true;
}
else {
for (var i = 0; i < event.length; i++) {
declaredEvents[event[i]] = true;
}
}
};
EventGroup._uniqueId = 0;
return EventGroup;
}());
exports.EventGroup = EventGroup;
//# sourceMappingURL=EventGroup.js.map
/***/ }),
/***/ 70141:
"use strict";

exports.FabricPerformance = void 0;
var now = function () {
return typeof performance !== 'undefined' && !!performance.now ?
performance.now() : Date.now();
};
var RESET_INTERVAL = 3 * 60 * 1000; // auto reset every 3 minutes
/**
* Performance helper class for measuring things.
*
* @public
* {@docCategory FabricPerformance}
*/
var FabricPerformance = /** @class */ (function () {
function FabricPerformance() {
}
/**
* Measures execution time of the given syncronous function. If the same logic
is executed multiple times,
* each individual measurement will be collected as well the overall numbers.
* @param name - The name of this measurement
* @param func - The logic to be measured for execution time
*/
FabricPerformance.measure = function (name, func) {
if (FabricPerformance._timeoutId) {
FabricPerformance.setPeriodicReset();
}
var start = now();
func();
var end = now();
var measurement = FabricPerformance.summary[name] || {
totalDuration: 0,
count: 0,
all: [],
};
var duration = end - start;
measurement.totalDuration += duration;
measurement.count++;
measurement.all.push({
duration: duration,
timeStamp: end,
});
FabricPerformance.summary[name] = measurement;
};
FabricPerformance.reset = function () {
FabricPerformance.summary = {};
clearTimeout(FabricPerformance._timeoutId);
FabricPerformance._timeoutId = NaN;
};
FabricPerformance.setPeriodicReset = function () {
FabricPerformance._timeoutId = setTimeout(function () { return
FabricPerformance.reset(); }, RESET_INTERVAL);
};
FabricPerformance.summary = {};
return FabricPerformance;
}());
exports.FabricPerformance = FabricPerformance;
//# sourceMappingURL=FabricPerformance.js.map
/***/ }),
/***/ 84526:
"use strict";

exports.GlobalSettings = void 0;
/**
* Storing global state in local module variables has issues when more than one
copy
* if the module gets loaded on the page (due to a bundling error or simply by
consuming
* a prebundled script.)
*
* This file contains helpers to deal with the getting and setting local state, and
allows
* callers to get called back when it mutates.
*/
var GLOBAL_SETTINGS_PROP_NAME = '__globalSettings__';
var CALLBACK_STATE_PROP_NAME = '__callbacks__';
var _counter = 0;
/**
* Global settings helper, which stores settings in the global (window) namespace.
* If window is not provided, it will store settings in module scope. Provides a
* way to observe changes as well when their values change.
*
* @public
* {@docCategory GlobalSettings}
*/
var GlobalSettings = /** @class */ (function () {
function GlobalSettings() {
}
GlobalSettings.getValue = function (key, defaultValue) {
var globalSettings = _getGlobalSettings();
if (globalSettings[key] === undefined) {
globalSettings[key] = typeof defaultValue === 'function' ?
defaultValue() : defaultValue;
}
return globalSettings[key];
};
GlobalSettings.setValue = function (key, value) {
var callbacks = globalSettings[CALLBACK_STATE_PROP_NAME];
var oldValue = globalSettings[key];
if (value !== oldValue) {
globalSettings[key] = value;
var changeDescription = {
oldValue: oldValue,
value: value,
key: key,
};
for (var id in callbacks) {
if (callbacks.hasOwnProperty(id)) {
callbacks[id](changeDescription);
}
}
}
return value;
};
GlobalSettings.addChangeListener = function (cb) {
// Note: we use generated ids on the callbacks to create a map of the
callbacks, which optimizes removal.
// (It's faster to delete a key than it is to look up the index of an
object and splice an array.)
var id = cb.__id__;
var callbacks = _getCallbacks();
if (!id) {
id = cb.__id__ = String(_counter++);
}
callbacks[id] = cb;
};
GlobalSettings.removeChangeListener = function (cb) {
var callbacks = _getCallbacks();
delete callbacks[cb.__id__];
};
return GlobalSettings;
}());
exports.GlobalSettings = GlobalSettings;
function _getGlobalSettings() {
var _a;
var win = getWindow_1.getWindow();
var globalObj = win || {};
if (!globalObj[GLOBAL_SETTINGS_PROP_NAME]) {
globalObj[GLOBAL_SETTINGS_PROP_NAME] = (_a = {},
_a[CALLBACK_STATE_PROP_NAME] = {},
_a);
}
return globalObj[GLOBAL_SETTINGS_PROP_NAME];
}
function _getCallbacks() {
return globalSettings[CALLBACK_STATE_PROP_NAME];
}
//# sourceMappingURL=GlobalSettings.js.map
/***/ }),
/***/ 31555:
"use strict";

exports.KeyCodes = void 0;
/**
* Simulated enum for keycodes. These will get inlined by uglify when used much
like an enum
*
* @public
* {@docCategory KeyCodes}
*/
exports.KeyCodes = {
backspace: 8,
tab: 9,
enter: 13,
shift: 16,
ctrl: 17,
alt: 18,
pauseBreak: 19,
capslock: 20,
escape: 27,
space: 32,
pageUp: 33,
pageDown: 34,
end: 35,
home: 36,
left: 37,
up: 38,
right: 39,
down: 40,
insert: 45,
del: 46,
zero: 48,
one: 49,
two: 50,
three: 51,
four: 52,
five: 53,
six: 54,
seven: 55,
eight: 56,
nine: 57,
colon: 58,
a: 65,
b: 66,
c: 67,
d: 68,
e: 69,
f: 70,
g: 71,
h: 72,
i: 73,
j: 74,
k: 75,
l: 76,
m: 77,
n: 78,
o: 79,
p: 80,
q: 81,
r: 82,
s: 83,
t: 84,
u: 85,
v: 86,
w: 87,
x: 88,
y: 89,
z: 90,
leftWindow: 91,
rightWindow: 92,
select: 93,
/* eslint-disable @typescript-eslint/naming-convention */
zero_numpad: 96,
one_numpad: 97,
two_numpad: 98,
three_numpad: 99,
four_numpad: 100,
five_numpad: 101,
six_numpad: 102,
seven_numpad: 103,
eight_numpad: 104,
nine_numpad: 105,
/* eslint-enable @typescript-eslint/naming-convention */
multiply: 106,
add: 107,
subtract: 109,
decimalPoint: 110,
divide: 111,
f1: 112,
f2: 113,
f3: 114,
f4: 115,
f5: 116,
f6: 117,
f7: 118,
f8: 119,
f9: 120,
f10: 121,
f11: 122,
f12: 123,
numlock: 144,
scrollLock: 145,
semicolon: 186,
equalSign: 187,
comma: 188,
dash: 189,
period: 190,
forwardSlash: 191,
graveAccent: 192,
openBracket: 219,
backSlash: 220,
closeBracket: 221,
singleQuote: 222,
};
//# sourceMappingURL=KeyCodes.js.map
/***/ }),
/***/ 28602:
"use strict";
exports.Rectangle = void 0;
/**
* Rectangle helper class.
*
* @public
* {@docCategory Rectangle}
*/
var Rectangle = /** @class */ (function () {
function Rectangle(left, right, top, bottom) {
if (left === void 0) { left = 0; }
if (right === void 0) { right = 0; }
if (top === void 0) { top = 0; }
if (bottom === void 0) { bottom = 0; }
this.top = top;
this.bottom = bottom;
this.left = left;
this.right = right;
}
Object.defineProperty(Rectangle.prototype, "width", {
/**
* Calculated automatically by subtracting the right from left
*/
get: function () {
return this.right - this.left;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "height", {
/**
* Calculated automatically by subtracting the bottom from top.
*/
get: function () {
return this.bottom - this.top;
},
enumerable: false,
configurable: true
});
/**
* Tests if another rect is approximately equal to this rect (within 4 decimal
places.)
*/
Rectangle.prototype.equals = function (rect) {
// Fixing to 4 decimal places because it allows enough precision and will
handle cases when something
// should be rounded, like .999999 should round to 1.
return (parseFloat(this.top.toFixed(4)) === parseFloat(rect.top.toFixed(4))
&&
parseFloat(this.bottom.toFixed(4)) ===
parseFloat(rect.bottom.toFixed(4)) &&
parseFloat(this.left.toFixed(4)) === parseFloat(rect.left.toFixed(4))
&&
parseFloat(this.right.toFixed(4)) ===
parseFloat(rect.right.toFixed(4)));
};
return Rectangle;
}());
exports.Rectangle = Rectangle;
//# sourceMappingURL=Rectangle.js.map
/***/ }),
/***/ 36689:
"use strict";
exports.appendFunction = void 0;
/**
* Returns a single function which will call each of the given functions in the
context of the
* parent.
*/
function appendFunction(parent) {
var functions = [];
functions[_i - 1] = arguments[_i];
}
if (functions.length < 2) {
return functions[0];
}
var args = [];
}
functions.forEach(function (f) { return f && f.apply(parent, args); });
};
}
exports.appendFunction = appendFunction;
//# sourceMappingURL=appendFunction.js.map
/***/ }),
/***/ 36813:
"use strict";

exports.mergeAriaAttributeValues = void 0;
/**
* ARIA helper to concatenate attributes, returning undefined if all attributes
* are undefined. (Empty strings are not a valid ARIA attribute value.)
*
* @param ariaAttributes - ARIA attributes to merge
*/
function mergeAriaAttributeValues() {
var ariaAttributes = [];
ariaAttributes[_i] = arguments[_i];
}
var mergedAttribute = ariaAttributes
.filter(function (arg) { return arg; })
.join(' ')
.trim();
return mergedAttribute === '' ? undefined : mergedAttribute;
}
exports.mergeAriaAttributeValues = mergeAriaAttributeValues;
//# sourceMappingURL=aria.js.map
/***/ }),
/***/ 48843:
"use strict";

exports.arraysEqual = exports.flatten = exports.addElementAtIndex =
exports.replaceElement = exports.removeIndex = exports.toMatrix =
exports.createArray = exports.find = exports.findIndex = void 0;
/**
* Helper to find the index of an item within an array, using a callback to
* determine the match.
*
* @public
* @param array - Array to search.
* @param cb - Callback which returns true on matches.
* @param fromIndex - Optional index to start from (defaults to 0)
*/
function findIndex(array, cb, fromIndex) {
if (fromIndex === void 0) { fromIndex = 0; }
var index = -1;
for (var i = fromIndex; array && i < array.length; i++) {
if (cb(array[i], i)) {
index = i;
break;
}
}
return index;
}
exports.findIndex = findIndex;
/**
* Helper to find the first item within an array that satisfies the callback.
* @param array - Array to search
* @param cb - Callback which returns true on matches
*/
function find(array, cb) {
var index = findIndex(array, cb);
if (index < 0) {
return undefined;
}
return array[index];
}
exports.find = find;
/**
* Creates an array of a given size and helper method to populate.
*
* @public
* @param size - Size of array.
* @param getItem - Callback to populate given cell index.
*/
function createArray(size, getItem) {
var array = [];
for (var i = 0; i < size; i++) {
array.push(getItem(i));
}
return array;
}
exports.createArray = createArray;
/**
* Convert the given array to a matrix with columnCount number
* of columns.
*
* @public
* @param items - The array to convert
* @param columnCount - The number of columns for the resulting matrix
* @returns A matrix of items
*/
function toMatrix(items, columnCount) {
return items.reduce(function (rows, currentValue, index) {
if (index % columnCount === 0) {
rows.push([currentValue]);
}
else {
rows[rows.length - 1].push(currentValue);
}
return rows;
}, []);
}
exports.toMatrix = toMatrix;
/**
* Given an array, it returns a new array that does not contain the item at the
given index.
* @param array - The array to operate on
* @param index - The index of the element to remove
*/
function removeIndex(array, index) {
return array.filter(function (_, i) { return index !== i; });
}
exports.removeIndex = removeIndex;
/**
* Given an array, this function returns a new array where the element at a given
index has been replaced.
* @param newElement - The element that will be placed in the new array
* @param index - The index of the element that should be replaced
*/
function replaceElement(array, newElement, index) {
var copy = array.slice();
copy[index] = newElement;
return copy;
}
exports.replaceElement = replaceElement;
/**
* Given an array, this function returns a new array where an element has been
inserted at the given index.
* @param index - The index where an element should be inserted
* @param itemToAdd - The element to insert
*/
function addElementAtIndex(array, index, itemToAdd) {
var copy = array.slice();
copy.splice(index, 0, itemToAdd);
return copy;
}
exports.addElementAtIndex = addElementAtIndex;
/**
* Given an array where each element is of type T or T[], flatten it into an array
of T
* @param array - The array where each element can optionally also be an array
*/
function flatten(array) {
var result = [];
array.forEach(function (item) { return (result = result.concat(item)); });
return result;
}
exports.flatten = flatten;
/**
* Returns a boolean indicating if the two given arrays are equal in length and
values.
*
* @param array1 - First array to compare
* @param array2 - Second array to compare
* @returns True if the arrays are the same length and have the same values in the
same positions, false otherwise.
*/
function arraysEqual(array1, array2) {
if (array1.length !== array2.length) {
return false;
}
for (var i = 0; i < array1.length; i++) {
if (array1[i] !== array2[i]) {
return false;
}
}
return true;
}
exports.arraysEqual = arraysEqual;
//# sourceMappingURL=array.js.map
/***/ }),
/***/ 53944:
"use strict";
/**
* asAsync - a HOC for async loading components.
*
* Usage:
*
* const AsyncDialog = asAsync({
* load: () => import('Dialog').then(result => result.default),
* });
*
* React.render(domElement, <AsyncDialog asyncPlaceholder={ () => <Spinner/> }
{ ...dialogProps } />);
*
* Note the àsyncPlaceholder` prop will be respected when rendering the async
component and it hasn't
* been loaded yet.
*/
exports.asAsync = void 0;
/**
* If possible, use a WeakMap to maintain a cache of loaded components.
* This can be used to synchronously render components that have already been
loaded,
* rather than having to wait for at least one async tick.
*/
var _syncModuleCache = typeof WeakMap !== 'undefined'
? // eslint-disable-next-line @typescript-eslint/no-explicit-any
new WeakMap()
: undefined;
/**
* Produces a component which internally loads the target component before first
mount.
* The component passes all props through to the loaded component.
*
* This overload accepts a module with a default export for the component.
*/
function asAsync(options) {
var Async = /** @class */ (function (_super) {
tslib_1.__extends(Async, _super);
function Async() {
_this.state = {
Component: _syncModuleCache ? _syncModuleCache.get(options.load) :
undefined,
};
return _this;
}
Async.prototype.render = function () {
// Typescript issue: the rest can't be pulled without the any cast, as
TypeScript fails with rest on generics.
var _a = this.props, forwardedRef = _a.forwardedRef, Placeholder =
_a.asyncPlaceholder, rest = tslib_1.__rest(_a, ["forwardedRef",
"asyncPlaceholder"]);
var Component = this.state.Component;
return Component ? (React.createElement(Component,
tslib_1.__assign(tslib_1.__assign({}, rest), { ref: forwardedRef }))) : Placeholder
? (React.createElement(Placeholder, null)) : null;
};
Async.prototype.componentDidMount = function () {
var _this = this;
var Component = this.state.Component;
if (!Component) {
options
.load()
.then(function (LoadedComponent) {
if (LoadedComponent) {
// Cache component for future reference.
_syncModuleCache && _syncModuleCache.set(options.load,
LoadedComponent);
// Set state.
_this.setState({
Component: LoadedComponent,
}, options.onLoad);
}
})
.catch(options.onError);
}
};
return Async;
return React.forwardRef(function (props, ref) { return
React.createElement(Async, tslib_1.__assign({}, props, { forwardedRef: ref })); });
}
exports.asAsync = asAsync;
//# sourceMappingURL=asAsync.js.map
/***/ }),
/***/ 85463:
"use strict";

exports.assertNever = void 0;
/**
* AssertNever is a utility function that can be used for exhaustiveness checks in
switch statements.
*
* @public
*/
function assertNever(x) {
throw new Error('Unexpected object: ' + x);
}
exports.assertNever = assertNever;
//# sourceMappingURL=assertNever.js.map
/***/ }),
/***/ 248:
"use strict";

exports.classNamesFunction = void 0;
var rtl_1 = __webpack_require__(31820);
var dom_1 = __webpack_require__(81022);
var MAX_CACHE_COUNT = 50;
var DEFAULT_SPECIFICITY_MULTIPLIER = 5;
var _memoizedClassNames = 0;
stylesheet.onReset(function () { return _memoizedClassNames++; });
}
// Note that because of the caching nature within the classNames memoization,
// I've disabled this rule to simply be able to work with any types.
// This represents a prop we attach to each Map to indicate the cached return value
// associated with the graph node.
var retVal = '__retval__';
/**
* Creates a getClassNames function which calls getStyles given the props, and
injects them
* into mergeStyleSets.
*
* Note that the props you pass in on every render should be in the same order and
* immutable (numbers, strings, and booleans). This will allow the results to be
memoized. Violating
* these will cause extra recalcs to occur.
*/
function classNamesFunction(options) {
// We build a trie where each node is a Map. The map entry key represents an
argument
// value, and the entry value is another node (Map). Each node has a
`__retval__`
// property which is used to hold the cached response.
// To derive the response, we can simply ensure the arguments are added or
already
// exist in the trie. At the last node, if there is a `__retval__` we return
that. Otherwise
// we call the `getStyles` api to evaluate, cache on the property, and return
that.
var map = new Map();
var styleCalcCount = 0;
var getClassNamesCount = 0;
var currentMemoizedClassNames = _memoizedClassNames;
var getClassNames = function (styleFunctionOrObject, styleProps) {
var _a;
if (styleProps === void 0) { styleProps = {}; }
// If useStaticStyles is true, styleFunctionOrObject returns slot to
classname mappings.
// If there is also no style overrides, we can skip merge styles completely
and
// simply return the result from the style funcion.
if (options.useStaticStyles &&
typeof styleFunctionOrObject === 'function' &&
styleFunctionOrObject.__noStyleOverride__) {
return styleFunctionOrObject(styleProps);
}
getClassNamesCount++;
var current = map;
var theme = styleProps.theme;
var rtl = theme && theme.rtl !== undefined ? theme.rtl : rtl_1.getRTL();
var disableCaching = options.disableCaching;
// On reset of our stylesheet, reset memoized cache.
if (currentMemoizedClassNames !== _memoizedClassNames) {
currentMemoizedClassNames = _memoizedClassNames;
map = new Map();
styleCalcCount = 0;
}
if (!options.disableCaching) {
current = _traverseMap(map, styleFunctionOrObject);
current = _traverseMap(current, styleProps);
}
if (disableCaching || !current[retVal]) {
if (styleFunctionOrObject === undefined) {
current[retVal] = {};
}
else {
current[retVal] = merge_styles_1.mergeCssSets([
(typeof styleFunctionOrObject === 'function'
? styleFunctionOrObject(styleProps)
: styleFunctionOrObject),
], { rtl: !!rtl, specificityMultiplier: options.useStaticStyles ?
DEFAULT_SPECIFICITY_MULTIPLIER : undefined });
}
if (!disableCaching) {
styleCalcCount++;
}
}
if (styleCalcCount > (options.cacheSize || MAX_CACHE_COUNT)) {
var win = dom_1.getWindow();
if ((_a = win === null || win === void 0 ? void 0 : win.FabricConfig)
=== null || _a === void 0 ? void 0 : _a.enableClassNameCacheFullWarning) {
console.warn("Styles are being recalculated too frequently. Cache
miss rate is " + styleCalcCount + "/" + getClassNamesCount + ".");
console.trace();
}
map.clear();
styleCalcCount = 0;
// Mutate the options passed in, that's all we can do.
options.disableCaching = true;
}
// Note: the retVal is an attached property on the Map; not a key in the
Map. We use this attached property to
// cache the return value for this branch of the graph.
return current[retVal];
};
return getClassNames;
}
exports.classNamesFunction = classNamesFunction;
function _traverseEdge(current, value) {
value = _normalizeValue(value);
if (!current.has(value)) {
current.set(value, new Map());
}
return current.get(value);
}
function _traverseMap(current, inputs) {
if (typeof inputs === 'function') {
var cachedInputsFromStyled = inputs.__cachedInputs__;
if (cachedInputsFromStyled) {
// The styled helper will generate the styles function and will attach
the cached
// inputs (consisting of the default styles, customzied styles, and
user provided styles.)
// These should be used as cache keys for deriving the memoized value.
for (var _i = 0, _a = inputs.__cachedInputs__; _i < _a.length; _i++) {
var input = _a[_i];
current = _traverseEdge(current, input);
}
}
else {
current = _traverseEdge(current, inputs);
}
}
else if (typeof inputs === 'object') {
for (var propName in inputs) {
if (inputs.hasOwnProperty(propName)) {
current = _traverseEdge(current, inputs[propName]);
}
}
}
return current;
}
function _normalizeValue(value) {
switch (value) {
case undefined:
return '__undefined__';
case null:
return '__null__';
default:
return value;
}
}
//# sourceMappingURL=classNamesFunction.js.map
/***/ }),
/***/ 15726:
"use strict";

exports.composeComponentAs = void 0;
var memoize_1 = __webpack_require__(21519);
function createComposedComponent(outer) {
var Outer = outer;
var outerMemoizer = memoize_1.createMemoizer(function (inner) {
if (outer === inner) {
throw new Error('Attempted to compose a component with itself.');
}
var Inner = inner;
var innerMemoizer = memoize_1.createMemoizer(function (defaultRender) {
var InnerWithDefaultRender = function (innerProps) {
return React.createElement(Inner, tslib_1.__assign({}, innerProps,
{ defaultRender: defaultRender }));
};
return InnerWithDefaultRender;
});
var OuterWithDefaultRender = function (outerProps) {
var defaultRender = outerProps.defaultRender;
return React.createElement(Outer, tslib_1.__assign({}, outerProps,
{ defaultRender: defaultRender ? innerMemoizer(defaultRender) : Inner }));
};
return OuterWithDefaultRender;
});
return outerMemoizer;
}
var componentAsMemoizer = memoize_1.createMemoizer(createComposedComponent);
/**
* Composes two components which conform to the ÌComponentAs` specification; that
is, two
* components which accept a `defaultRender` prop, which is a 'default'
implementation of
* a component which accepts the same overall props.
*
* @public
*/
function composeComponentAs(outer, inner) {
return componentAsMemoizer(outer)(inner);
}
exports.composeComponentAs = composeComponentAs;
//# sourceMappingURL=composeComponentAs.js.map
/***/ }),
/***/ 54206:
"use strict";

exports.isControlled = void 0;
/**
* Determines whether a component is controlled.
* @param props - Component props
* @param valueProp - Prop containing the controlled value
* @returns true if controlled, false if uncontrolled
*/
function isControlled(props, valueProp) {
// React's built-in <input> considers a prop to be provided if its value is
non-null/undefined.
// Mirror that behavior here (rather than checking for just undefined).
return props[valueProp] !== undefined && props[valueProp] !== null;
}
exports.isControlled = isControlled;
//# sourceMappingURL=controlled.js.map
/***/ }),
/***/ 36694:
"use strict";

exports.createMergedRef = void 0;
var array_1 = __webpack_require__(48843);
/**
* Set up a ref resolver function given internal state managed for the ref.
* @param local Set
*/
var createResolver = function (local) { return function (newValue) {
for (var _i = 0, _a = local.refs; _i < _a.length; _i++) {
var ref = _a[_i];
ref(newValue);
}
else if (ref) {
// work around the immutability of the React.Ref type
ref.current = newValue;
}
}
}; };
/**
* Helper to merge refs from within class components.
*/
var createMergedRef = function (value) {
var local = {
refs: [],
};
var newRefs = [];
newRefs[_i] = arguments[_i];
}
if (!local.resolver || !array_1.arraysEqual(local.refs, newRefs)) {
local.resolver = createResolver(local);
}
local.refs = newRefs;
return local.resolver;
};
};
exports.createMergedRef = createMergedRef;
//# sourceMappingURL=createMergedRef.js.map
/***/ }),
/***/ 21822:
"use strict";

exports.css = void 0;
/**
* Concatination helper, which can merge class names together. Skips over falsey
values.
*
* @public
*/
function css() {
var args = [];
}
var classes = [];
for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
var arg = args_1[_a];
if (arg) {
classes.push(arg);
}
else if (arg.hasOwnProperty('toString') && typeof arg.toString ===
'function') {
classes.push(arg.toString());
}
else {
for (var key in arg) {
if (arg[key]) {
classes.push(key);
}
}
}
}
}
}
exports.css = css;
//# sourceMappingURL=css.js.map
/***/ }),
/***/ 43846:
"use strict";

exports.Customizations = void 0;
var GlobalSettings_1 = __webpack_require__(84526);
var CustomizationsGlobalKey = 'customizations';
var NO_CUSTOMIZATIONS = { settings: {}, scopedSettings: {}, inCustomizerContext:
false };
var _allSettings =
GlobalSettings_1.GlobalSettings.getValue(CustomizationsGlobalKey, {
settings: {},
scopedSettings: {},
inCustomizerContext: false,
});
var _events = [];
var Customizations = /** @class */ (function () {
function Customizations() {
}
Customizations.reset = function () {
_allSettings.settings = {};
_allSettings.scopedSettings = {};
};
/** Apply global Customization settings.
* @example Customizations.applySettings(\{ theme: \{...\} \});
*/
Customizations.applySettings = function (settings) {
_allSettings.settings = tslib_1.__assign(tslib_1.__assign({},
_allSettings.settings), settings);
Customizations._raiseChange();
};
/** Apply Customizations to a particular named scope, like a component.
* @example Customizations.applyScopedSettings('Nav', \{ styles: () =\> \
{\} \});
*/
Customizations.applyScopedSettings = function (scopeName, settings) {
_allSettings.scopedSettings[scopeName] =
tslib_1.__assign(tslib_1.__assign({}, _allSettings.scopedSettings[scopeName]),
settings);
};
Customizations.getSettings = function (properties, scopeName, localSettings) {
if (localSettings === void 0) { localSettings = NO_CUSTOMIZATIONS; }
var settings = {};
var localScopedSettings = (scopeName &&
localSettings.scopedSettings[scopeName]) || {};
var globalScopedSettings = (scopeName &&
_allSettings.scopedSettings[scopeName]) || {};
for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++)
{
var property = properties_1[_i];
settings[property] =
localScopedSettings[property] ||
localSettings.settings[property] ||
globalScopedSettings[property] ||
_allSettings.settings[property];
}
return settings;
};
/** Used to run some code that sets Customizations without triggering an update
until the end.
* Useful for applying Customizations that don't affect anything currently
rendered, or for
* applying many customizations at once.
* @param suppressUpdate - Do not raise the change event at the end, preventing
all updates
*/
Customizations.applyBatchedUpdates = function (code, suppressUpdate) {
Customizations._suppressUpdates = true;
try {
code();
}
catch (_a) {
/* do nothing */
}
Customizations._suppressUpdates = false;
if (!suppressUpdate) {
}
};
Customizations.observe = function (onChange) {
_events.push(onChange);
};
Customizations.unobserve = function (onChange) {
_events = _events.filter(function (cb) { return cb !== onChange; });
};
Customizations._raiseChange = function () {
if (!Customizations._suppressUpdates) {
_events.forEach(function (cb) { return cb(); });
}
};
return Customizations;
}());
exports.Customizations = Customizations;
//# sourceMappingURL=Customizations.js.map
/***/ }),
/***/ 89433:
"use strict";

exports.Customizer = void 0;
var Customizations_1 = __webpack_require__(43846);
var CustomizerContext_1 = __webpack_require__(83786);
var mergeCustomizations_1 = __webpack_require__(8336);
/**
* The Customizer component allows for default props to be mixed into components
which
* are decorated with the customizable() decorator, or use the styled HOC. This
enables
* injection scenarios like:
*
* 1. render svg icons instead of the icon font within all buttons
* 2. inject a custom theme object into a component
*
* Props are provided via the settings prop which should be one of the following:
* - A json map which contains 1 or more name/value pairs representing injectable
props.
* - A function that receives the current settings and returns the new ones that
apply to the scope
*
* @public
*
* @deprecated This component is deprecated for purpose of applying theme to
components
* as of `@fluentui/react` version 8. Use `ThemeProvider` for applying theme
instead.
*/
var Customizer = /** @class */ (function (_super) {
tslib_1.__extends(Customizer, _super);
function Customizer() {
_this._onCustomizationChange = function () { return _this.forceUpdate(); };
return _this;
}
Customizer.prototype.componentDidMount = function () {
Customizations_1.Customizations.observe(this._onCustomizationChange);
};
Customizer.prototype.componentWillUnmount = function () {
Customizations_1.Customizations.unobserve(this._onCustomizationChange);
};
Customizer.prototype.render = function () {
var _this = this;
var contextTransform = this.props.contextTransform;
return (React.createElement(CustomizerContext_1.CustomizerContext.Consumer,
null, function (parentContext) {
var newContext = mergeCustomizations_1.mergeCustomizations(_this.props,
parentContext);
if (contextTransform) {
newContext = contextTransform(newContext);
}
return
React.createElement(CustomizerContext_1.CustomizerContext.Provider, { value:
newContext }, _this.props.children);
}));
};
return Customizer;
exports.Customizer = Customizer;
//# sourceMappingURL=Customizer.js.map
/***/ }),
/***/ 83786:
"use strict";

exports.CustomizerContext = void 0;
exports.CustomizerContext = React.createContext({
customizations: {
inCustomizerContext: false,
settings: {},
scopedSettings: {},
},
});
//# sourceMappingURL=CustomizerContext.js.map
/***/ }),
/***/ 5954:
"use strict";

exports.customizable = void 0;
var hoistStatics_1 = __webpack_require__(47272);
function customizable(scope, fields, concatStyles) {
return function customizableFactory(ComposedComponent) {
var _a;
var resultClass = (_a = /** @class */ (function (_super) {
tslib_1.__extends(ComponentWithInjectedProps, _super);
function ComponentWithInjectedProps(props) {
_this._styleCache = {};
_this._onSettingChanged = _this._onSettingChanged.bind(_this);
return _this;
}
ComponentWithInjectedProps.prototype.componentDidMount = function
() {
Customizations_1.Customizations.observe(this._onSettingChanged);
};
ComponentWithInjectedProps.prototype.componentWillUnmount =
function () {
Customizations_1.Customizations.unobserve(this._onSettingChanged);
};
ComponentWithInjectedProps.prototype.render = function () {
var _this = this;
return
(React.createElement(CustomizerContext_1.CustomizerContext.Consumer, null, function
(context) {
var defaultProps =
Customizations_1.Customizations.getSettings(fields, scope, context.customizations);
// eslint-disable-next-line @typescript-eslint/no-explicit-
any
var componentProps = _this.props;
// If defaultProps.styles is a function, evaluate it before
calling concatStyleSets
if (defaultProps.styles && typeof defaultProps.styles ===
'function') {
defaultProps.styles =
defaultProps.styles(tslib_1.__assign(tslib_1.__assign({}, defaultProps),
componentProps));
}
// If concatStyles is true and custom styles have been
defined compute those styles
if (concatStyles && defaultProps.styles) {
if (_this._styleCache.default !== defaultProps.styles
||
_this._styleCache.component !==
componentProps.styles) {
var mergedStyles =
merge_styles_1.concatStyleSets(defaultProps.styles, componentProps.styles);
_this._styleCache.default = defaultProps.styles;
_this._styleCache.component =
componentProps.styles;
_this._styleCache.merged = mergedStyles;
}
return React.createElement(ComposedComponent,
tslib_1.__assign({}, defaultProps, componentProps, { styles:
_this._styleCache.merged }));
}
return React.createElement(ComposedComponent,
tslib_1.__assign({}, defaultProps, componentProps));
}));
};
ComponentWithInjectedProps.prototype._onSettingChanged = function
() {
this.forceUpdate();
};
return ComponentWithInjectedProps;
}(React.Component)),
_a.displayName = 'Customized' + scope,
_a);
return hoistStatics_1.hoistStatics(ComposedComponent, resultClass);
};
}
exports.customizable = customizable;
//# sourceMappingURL=customizable.js.map
/***/ }),
/***/ 8336:
"use strict";

exports.mergeCustomizations = void 0;
var mergeSettings_1 = __webpack_require__(61);
/**
* Merge props and customizations giving priority to props over context.
* NOTE: This function will always perform multiple merge operations. Use with
caution.
* @param props - New settings to merge in.
* @param parentContext - Context containing current settings.
* @returns Merged customizations.
*/
function mergeCustomizations(props, parentContext) {
var _a = (parentContext || {}).customizations, customizations = _a === void 0 ?
{ settings: {}, scopedSettings: {} } : _a;
return {
customizations: {
settings: mergeSettings_1.mergeSettings(customizations.settings,
props.settings),
scopedSettings:
mergeSettings_1.mergeScopedSettings(customizations.scopedSettings,
props.scopedSettings),
inCustomizerContext: true,
},
};
}
exports.mergeCustomizations = mergeCustomizations;
//# sourceMappingURL=mergeCustomizations.js.map
/***/ }),
/***/ 61:
"use strict";

exports.mergeScopedSettings = exports.mergeSettings = void 0;
/**
* Merge new and old settings, giving priority to new settings.
* New settings is optional in which case oldSettings is returned as-is.
* @param oldSettings - Old settings to fall back to.
* @param newSettings - New settings that will be merged over oldSettings.
* @returns Merged settings.
*/
function mergeSettings(oldSettings, newSettings) {
if (oldSettings === void 0) { oldSettings = {}; }
var mergeSettingsWith = _isSettingsFunction(newSettings) ? newSettings :
_settingsMergeWith(newSettings);
return mergeSettingsWith(oldSettings);
}
exports.mergeSettings = mergeSettings;
function mergeScopedSettings(oldSettings, newSettings) {
if (oldSettings === void 0) { oldSettings = {}; }
var mergeSettingsWith = _isSettingsFunction(newSettings) ? newSettings :
_scopedSettingsMergeWith(newSettings);
return mergeSettingsWith(oldSettings);
}
exports.mergeScopedSettings = mergeScopedSettings;
function _isSettingsFunction(settings) {
return typeof settings === 'function';
}
function _settingsMergeWith(newSettings) {
return function (settings) { return (newSettings ?
tslib_1.__assign(tslib_1.__assign({}, settings), newSettings) : settings); };
}
function _scopedSettingsMergeWith(scopedSettingsFromProps) {
if (scopedSettingsFromProps === void 0) { scopedSettingsFromProps = {}; }
return function (oldScopedSettings) {
var newScopedSettings = tslib_1.__assign({}, oldScopedSettings);
for (var scopeName in scopedSettingsFromProps) {
if (scopedSettingsFromProps.hasOwnProperty(scopeName)) {
newScopedSettings[scopeName] =
tslib_1.__assign(tslib_1.__assign({}, oldScopedSettings[scopeName]),
scopedSettingsFromProps[scopeName]);
}
}
return newScopedSettings;
};
}
//# sourceMappingURL=mergeSettings.js.map
/***/ }),
/***/ 29640:
"use strict";

exports.useCustomizationSettings = void 0;
/**
* Hook to get Customizations settings from Customizations singleton or
CustomizerContext.
* It will trigger component state update on settings change observed.
*/
function useCustomizationSettings(properties, scopeName) {
var forceUpdate = useForceUpdate();
var customizations =
React.useContext(CustomizerContext_1.CustomizerContext).customizations;
var inCustomizerContext = customizations.inCustomizerContext;
if (!inCustomizerContext) {
Customizations_1.Customizations.observe(forceUpdate);
}
if (!inCustomizerContext) {
Customizations_1.Customizations.unobserve(forceUpdate);
}
};
// eslint-disable-next-line react-hooks/exhaustive-deps -- exclude
forceUpdate
}, [inCustomizerContext]);
return Customizations_1.Customizations.getSettings(properties, scopeName,
customizations);
}
exports.useCustomizationSettings = useCustomizationSettings;
function useForceUpdate() {
var _a = React.useState(0), setValue = _a[1];
return function () { return setValue(function (value) { return ++value; }); };
}
//# sourceMappingURL=useCustomizationSettings.js.map
/***/ }),
/***/ 81022:
"use strict";

exports.setVirtualParent = exports.setPortalAttribute =
exports.DATA_PORTAL_ATTRIBUTE = exports.raiseClick = exports.portalContainsElement
= exports.on = exports.isVirtualElement = exports.getWindow =
exports.getVirtualParent = exports.getRect = exports.getParent =
exports.getFirstVisibleElementFromSelector = exports.getDocument =
exports.getChildren = exports.findElementRecursive =
exports.elementContainsAttribute = exports.elementContains = void 0;
var elementContains_1 = __webpack_require__(1527);
function () { return elementContains_1.elementContains; } }));
var elementContainsAttribute_1 = __webpack_require__(16012);
elementContainsAttribute_1.elementContainsAttribute; } }));
function () { return findElementRecursive_1.findElementRecursive; } }));
var getChildren_1 = __webpack_require__(11933);
{ return getChildren_1.getChildren; } }));
var getDocument_1 = __webpack_require__(7611);
{ return getDocument_1.getDocument; } }));
var getFirstVisibleElementFromSelector_1 = __webpack_require__(59632);
getFirstVisibleElementFromSelector_1.getFirstVisibleElementFromSelector; } }));
return getParent_1.getParent; } }));
var getRect_1 = __webpack_require__(37978);
{ return getRect_1.getRect; } }));
var getVirtualParent_1 = __webpack_require__(97370);
function () { return getVirtualParent_1.getVirtualParent; } }));
return getWindow_1.getWindow; } }));
function () { return isVirtualElement_1.isVirtualElement; } }));
var on_1 = __webpack_require__(12765);
on_1.on; } }));
var portalContainsElement_1 = __webpack_require__(20507);
function () { return portalContainsElement_1.portalContainsElement; } }));
var raiseClick_1 = __webpack_require__(79375);
{ return raiseClick_1.raiseClick; } }));
var setPortalAttribute_1 = __webpack_require__(68590);
function () { return setPortalAttribute_1.DATA_PORTAL_ATTRIBUTE; } }));
function () { return setPortalAttribute_1.setPortalAttribute; } }));
var setVirtualParent_1 = __webpack_require__(46846);
function () { return setVirtualParent_1.setVirtualParent; } }));
//# sourceMappingURL=dom.js.map
/***/ }),
/***/ 1527:
"use strict";

exports.elementContains = void 0;
var dom_utilities_1 = __webpack_require__(2970);
function () { return dom_utilities_1.elementContains; } }));
//# sourceMappingURL=elementContains.js.map
/***/ }),
/***/ 16012:
"use strict";

exports.elementContainsAttribute = void 0;
get: function () { return dom_utilities_1.elementContainsAttribute; } }));
//# sourceMappingURL=elementContainsAttribute.js.map
/***/ }),
/***/ 87220:
"use strict";

exports.findElementRecursive = void 0;
function () { return dom_utilities_1.findElementRecursive; } }));
//# sourceMappingURL=findElementRecursive.js.map
/***/ }),
/***/ 11933:
"use strict";

exports.getChildren = void 0;
{ return dom_utilities_1.getChildren; } }));
//# sourceMappingURL=getChildren.js.map
/***/ }),
/***/ 7611:
"use strict";

exports.getDocument = void 0;
var setSSR_1 = __webpack_require__(84934);
/**
* Helper to get the document object. Note that in popup window cases, document
* might be the wrong document, which is why we look at ownerDocument for the
* truth. Also note that the SSR flag is used to test ssr scenarios even if
* document is defined (from JSDOM for example.)
*
* @public
*/
function getDocument(rootElement) {
if (setSSR_1._isSSR || typeof document === 'undefined') {
return undefined;
}
else {
var el = rootElement;
return el && el.ownerDocument ? el.ownerDocument : document;
}
}
exports.getDocument = getDocument;
//# sourceMappingURL=getDocument.js.map
/***/ }),
/***/ 59632:
"use strict";

exports.getFirstVisibleElementFromSelector = void 0;
var focus_1 = __webpack_require__(78224);
/**
* Gets the first visible element that matches the given selector
* @param selector - The selector to use to find potential visible elements
* @returns The first visible element that matches the selector, otherwise
undefined
*
* @public
*/
function getFirstVisibleElementFromSelector(selector) {
var elements = getDocument_1.getDocument().querySelectorAll(selector);
// Iterate across the elements that match the selector and return the first
visible/non-hidden element
return Array.from(elements).find(function (element) { return
focus_1.isElementVisibleAndNotHidden(element); });
}
exports.getFirstVisibleElementFromSelector = getFirstVisibleElementFromSelector;
//# sourceMappingURL=getFirstVisibleElementFromSelector.js.map
/***/ }),
/***/ 89404:
"use strict";

exports.getParent = void 0;
return dom_utilities_1.getParent; } }));
//# sourceMappingURL=getParent.js.map
/***/ }),
/***/ 37978:
"use strict";

exports.getRect = void 0;
/**
* Helper to get bounding client rect. Passing in window will get the window size.
*
* @public
*/
function getRect(element) {
var rect;
if (element) {
if (element === window) {
rect = {
left: 0,
top: 0,
width: window.innerWidth,
height: window.innerHeight,
right: window.innerWidth,
bottom: window.innerHeight,
};
}
else if (element.getBoundingClientRect) {
rect = element.getBoundingClientRect();
}
}
return rect;
}
exports.getRect = getRect;
//# sourceMappingURL=getRect.js.map
/***/ }),
/***/ 97370:
"use strict";

exports.getVirtualParent = void 0;
function () { return dom_utilities_1.getVirtualParent; } }));
//# sourceMappingURL=getVirtualParent.js.map
/***/ }),
/***/ 17746:
"use strict";

exports.getWindow = void 0;
var _window = undefined;
// Note: Accessing "window" in IE11 is somewhat expensive, and calling "typeof
window"
// hits a memory leak, whereas aliasing it and calling "typeof _window" does not.
// Caching the window value at the file scope lets us minimize the impact.
try {
_window = window;
}
catch (e) {
/* no-op */
}
/**
* Helper to get the window object. The helper will make sure to use a cached
variable
* of "window", to avoid overhead and memory leaks in IE11. Note that in popup
scenarios the
* window object won't match the "global" window object, and for these scenarios,
you should
* pass in an element hosted within the popup.
*
* @public
*/
function getWindow(rootElement) {
if (setSSR_1._isSSR || typeof _window === 'undefined') {
return undefined;
}
else {
var el = rootElement;
return el && el.ownerDocument && el.ownerDocument.defaultView ?
el.ownerDocument.defaultView : _window;
}
}
exports.getWindow = getWindow;
//# sourceMappingURL=getWindow.js.map
/***/ }),
/***/ 44373:
"use strict";

exports.isVirtualElement = void 0;
function () { return dom_utilities_1.isVirtualElement; } }));
//# sourceMappingURL=isVirtualElement.js.map
/***/ }),
/***/ 12765:
"use strict";

exports.on = void 0;
function on(element, eventName, callback, options) {
element.addEventListener(eventName, callback, options);
return function () { return element.removeEventListener(eventName, callback,
options); };
}
exports.on = on;
//# sourceMappingURL=on.js.map
/***/ }),
/***/ 20507:
"use strict";

exports.portalContainsElement = void 0;
function () { return dom_utilities_1.portalContainsElement; } }));
//# sourceMappingURL=portalContainsElement.js.map
/***/ }),
/***/ 79375:
"use strict";

exports.raiseClick = void 0;
/** Raises a click event.
* @deprecated Moved to `FocusZone` component since it was the only place
internally using this function.
*/
function raiseClick(target) {
var event = createNewEvent('MouseEvents');
event.initEvent('click', true, true);
target.dispatchEvent(event);
}
exports.raiseClick = raiseClick;
function createNewEvent(eventName) {
var event;
if (typeof Event === 'function') {
// Chrome, Opera, Firefox
event = new Event(eventName);
}
else {
// IE
event = document.createEvent('Event');
event.initEvent(eventName, true, true);
}
return event;
}
//# sourceMappingURL=raiseClick.js.map
/***/ }),
/***/ 68590:
"use strict";

exports.setPortalAttribute = exports.DATA_PORTAL_ATTRIBUTE = void 0;
function () { return dom_utilities_1.DATA_PORTAL_ATTRIBUTE; } }));
function () { return dom_utilities_1.setPortalAttribute; } }));
//# sourceMappingURL=setPortalAttribute.js.map
/***/ }),
/***/ 84934:
"use strict";

exports.setSSR = exports._isSSR = void 0;
exports._isSSR = false;
/**
* Helper to set ssr mode to simulate no window object returned from getWindow
helper.
*
* @public
*/
function setSSR(isEnabled) {
exports._isSSR = isEnabled;
}
exports.setSSR = setSSR;
//# sourceMappingURL=setSSR.js.map
/***/ }),
/***/ 46846:
"use strict";

exports.setVirtualParent = void 0;
function () { return dom_utilities_1.setVirtualParent; } }));
//# sourceMappingURL=setVirtualParent.js.map
/***/ }),
/***/ 68425:
"use strict";

exports.extendComponent = void 0;
var appendFunction_1 = __webpack_require__(36689);
/**
* Extends a component's lifetime methods by appending new functions to the
existing lifetime functions.
*/
function extendComponent(parent, methods) {
for (var name_1 in methods) {
if (methods.hasOwnProperty(name_1)) {
parent[name_1] = appendFunction_1.appendFunction(parent,
parent[name_1], methods[name_1]);
}
}
}
exports.extendComponent = extendComponent;
//# sourceMappingURL=extendComponent.js.map
/***/ }),
/***/ 78224:
"use strict";

exports.getElementIndexPath = exports.getFocusableByIndexPath = exports.focusAsync
= exports.shouldWrapFocus = exports.doesElementContainFocus =
exports.isElementFocusSubZone = exports.isElementFocusZone =
exports.isElementTabbable = exports.isElementVisibleAndNotHidden =
exports.isElementVisible = exports.getNextElement = exports.getPreviousElement =
exports.focusFirstChild = exports.getLastTabbable = exports.getFirstTabbable =
exports.getLastFocusable = exports.getFirstFocusable = void 0;
var elementContainsAttribute_1 = __webpack_require__(16012);
var elementContains_1 = __webpack_require__(1527);
var IS_FOCUSABLE_ATTRIBUTE = 'data-is-focusable';
var IS_VISIBLE_ATTRIBUTE = 'data-is-visible';
var FOCUSZONE_ID_ATTRIBUTE = 'data-focuszone-id';
var FOCUSZONE_SUB_ATTRIBUTE = 'data-is-sub-focuszone';
/**
* Gets the first focusable element.
*
* @public
*/
function getFirstFocusable(rootElement, currentElement,
includeElementsInFocusZones) {
return getNextElement(rootElement, currentElement, true /*checkNode*/, false
/*suppressParentTraversal*/, false /*suppressChildTraversal*/,
includeElementsInFocusZones);
}
exports.getFirstFocusable = getFirstFocusable;
/**
* Gets the last focusable element.
*
* @public
*/
function getLastFocusable(rootElement, currentElement, includeElementsInFocusZones)
{
return getPreviousElement(rootElement, currentElement, true /*checkNode*/,
false /*suppressParentTraversal*/, true /*traverseChildren*/,
includeElementsInFocusZones);
}
exports.getLastFocusable = getLastFocusable;
/**
* Gets the first tabbable element. (The difference between focusable and tabbable
is that tabbable elements are
* focusable elements that also have tabIndex != -1.)
* @param rootElement - The parent element to search beneath.
* @param currentElement - The descendant of rootElement to start the search at.
This element is the first one checked,
* and iteration continues forward. Typical use passes rootElement.firstChild.
* @param includeElementsInFocusZones - true if traversal should go into FocusZone
descendants.
* @param checkNode - Include currentElement in search when true. Defaults to true.
* @public
*/
function getFirstTabbable(rootElement, currentElement, includeElementsInFocusZones,
checkNode) {
if (checkNode === void 0) { checkNode = true; }
return getNextElement(rootElement, currentElement, checkNode, false
/*suppressParentTraversal*/, false /*suppressChildTraversal*/,
includeElementsInFocusZones, false /*allowFocusRoot*/, true /*tabbable*/);
}
exports.getFirstTabbable = getFirstTabbable;
/**
* Gets the last tabbable element. (The difference between focusable and tabbable
is that tabbable elements are
* focusable elements that also have tabIndex != -1.)
* @param rootElement - The parent element to search beneath.
* @param currentElement - The descendant of rootElement to start the search at.
This element is the first one checked,
* and iteration continues in reverse. Typical use passes rootElement.lastChild.
* @param includeElementsInFocusZones - true if traversal should go into FocusZone
descendants.
* @param checkNode - Include currentElement in search when true. Defaults to true.
* @public
*/
function getLastTabbable(rootElement, currentElement, includeElementsInFocusZones,
checkNode) {
if (checkNode === void 0) { checkNode = true; }
return getPreviousElement(rootElement, currentElement, checkNode, false
/*suppressParentTraversal*/, true /*traverseChildren*/,
includeElementsInFocusZones, false /*allowFocusRoot*/, true /*tabbable*/);
}
exports.getLastTabbable = getLastTabbable;
/**
* Attempts to focus the first focusable element that is a child or child's child
of the rootElement.
*
* @public
* @param rootElement - Element to start the search for a focusable child.
* @returns True if focus was set, false if it was not.
*/
function focusFirstChild(rootElement) {
var element = getNextElement(rootElement, rootElement, true, false, false,
true);
if (element) {
focusAsync(element);
return true;
}
return false;
}
exports.focusFirstChild = focusFirstChild;
/**
* Traverse to find the previous element.
* If tabbable is true, the element must have tabIndex != -1.
*
* @public
*/
function getPreviousElement(rootElement, currentElement, checkNode,
suppressParentTraversal, traverseChildren, includeElementsInFocusZones,
allowFocusRoot, tabbable) {
if (!currentElement || (!allowFocusRoot && currentElement === rootElement)) {
return null;
}
var isCurrentElementVisible = isElementVisible(currentElement);
// Check its children.
if (traverseChildren &&
isCurrentElementVisible &&
(includeElementsInFocusZones || !(isElementFocusZone(currentElement) ||
isElementFocusSubZone(currentElement)))) {
var childMatch = getPreviousElement(rootElement,
currentElement.lastElementChild, true, true, true, includeElementsInFocusZones,
allowFocusRoot, tabbable);
if (childMatch) {
if ((tabbable && isElementTabbable(childMatch, true)) || !tabbable) {
return childMatch;
}
var childMatchSiblingMatch = getPreviousElement(rootElement,
childMatch.previousElementSibling, true, true, true, includeElementsInFocusZones,
if (childMatchSiblingMatch) {
return childMatchSiblingMatch;
}
var childMatchParent = childMatch.parentElement;
// At this point if we have not found any potential matches
// start looking at the rest of the subtree under the currentParent.
// NOTE: We do not want to recurse here because doing so could
// cause elements to get skipped.
while (childMatchParent && childMatchParent !== currentElement) {
var childMatchParentMatch = getPreviousElement(rootElement,
childMatchParent.previousElementSibling, true, true, true,
includeElementsInFocusZones, allowFocusRoot, tabbable);
if (childMatchParentMatch) {
return childMatchParentMatch;
}
childMatchParent = childMatchParent.parentElement;
}
}
}
// Check the current node, if it's not the first traversal.
if (checkNode && isCurrentElementVisible && isElementTabbable(currentElement,
tabbable)) {
return currentElement;
}
// Check its previous sibling.
var siblingMatch = getPreviousElement(rootElement,
currentElement.previousElementSibling, true, true, true,
includeElementsInFocusZones, allowFocusRoot, tabbable);
if (siblingMatch) {
return siblingMatch;
}
// Check its parent.
if (!suppressParentTraversal) {
return getPreviousElement(rootElement, currentElement.parentElement, true,
false, false, includeElementsInFocusZones, allowFocusRoot, tabbable);
}
return null;
}
exports.getPreviousElement = getPreviousElement;
/**
* Traverse to find the next focusable element.
* If tabbable is true, the element must have tabIndex != -1.
*
* @public
* @param checkNode - Include currentElement in search when true.
*/
function getNextElement(rootElement, currentElement, checkNode,
suppressParentTraversal, suppressChildTraversal, includeElementsInFocusZones,
allowFocusRoot, tabbable) {
if (!currentElement || (currentElement === rootElement &&
suppressChildTraversal && !allowFocusRoot)) {
return null;
}
var isCurrentElementVisible = isElementVisible(currentElement);
// Check the current node, if it's not the first traversal.
if (checkNode && isCurrentElementVisible && isElementTabbable(currentElement,
tabbable)) {
return currentElement;
}
// Check its children.
if (!suppressChildTraversal &&
isCurrentElementVisible &&
(includeElementsInFocusZones || !(isElementFocusZone(currentElement) ||
isElementFocusSubZone(currentElement)))) {
var childMatch = getNextElement(rootElement,
currentElement.firstElementChild, true, true, false, includeElementsInFocusZones,
if (childMatch) {
return childMatch;
}
}
if (currentElement === rootElement) {
return null;
}
// Check its sibling.
var siblingMatch = getNextElement(rootElement,
currentElement.nextElementSibling, true, true, false, includeElementsInFocusZones,
if (siblingMatch) {
return siblingMatch;
}
if (!suppressParentTraversal) {
return getNextElement(rootElement, currentElement.parentElement, false,
false, true, includeElementsInFocusZones, allowFocusRoot, tabbable);
}
return null;
}
exports.getNextElement = getNextElement;
/**
* Determines if an element is visible.
*
* @public
*/
function isElementVisible(element) {
// If the element is not valid, return false.
if (!element || !element.getAttribute) {
return false;
}
var visibilityAttribute = element.getAttribute(IS_VISIBLE_ATTRIBUTE);
// If the element is explicitly marked with the visibility attribute, return
that value as boolean.
if (visibilityAttribute !== null && visibilityAttribute !== undefined) {
return visibilityAttribute === 'true';
}
// Fallback to other methods of determining actual visibility.
return (element.offsetHeight !== 0 ||
element.offsetParent !== null ||
element.isVisible === true); // used as a workaround for testing.
}
exports.isElementVisible = isElementVisible;
/**
* Determines if an element is visible and not hidden
* @param element - Element to check
* @returns Returns true if the given element is visible and not hidden
*
* @public
*/
function isElementVisibleAndNotHidden(element) {
return (!!element &&
isElementVisible(element) &&
!element.hidden &&
window.getComputedStyle(element).visibility !== 'hidden');
}
exports.isElementVisibleAndNotHidden = isElementVisibleAndNotHidden;
/**
* Determines if an element can receive focus programmatically or via a mouse
click.
* If checkTabIndex is true, additionally checks to ensure the element can be
focused with the tab key,
* meaning tabIndex != -1.
*
* @public
*/
function isElementTabbable(element, checkTabIndex) {
// If this element is null or is disabled, it is not considered tabbable.
if (!element || element.disabled) {
return false;
}
var tabIndex = 0;
var tabIndexAttributeValue = null;
if (element && element.getAttribute) {
tabIndexAttributeValue = element.getAttribute('tabIndex');
if (tabIndexAttributeValue) {
tabIndex = parseInt(tabIndexAttributeValue, 10);
}
}
var isFocusableAttribute = element.getAttribute ?
element.getAttribute(IS_FOCUSABLE_ATTRIBUTE) : null;
var isTabIndexSet = tabIndexAttributeValue !== null && tabIndex >= 0;
var result = !!element &&
isFocusableAttribute !== 'false' &&
(element.tagName === 'A' ||
element.tagName === 'BUTTON' ||
element.tagName === 'INPUT' ||
element.tagName === 'TEXTAREA' ||
element.tagName === 'SELECT' ||
isFocusableAttribute === 'true' ||
isTabIndexSet);
return checkTabIndex ? tabIndex !== -1 && result : result;
}
exports.isElementTabbable = isElementTabbable;
/**
* Determines if a given element is a focus zone.
*
* @public
*/
function isElementFocusZone(element) {
return !!(element && element.getAttribute && !!
element.getAttribute(FOCUSZONE_ID_ATTRIBUTE));
}
exports.isElementFocusZone = isElementFocusZone;
/**
* Determines if a given element is a focus sub zone.
*
* @public
*/
function isElementFocusSubZone(element) {
return !!(element && element.getAttribute &&
element.getAttribute(FOCUSZONE_SUB_ATTRIBUTE) === 'true');
}
exports.isElementFocusSubZone = isElementFocusSubZone;
/**
* Determines if an element, or any of its children, contain focus.
*
* @public
*/
function doesElementContainFocus(element) {
var document = getDocument_1.getDocument(element);
var currentActiveElement = document && document.activeElement;
if (currentActiveElement && elementContains_1.elementContains(element,
currentActiveElement)) {
return true;
}
return false;
}
exports.doesElementContainFocus = doesElementContainFocus;
/**
* Determines if an, or any of its ancestors, sepcificies that it doesn't want
focus to wrap
* @param element - element to start searching from
* @param noWrapDataAttribute - the no wrap data attribute to match (either)
* @returns true if focus should wrap, false otherwise
*/
function shouldWrapFocus(element, noWrapDataAttribute) {
return elementContainsAttribute_1.elementContainsAttribute(element,
noWrapDataAttribute) === 'true' ? false : true;
}
exports.shouldWrapFocus = shouldWrapFocus;
var targetToFocusOnNextRepaint = undefined;
/**
* Sets focus to an element asynchronously. The focus will be set at the next
browser repaint,
* meaning it won't cause any extra recalculations. If more than one focusAsync is
called during one frame,
* only the latest called focusAsync element will actually be focused
* @param element - The element to focus
*/
function focusAsync(element) {
if (element) {
// An element was already queued to be focused, so replace that one with
the new element
if (targetToFocusOnNextRepaint) {
targetToFocusOnNextRepaint = element;
return;
}
targetToFocusOnNextRepaint = element;
var win = getWindow_1.getWindow(element);
if (win) {
// element.focus() is a no-op if the element is no longer in the DOM,
meaning this is always safe
win.requestAnimationFrame(function () {
targetToFocusOnNextRepaint && targetToFocusOnNextRepaint.focus();
// We are done focusing for this frame, so reset the queued focus
element
targetToFocusOnNextRepaint = undefined;
});
}
}
}
exports.focusAsync = focusAsync;
/**
* Finds the closest focusable element via an index path from a parent. See
* `getElementIndexPath` for getting an index path from an element to a child.
*/
function getFocusableByIndexPath(parent, path) {
var element = parent;
for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
var index = path_1[_i];
var nextChild = element.children[Math.min(index, element.children.length -
1)];
if (!nextChild) {
break;
}
element = nextChild;
}
element =
isElementTabbable(element) && isElementVisible(element)
? element
: getNextElement(parent, element, true) || getPreviousElement(parent,
element);
return element;
}
exports.getFocusableByIndexPath = getFocusableByIndexPath;
/**
* Finds the element index path from a parent element to a child element.
*
* If you had this node structure: "A has children [B, C] and C has child D",
* the index path from A to D would be [1, 0], or `parent.chidren[1].children[0]`.
*/
function getElementIndexPath(fromElement, toElement) {
var path = [];
while (toElement && fromElement && toElement !== fromElement) {
var parent_1 = getParent_1.getParent(toElement, true);
if (parent_1 === null) {
return [];
}
path.unshift(Array.prototype.indexOf.call(parent_1.children, toElement));
toElement = parent_1;
}
return path;
}
exports.getElementIndexPath = getElementIndexPath;
//# sourceMappingURL=focus.js.map
/***/ }),
/***/ 77937:
"use strict";

exports.resetIds = exports.getId = void 0;
// Initialize global window id.
var CURRENT_ID_PROPERTY = '__currentId__';
var DEFAULT_ID_STRING = 'id__';
var _global = getWindow_1.getWindow() || {};
if (_global[CURRENT_ID_PROPERTY] === undefined) {
_global[CURRENT_ID_PROPERTY] = 0;
}
var _initializedStylesheetResets = false;
/**
* Generates a unique id in the global scope (this spans across duplicate copies of
the same library.)
*
* @public
*/
function getId(prefix) {
if (!_initializedStylesheetResets) {
// Configure ids to reset on stylesheet resets.
stylesheet.onReset(resetIds);
}
_initializedStylesheetResets = true;
}
var index = _global[CURRENT_ID_PROPERTY]++;
return (prefix === undefined ? DEFAULT_ID_STRING : prefix) + index;
}
exports.getId = getId;
/**
* Resets id counter to an (optional) number.
*
* @public
*/
function resetIds(counter) {
if (counter === void 0) { counter = 0; }
_global[CURRENT_ID_PROPERTY] = counter;
}
exports.resetIds = resetIds;
//# sourceMappingURL=getId.js.map
/***/ }),
/***/ 38863:
"use strict";

exports.getNativeElementProps = void 0;
var properties_1 = __webpack_require__(21850);
var nativeElementMap = {
label: properties_1.labelProperties,
audio: properties_1.audioProperties,
video: properties_1.videoProperties,
ol: properties_1.olProperties,
li: properties_1.liProperties,
a: properties_1.anchorProperties,
button: properties_1.buttonProperties,
input: properties_1.inputProperties,
textarea: properties_1.textAreaProperties,
select: properties_1.selectProperties,
option: properties_1.optionProperties,
table: properties_1.tableProperties,
tr: properties_1.trProperties,
th: properties_1.thProperties,
td: properties_1.tdProperties,
colGroup: properties_1.colGroupProperties,
col: properties_1.colProperties,
form: properties_1.formProperties,
iframe: properties_1.iframeProperties,
img: properties_1.imgProperties,
};
/**
* Given an element tagname and user props, filters the props to only allowed props
for the given
* element type.
* @param tagName - Tag name (e.g. "div")
* @param props - Props object
* @param excludedPropNames - List of props to disallow
*/
function getNativeElementProps(tagName, props, excludedPropNames) {
var allowedPropNames = (tagName && nativeElementMap[tagName]) ||
properties_1.htmlElementProperties;
return properties_1.getNativeProps(props, allowedPropNames, excludedPropNames);
}
exports.getNativeElementProps = getNativeElementProps;
//# sourceMappingURL=getNativeElementProps.js.map
/***/ }),
/***/ 74085:
"use strict";

exports.getPropsWithDefaults = void 0;
/**
* Function to apply default values to a component props object. This function is
intended for function components,
* to maintain parity with the `defaultProps` feature of class components. It
accounts for properties that are
* specified, but undefined.
* @param defaultProps- An object with default values for various properties
* @param propsWithoutDefaults- The props object passed into the component
*/
function getPropsWithDefaults(defaultProps, propsWithoutDefaults) {
var props = tslib_1.__assign({}, propsWithoutDefaults);
for (var _i = 0, _a = Object.keys(defaultProps); _i < _a.length; _i++) {
var key = _a[_i];
if (props[key] === undefined) {
props[key] = defaultProps[key];
}
}
return props;
}
exports.getPropsWithDefaults = getPropsWithDefaults;
//# sourceMappingURL=getPropsWithDefaults.js.map
/***/ }),
/***/ 77998:
"use strict";

exports.unhoistMethods = exports.hoistMethods = void 0;
var REACT_LIFECYCLE_EXCLUSIONS = [
'setState',
'render',
'componentWillMount',
'UNSAFE_componentWillMount',
'componentDidMount',
'componentWillReceiveProps',
'UNSAFE_componentWillReceiveProps',
'shouldComponentUpdate',
'componentWillUpdate',
'getSnapshotBeforeUpdate',
'UNSAFE_componentWillUpdate',
'componentDidUpdate',
'componentWillUnmount',
];
/**
* Allows you to hoist methods, except those in an exclusion set from a source
object into a destination object.
*
* @public
* @param destination - The instance of the object to hoist the methods onto.
* @param source - The instance of the object where the methods are hoisted from.
* @param exclusions - (Optional) What methods to exclude from being hoisted.
* @returns An array of names of methods that were hoisted.
*/
function hoistMethods(
destination,
source, exclusions) {
if (exclusions === void 0) { exclusions = REACT_LIFECYCLE_EXCLUSIONS; }
var hoisted = [];
var _loop_1 = function (methodName) {
if (typeof source[methodName] === 'function' &&
destination[methodName] === undefined &&
(!exclusions || exclusions.indexOf(methodName) === -1)) {
hoisted.push(methodName);
destination[methodName] = function () {
var args = [];
}
source[methodName].apply(source, args);
};
}
};
for (var methodName in source) {
_loop_1(methodName);
}
return hoisted;
}
exports.hoistMethods = hoistMethods;
/**
* Provides a method for convenience to unhoist hoisted methods.
*
* @public
* @param source - The source object upon which methods were hoisted.
* @param methodNames - An array of method names to unhoist.
*/
function unhoistMethods(source, methodNames) {
methodNames.forEach(function (methodName) { return delete
source[methodName]; });
}
exports.unhoistMethods = unhoistMethods;
//# sourceMappingURL=hoist.js.map
/***/ }),
/***/ 47272:
"use strict";
/**
* Allows you to hoist static functions in components.
* Created for the purpose of fixing broken static functions in classes
* that utilize decorators.
*
* @public
* @param source - The object where the methods are hoisted from.
* @param dest - The object to hoist the methods onto.
* @returns The dest object with methods added
*/
exports.hoistStatics = void 0;
function hoistStatics(source, dest) {
for (var name_1 in source) {
if (source.hasOwnProperty(name_1)) {
dest[name_1] = source[name_1];
}
}
return dest;
}
exports.hoistStatics = hoistStatics;
//# sourceMappingURL=hoistStatics.js.map
/***/ }),
/***/ 24478:
"use strict";

exports.isIE11 = void 0;
var isIE11 = function () {
var _a;
if (!((_a = win === null || win === void 0 ? void 0 : win.navigator) === null
|| _a === void 0 ? void 0 : _a.userAgent)) {
return false;
}
return win.navigator.userAgent.indexOf('rv:11.0') > -1;
};
exports.isIE11 = isIE11;
//# sourceMappingURL=ie11Detector.js.map
/***/ }),
/***/ 10254:
"use strict";

exports.raiseClick = exports.portalContainsElement = exports.on =
exports.isVirtualElement = exports.getWindow = exports.getVirtualParent =
exports.getRect = exports.getParent = exports.getFirstVisibleElementFromSelector =
exports.getDocument = exports.getChildren = exports.findElementRecursive =
exports.elementContainsAttribute = exports.elementContains =
exports.DATA_PORTAL_ATTRIBUTE = exports.mergeSettings = exports.mergeScopedSettings
= exports.mergeCustomizations = exports.useCustomizationSettings =
exports.customizable = exports.CustomizerContext = exports.Customizer =
exports.Customizations = exports.css = exports.isControlled =
exports.composeComponentAs = exports.classNamesFunction = exports.assertNever =
exports.asAsync = exports.toMatrix = exports.replaceElement = exports.removeIndex =
exports.flatten = exports.findIndex = exports.find = exports.createArray =
exports.arraysEqual = exports.addElementAtIndex = exports.mergeAriaAttributeValues
= exports.appendFunction = exports.Rectangle = exports.KeyCodes =
exports.GlobalSettings = exports.FabricPerformance = exports.EventGroup =
exports.DelayedRender = exports.nullRender = exports.BaseComponent =
exports.AutoScroll = exports.Async = void 0;
exports.mapEnumByName = exports.filteredAssign = exports.assign = exports.modalize
= exports.isIOS = exports.merge = exports.setMemoizeWeakMap =
exports.resetMemoizations = exports.memoizeFunction = exports.memoize =
exports.createMemoizer = exports.precisionRound = exports.getDistanceBetweenPoints
= exports.fitContentToBounds = exports.calculatePrecision = exports.setLanguage =
exports.getLanguage = exports.isDirectionalKeyCode = exports.addDirectionalKeyCode
= exports.getInitials = exports.useFocusRects = exports.FocusRects =
exports.initializeFocusRects = exports.initializeComponentRef =
exports.hoistStatics = exports.unhoistMethods = exports.hoistMethods =
exports.getNativeElementProps = exports.resetIds = exports.getId =
exports.shouldWrapFocus = exports.isElementVisibleAndNotHidden =
exports.isElementVisible = exports.isElementTabbable = exports.isElementFocusZone =
exports.isElementFocusSubZone = exports.getPreviousElement = exports.getNextElement
= exports.getLastTabbable = exports.getLastFocusable =
exports.getFocusableByIndexPath = exports.getFirstTabbable =
exports.getFirstFocusable = exports.getElementIndexPath = exports.focusFirstChild =
exports.focusAsync = exports.doesElementContainFocus = exports.extendComponent =
exports.setVirtualParent = exports.setPortalAttribute = void 0;
exports.SELECTION_ITEMS_CHANGE = exports.SELECTION_CHANGE =
exports.getScrollbarWidth = exports.findScrollableParent = exports.enableBodyScroll
= exports.disableBodyScroll = exports.allowScrollOnElement =
exports.allowOverscrollOnElement = exports.DATA_IS_SCROLLABLE_ATTRIBUTE =
exports.safeSetTimeout = exports.safeRequestAnimationFrame = exports.setRTL =
exports.getRTLSafeKeyCode = exports.getRTL = exports.setBaseUrl =
exports.getResourceUrl = exports.composeRenderFunction = exports.videoProperties =
exports.trProperties = exports.thProperties = exports.textAreaProperties =
exports.tdProperties = exports.tableProperties = exports.selectProperties =
exports.optionProperties = exports.olProperties = exports.liProperties =
exports.labelProperties = exports.inputProperties = exports.imgProperties =
exports.imageProperties = exports.iframeProperties = exports.htmlElementProperties
= exports.getNativeProps = exports.formProperties = exports.divProperties =
exports.colProperties = exports.colGroupProperties = exports.buttonProperties =
exports.baseElementProperties = exports.baseElementEvents = exports.audioProperties
= exports.anchorProperties = exports.hasVerticalOverflow = exports.hasOverflow =
exports.hasHorizontalOverflow = exports.isMac = exports.omit = exports.values =
exports.shallowCompare = void 0;
exports.useIsomorphicLayoutEffect = exports.createMergedRef = exports.setSSR =
exports.IsFocusVisibleClassName = exports.setFocusVisibility =
exports.getPropsWithDefaults = exports.isIE11 = exports.warnMutuallyExclusive =
exports.warnDeprecations = exports.warnControlledUsage =
exports.warnConditionallyRequiredProps = exports.warn = exports.setWarningCallback
= exports.resetControlledWarnings = exports.styled = exports.format =
exports.SelectionMode = exports.SelectionDirection = exports.Selection = void 0;
var Async_1 = __webpack_require__(13482);
Object.defineProperty(exports, "Async", ({ enumerable: true, get: function ()
{ return Async_1.Async; } }));
var AutoScroll_1 = __webpack_require__(72418);
Object.defineProperty(exports, "AutoScroll", ({ enumerable: true, get: function ()
{ return AutoScroll_1.AutoScroll; } }));
var BaseComponent_1 = __webpack_require__(97442);
Object.defineProperty(exports, "BaseComponent", ({ enumerable: true, get: function
() { return BaseComponent_1.BaseComponent; } }));
Object.defineProperty(exports, "nullRender", ({ enumerable: true, get: function ()
{ return BaseComponent_1.nullRender; } }));
var DelayedRender_1 = __webpack_require__(87065);
Object.defineProperty(exports, "DelayedRender", ({ enumerable: true, get: function
() { return DelayedRender_1.DelayedRender; } }));
Object.defineProperty(exports, "EventGroup", ({ enumerable: true, get: function ()
{ return EventGroup_1.EventGroup; } }));
var FabricPerformance_1 = __webpack_require__(70141);
Object.defineProperty(exports, "FabricPerformance", ({ enumerable: true, get:
function () { return FabricPerformance_1.FabricPerformance; } }));
var GlobalSettings_1 = __webpack_require__(84526);
Object.defineProperty(exports, "GlobalSettings", ({ enumerable: true, get: function
() { return GlobalSettings_1.GlobalSettings; } }));
var KeyCodes_1 = __webpack_require__(31555);
Object.defineProperty(exports, "KeyCodes", ({ enumerable: true, get: function ()
{ return KeyCodes_1.KeyCodes; } }));
var Rectangle_1 = __webpack_require__(28602);
Object.defineProperty(exports, "Rectangle", ({ enumerable: true, get: function () {
return Rectangle_1.Rectangle; } }));
var appendFunction_1 = __webpack_require__(36689);
Object.defineProperty(exports, "appendFunction", ({ enumerable: true, get: function
() { return appendFunction_1.appendFunction; } }));
var aria_1 = __webpack_require__(36813);
Object.defineProperty(exports, "mergeAriaAttributeValues", ({ enumerable: true,
get: function () { return aria_1.mergeAriaAttributeValues; } }));
var array_1 = __webpack_require__(48843);
Object.defineProperty(exports, "addElementAtIndex", ({ enumerable: true, get:
function () { return array_1.addElementAtIndex; } }));
Object.defineProperty(exports, "arraysEqual", ({ enumerable: true, get: function ()
{ return array_1.arraysEqual; } }));
Object.defineProperty(exports, "createArray", ({ enumerable: true, get: function ()
{ return array_1.createArray; } }));
Object.defineProperty(exports, "find", ({ enumerable: true, get: function ()
{ return array_1.find; } }));
Object.defineProperty(exports, "findIndex", ({ enumerable: true, get: function () {
return array_1.findIndex; } }));
Object.defineProperty(exports, "flatten", ({ enumerable: true, get: function ()
{ return array_1.flatten; } }));
Object.defineProperty(exports, "removeIndex", ({ enumerable: true, get: function ()
{ return array_1.removeIndex; } }));
Object.defineProperty(exports, "replaceElement", ({ enumerable: true, get: function
() { return array_1.replaceElement; } }));
Object.defineProperty(exports, "toMatrix", ({ enumerable: true, get: function ()
{ return array_1.toMatrix; } }));
var asAsync_1 = __webpack_require__(53944);
Object.defineProperty(exports, "asAsync", ({ enumerable: true, get: function ()
{ return asAsync_1.asAsync; } }));
var assertNever_1 = __webpack_require__(85463);
Object.defineProperty(exports, "assertNever", ({ enumerable: true, get: function ()
{ return assertNever_1.assertNever; } }));
var classNamesFunction_1 = __webpack_require__(248);
Object.defineProperty(exports, "classNamesFunction", ({ enumerable: true, get:
function () { return classNamesFunction_1.classNamesFunction; } }));
var composeComponentAs_1 = __webpack_require__(15726);
Object.defineProperty(exports, "composeComponentAs", ({ enumerable: true, get:
function () { return composeComponentAs_1.composeComponentAs; } }));
var controlled_1 = __webpack_require__(54206);
Object.defineProperty(exports, "isControlled", ({ enumerable: true, get: function
() { return controlled_1.isControlled; } }));
var css_1 = __webpack_require__(21822);
Object.defineProperty(exports, "css", ({ enumerable: true, get: function ()
{ return css_1.css; } }));
Object.defineProperty(exports, "Customizations", ({ enumerable: true, get: function
() { return Customizations_1.Customizations; } }));
var Customizer_1 = __webpack_require__(89433);
Object.defineProperty(exports, "Customizer", ({ enumerable: true, get: function ()
{ return Customizer_1.Customizer; } }));
Object.defineProperty(exports, "CustomizerContext", ({ enumerable: true, get:
function () { return CustomizerContext_1.CustomizerContext; } }));
var customizable_1 = __webpack_require__(5954);
Object.defineProperty(exports, "customizable", ({ enumerable: true, get: function
() { return customizable_1.customizable; } }));
var useCustomizationSettings_1 = __webpack_require__(29640);
Object.defineProperty(exports, "useCustomizationSettings", ({ enumerable: true,
useCustomizationSettings_1.useCustomizationSettings; } }));
var mergeCustomizations_1 = __webpack_require__(8336);
Object.defineProperty(exports, "mergeCustomizations", ({ enumerable: true, get:
function () { return mergeCustomizations_1.mergeCustomizations; } }));
var mergeSettings_1 = __webpack_require__(61);
Object.defineProperty(exports, "mergeScopedSettings", ({ enumerable: true, get:
function () { return mergeSettings_1.mergeScopedSettings; } }));
Object.defineProperty(exports, "mergeSettings", ({ enumerable: true, get: function
() { return mergeSettings_1.mergeSettings; } }));
var dom_1 = __webpack_require__(81022);
function () { return dom_1.DATA_PORTAL_ATTRIBUTE; } }));
function () { return dom_1.elementContains; } }));
get: function () { return dom_1.elementContainsAttribute; } }));
function () { return dom_1.findElementRecursive; } }));
{ return dom_1.getChildren; } }));
{ return dom_1.getDocument; } }));
true, get: function () { return dom_1.getFirstVisibleElementFromSelector; } }));
return dom_1.getParent; } }));
{ return dom_1.getRect; } }));
function () { return dom_1.getVirtualParent; } }));
return dom_1.getWindow; } }));
function () { return dom_1.isVirtualElement; } }));
dom_1.on; } }));
function () { return dom_1.portalContainsElement; } }));
{ return dom_1.raiseClick; } }));
function () { return dom_1.setPortalAttribute; } }));
function () { return dom_1.setVirtualParent; } }));
var extendComponent_1 = __webpack_require__(68425);
Object.defineProperty(exports, "extendComponent", ({ enumerable: true, get:
function () { return extendComponent_1.extendComponent; } }));
var focus_1 = __webpack_require__(78224);
Object.defineProperty(exports, "doesElementContainFocus", ({ enumerable: true, get:
function () { return focus_1.doesElementContainFocus; } }));
Object.defineProperty(exports, "focusAsync", ({ enumerable: true, get: function ()
{ return focus_1.focusAsync; } }));
Object.defineProperty(exports, "focusFirstChild", ({ enumerable: true, get:
function () { return focus_1.focusFirstChild; } }));
Object.defineProperty(exports, "getElementIndexPath", ({ enumerable: true, get:
function () { return focus_1.getElementIndexPath; } }));
Object.defineProperty(exports, "getFirstFocusable", ({ enumerable: true, get:
function () { return focus_1.getFirstFocusable; } }));
Object.defineProperty(exports, "getFirstTabbable", ({ enumerable: true, get:
function () { return focus_1.getFirstTabbable; } }));
Object.defineProperty(exports, "getFocusableByIndexPath", ({ enumerable: true, get:
function () { return focus_1.getFocusableByIndexPath; } }));
Object.defineProperty(exports, "getLastFocusable", ({ enumerable: true, get:
function () { return focus_1.getLastFocusable; } }));
Object.defineProperty(exports, "getLastTabbable", ({ enumerable: true, get:
function () { return focus_1.getLastTabbable; } }));
Object.defineProperty(exports, "getNextElement", ({ enumerable: true, get: function
() { return focus_1.getNextElement; } }));
Object.defineProperty(exports, "getPreviousElement", ({ enumerable: true, get:
function () { return focus_1.getPreviousElement; } }));
Object.defineProperty(exports, "isElementFocusSubZone", ({ enumerable: true, get:
function () { return focus_1.isElementFocusSubZone; } }));
Object.defineProperty(exports, "isElementFocusZone", ({ enumerable: true, get:
function () { return focus_1.isElementFocusZone; } }));
Object.defineProperty(exports, "isElementTabbable", ({ enumerable: true, get:
function () { return focus_1.isElementTabbable; } }));
Object.defineProperty(exports, "isElementVisible", ({ enumerable: true, get:
function () { return focus_1.isElementVisible; } }));
Object.defineProperty(exports, "isElementVisibleAndNotHidden", ({ enumerable: true,
get: function () { return focus_1.isElementVisibleAndNotHidden; } }));
Object.defineProperty(exports, "shouldWrapFocus", ({ enumerable: true, get:
function () { return focus_1.shouldWrapFocus; } }));
var getId_1 = __webpack_require__(77937);
Object.defineProperty(exports, "getId", ({ enumerable: true, get: function ()
{ return getId_1.getId; } }));
Object.defineProperty(exports, "resetIds", ({ enumerable: true, get: function ()
{ return getId_1.resetIds; } }));
var getNativeElementProps_1 = __webpack_require__(38863);
Object.defineProperty(exports, "getNativeElementProps", ({ enumerable: true, get:
function () { return getNativeElementProps_1.getNativeElementProps; } }));
var hoist_1 = __webpack_require__(77998);
Object.defineProperty(exports, "hoistMethods", ({ enumerable: true, get: function
() { return hoist_1.hoistMethods; } }));
Object.defineProperty(exports, "unhoistMethods", ({ enumerable: true, get: function
() { return hoist_1.unhoistMethods; } }));
var hoistStatics_1 = __webpack_require__(47272);
Object.defineProperty(exports, "hoistStatics", ({ enumerable: true, get: function
() { return hoistStatics_1.hoistStatics; } }));
var initializeComponentRef_1 = __webpack_require__(69280);
Object.defineProperty(exports, "initializeComponentRef", ({ enumerable: true, get:
function () { return initializeComponentRef_1.initializeComponentRef; } }));
var initializeFocusRects_1 = __webpack_require__(39514);
Object.defineProperty(exports, "initializeFocusRects", ({ enumerable: true, get:
function () { return initializeFocusRects_1.initializeFocusRects; } }));
var useFocusRects_1 = __webpack_require__(93984);
Object.defineProperty(exports, "FocusRects", ({ enumerable: true, get: function ()
{ return useFocusRects_1.FocusRects; } }));
Object.defineProperty(exports, "useFocusRects", ({ enumerable: true, get: function
() { return useFocusRects_1.useFocusRects; } }));
var initials_1 = __webpack_require__(39629);
Object.defineProperty(exports, "getInitials", ({ enumerable: true, get: function ()
{ return initials_1.getInitials; } }));
var keyboard_1 = __webpack_require__(69889);
Object.defineProperty(exports, "addDirectionalKeyCode", ({ enumerable: true, get:
function () { return keyboard_1.addDirectionalKeyCode; } }));
Object.defineProperty(exports, "isDirectionalKeyCode", ({ enumerable: true, get:
function () { return keyboard_1.isDirectionalKeyCode; } }));
var language_1 = __webpack_require__(84569);
Object.defineProperty(exports, "getLanguage", ({ enumerable: true, get: function ()
{ return language_1.getLanguage; } }));
Object.defineProperty(exports, "setLanguage", ({ enumerable: true, get: function ()
{ return language_1.setLanguage; } }));
var math_1 = __webpack_require__(62607);
Object.defineProperty(exports, "calculatePrecision", ({ enumerable: true, get:
function () { return math_1.calculatePrecision; } }));
Object.defineProperty(exports, "fitContentToBounds", ({ enumerable: true, get:
function () { return math_1.fitContentToBounds; } }));
Object.defineProperty(exports, "getDistanceBetweenPoints", ({ enumerable: true,
get: function () { return math_1.getDistanceBetweenPoints; } }));
Object.defineProperty(exports, "precisionRound", ({ enumerable: true, get: function
() { return math_1.precisionRound; } }));
Object.defineProperty(exports, "createMemoizer", ({ enumerable: true, get: function
() { return memoize_1.createMemoizer; } }));
Object.defineProperty(exports, "memoize", ({ enumerable: true, get: function ()
{ return memoize_1.memoize; } }));
Object.defineProperty(exports, "memoizeFunction", ({ enumerable: true, get:
function () { return memoize_1.memoizeFunction; } }));
Object.defineProperty(exports, "resetMemoizations", ({ enumerable: true, get:
function () { return memoize_1.resetMemoizations; } }));
Object.defineProperty(exports, "setMemoizeWeakMap", ({ enumerable: true, get:
function () { return memoize_1.setMemoizeWeakMap; } }));
var merge_1 = __webpack_require__(60035);
Object.defineProperty(exports, "merge", ({ enumerable: true, get: function ()
{ return merge_1.merge; } }));
var mobileDetector_1 = __webpack_require__(2694);
Object.defineProperty(exports, "isIOS", ({ enumerable: true, get: function ()
{ return mobileDetector_1.isIOS; } }));
var modalize_1 = __webpack_require__(31594);
Object.defineProperty(exports, "modalize", ({ enumerable: true, get: function ()
{ return modalize_1.modalize; } }));
var object_1 = __webpack_require__(28164);
Object.defineProperty(exports, "assign", ({ enumerable: true, get: function ()
{ return object_1.assign; } }));
Object.defineProperty(exports, "filteredAssign", ({ enumerable: true, get: function
() { return object_1.filteredAssign; } }));
Object.defineProperty(exports, "mapEnumByName", ({ enumerable: true, get: function
() { return object_1.mapEnumByName; } }));
Object.defineProperty(exports, "shallowCompare", ({ enumerable: true, get: function
() { return object_1.shallowCompare; } }));
Object.defineProperty(exports, "values", ({ enumerable: true, get: function ()
{ return object_1.values; } }));
Object.defineProperty(exports, "omit", ({ enumerable: true, get: function ()
{ return object_1.omit; } }));
var osDetector_1 = __webpack_require__(5744);
Object.defineProperty(exports, "isMac", ({ enumerable: true, get: function ()
{ return osDetector_1.isMac; } }));
var overflow_1 = __webpack_require__(96430);
Object.defineProperty(exports, "hasHorizontalOverflow", ({ enumerable: true, get:
function () { return overflow_1.hasHorizontalOverflow; } }));
Object.defineProperty(exports, "hasOverflow", ({ enumerable: true, get: function ()
{ return overflow_1.hasOverflow; } }));
Object.defineProperty(exports, "hasVerticalOverflow", ({ enumerable: true, get:
function () { return overflow_1.hasVerticalOverflow; } }));
var properties_1 = __webpack_require__(21850);
Object.defineProperty(exports, "anchorProperties", ({ enumerable: true, get:
function () { return properties_1.anchorProperties; } }));
Object.defineProperty(exports, "audioProperties", ({ enumerable: true, get:
function () { return properties_1.audioProperties; } }));
Object.defineProperty(exports, "baseElementEvents", ({ enumerable: true, get:
function () { return properties_1.baseElementEvents; } }));
Object.defineProperty(exports, "baseElementProperties", ({ enumerable: true, get:
function () { return properties_1.baseElementProperties; } }));
Object.defineProperty(exports, "buttonProperties", ({ enumerable: true, get:
function () { return properties_1.buttonProperties; } }));
Object.defineProperty(exports, "colGroupProperties", ({ enumerable: true, get:
function () { return properties_1.colGroupProperties; } }));
Object.defineProperty(exports, "colProperties", ({ enumerable: true, get: function
() { return properties_1.colProperties; } }));
Object.defineProperty(exports, "divProperties", ({ enumerable: true, get: function
() { return properties_1.divProperties; } }));
Object.defineProperty(exports, "formProperties", ({ enumerable: true, get: function
() { return properties_1.formProperties; } }));
Object.defineProperty(exports, "getNativeProps", ({ enumerable: true, get: function
() { return properties_1.getNativeProps; } }));
Object.defineProperty(exports, "htmlElementProperties", ({ enumerable: true, get:
function () { return properties_1.htmlElementProperties; } }));
Object.defineProperty(exports, "iframeProperties", ({ enumerable: true, get:
function () { return properties_1.iframeProperties; } }));
Object.defineProperty(exports, "imageProperties", ({ enumerable: true, get:
function () { return properties_1.imageProperties; } }));
Object.defineProperty(exports, "imgProperties", ({ enumerable: true, get: function
() { return properties_1.imgProperties; } }));
Object.defineProperty(exports, "inputProperties", ({ enumerable: true, get:
function () { return properties_1.inputProperties; } }));
Object.defineProperty(exports, "labelProperties", ({ enumerable: true, get:
function () { return properties_1.labelProperties; } }));
Object.defineProperty(exports, "liProperties", ({ enumerable: true, get: function
() { return properties_1.liProperties; } }));
Object.defineProperty(exports, "olProperties", ({ enumerable: true, get: function
() { return properties_1.olProperties; } }));
Object.defineProperty(exports, "optionProperties", ({ enumerable: true, get:
function () { return properties_1.optionProperties; } }));
Object.defineProperty(exports, "selectProperties", ({ enumerable: true, get:
function () { return properties_1.selectProperties; } }));
Object.defineProperty(exports, "tableProperties", ({ enumerable: true, get:
function () { return properties_1.tableProperties; } }));
Object.defineProperty(exports, "tdProperties", ({ enumerable: true, get: function
() { return properties_1.tdProperties; } }));
Object.defineProperty(exports, "textAreaProperties", ({ enumerable: true, get:
function () { return properties_1.textAreaProperties; } }));
Object.defineProperty(exports, "thProperties", ({ enumerable: true, get: function
() { return properties_1.thProperties; } }));
Object.defineProperty(exports, "trProperties", ({ enumerable: true, get: function
() { return properties_1.trProperties; } }));
Object.defineProperty(exports, "videoProperties", ({ enumerable: true, get:
function () { return properties_1.videoProperties; } }));
var composeRenderFunction_1 = __webpack_require__(75731);
Object.defineProperty(exports, "composeRenderFunction", ({ enumerable: true, get:
function () { return composeRenderFunction_1.composeRenderFunction; } }));
var resources_1 = __webpack_require__(90103);
Object.defineProperty(exports, "getResourceUrl", ({ enumerable: true, get: function
() { return resources_1.getResourceUrl; } }));
Object.defineProperty(exports, "setBaseUrl", ({ enumerable: true, get: function ()
{ return resources_1.setBaseUrl; } }));
var rtl_1 = __webpack_require__(31820);
Object.defineProperty(exports, "getRTL", ({ enumerable: true, get: function ()
{ return rtl_1.getRTL; } }));
Object.defineProperty(exports, "getRTLSafeKeyCode", ({ enumerable: true, get:
function () { return rtl_1.getRTLSafeKeyCode; } }));
{ return rtl_1.setRTL; } }));
var safeRequestAnimationFrame_1 = __webpack_require__(71976);
Object.defineProperty(exports, "safeRequestAnimationFrame", ({ enumerable: true,
safeRequestAnimationFrame_1.safeRequestAnimationFrame; } }));
var safeSetTimeout_1 = __webpack_require__(38816);
Object.defineProperty(exports, "safeSetTimeout", ({ enumerable: true, get: function
() { return safeSetTimeout_1.safeSetTimeout; } }));
var scroll_1 = __webpack_require__(99264);
Object.defineProperty(exports, "DATA_IS_SCROLLABLE_ATTRIBUTE", ({ enumerable: true,
get: function () { return scroll_1.DATA_IS_SCROLLABLE_ATTRIBUTE; } }));
Object.defineProperty(exports, "allowOverscrollOnElement", ({ enumerable: true,
get: function () { return scroll_1.allowOverscrollOnElement; } }));
Object.defineProperty(exports, "allowScrollOnElement", ({ enumerable: true, get:
function () { return scroll_1.allowScrollOnElement; } }));
Object.defineProperty(exports, "disableBodyScroll", ({ enumerable: true, get:
function () { return scroll_1.disableBodyScroll; } }));
Object.defineProperty(exports, "enableBodyScroll", ({ enumerable: true, get:
function () { return scroll_1.enableBodyScroll; } }));
Object.defineProperty(exports, "findScrollableParent", ({ enumerable: true, get:
function () { return scroll_1.findScrollableParent; } }));
Object.defineProperty(exports, "getScrollbarWidth", ({ enumerable: true, get:
function () { return scroll_1.getScrollbarWidth; } }));
function () { return index_1.SELECTION_CHANGE; } }));
Object.defineProperty(exports, "SELECTION_ITEMS_CHANGE", ({ enumerable: true, get:
function () { return index_1.SELECTION_ITEMS_CHANGE; } }));
return index_1.Selection; } }));
function () { return index_1.SelectionDirection; } }));
() { return index_1.SelectionMode; } }));
var string_1 = __webpack_require__(67722);
Object.defineProperty(exports, "format", ({ enumerable: true, get: function ()
{ return string_1.format; } }));
var styled_1 = __webpack_require__(93085);
Object.defineProperty(exports, "styled", ({ enumerable: true, get: function ()
{ return styled_1.styled; } }));
var warn_1 = __webpack_require__(77060);
function () { return warn_1.resetControlledWarnings; } }));
function () { return warn_1.setWarningCallback; } }));
{ return warn_1.warn; } }));
true, get: function () { return warn_1.warnConditionallyRequiredProps; } }));
function () { return warn_1.warnControlledUsage; } }));
function () { return warn_1.warnDeprecations; } }));
function () { return warn_1.warnMutuallyExclusive; } }));
var ie11Detector_1 = __webpack_require__(24478);
Object.defineProperty(exports, "isIE11", ({ enumerable: true, get: function ()
{ return ie11Detector_1.isIE11; } }));
var getPropsWithDefaults_1 = __webpack_require__(74085);
Object.defineProperty(exports, "getPropsWithDefaults", ({ enumerable: true, get:
function () { return getPropsWithDefaults_1.getPropsWithDefaults; } }));
var setFocusVisibility_1 = __webpack_require__(11795);
Object.defineProperty(exports, "setFocusVisibility", ({ enumerable: true, get:
function () { return setFocusVisibility_1.setFocusVisibility; } }));
Object.defineProperty(exports, "IsFocusVisibleClassName", ({ enumerable: true, get:
function () { return setFocusVisibility_1.IsFocusVisibleClassName; } }));
Object.defineProperty(exports, "setSSR", ({ enumerable: true, get: function ()
{ return setSSR_1.setSSR; } }));
var createMergedRef_1 = __webpack_require__(36694);
Object.defineProperty(exports, "createMergedRef", ({ enumerable: true, get:
function () { return createMergedRef_1.createMergedRef; } }));
var useIsomorphicLayoutEffect_1 = __webpack_require__(60821);
Object.defineProperty(exports, "useIsomorphicLayoutEffect", ({ enumerable: true,
useIsomorphicLayoutEffect_1.useIsomorphicLayoutEffect; } }));
/***/ }),
/***/ 69280:
"use strict";

exports.initializeComponentRef = void 0;
/**
* Helper to manage componentRef resolution. Internally appends logic to
* lifetime methods to resolve componentRef to the passed in object.
*
* Usage: call initializeComponentRef(this) in the constructor,
*/
function initializeComponentRef(obj) {
extendComponent_1.extendComponent(obj, {
componentDidMount: _onMount,
componentDidUpdate: _onUpdate,
componentWillUnmount: _onUnmount,
});
}
exports.initializeComponentRef = initializeComponentRef;
function _onMount() {
_setComponentRef(this.props.componentRef, this);
}
function _onUpdate(prevProps) {
if (prevProps.componentRef !== this.props.componentRef) {
_setComponentRef(prevProps.componentRef, null);
_setComponentRef(this.props.componentRef, this);
}
}
function _onUnmount() {
_setComponentRef(this.props.componentRef, null);
}
function _setComponentRef(componentRef, value) {
if (componentRef) {
if (typeof componentRef === 'object') {
componentRef.current = value;
}
else if (typeof componentRef === 'function') {
componentRef(value);
}
}
}
//# sourceMappingURL=initializeComponentRef.js.map
/***/ }),
/***/ 39514:
"use strict";

exports.initializeFocusRects = void 0;
/**
* Initializes the logic which:
*
* 1. Subscribes keydown and mousedown events. (It will only do it once per window,
* so it's safe to call this method multiple times.)
* 2. When the user presses directional keyboard keys, adds the 'ms-Fabric--
isFocusVisible' classname
* to the document body, removes the 'ms-Fabric-isFocusHidden' classname.
* 3. When the user clicks a mouse button, adds the 'ms-Fabric-isFocusHidden'
classname to the
* document body, removes the 'ms-Fabric--isFocusVisible' classname.
*
* This logic allows components on the page to conditionally render focus
treatments based on
* the existence of global classnames, which simplifies logic overall.
*
* @param window - the window used to add the event listeners
* @deprecated Use useFocusRects hook or FocusRects component instead.
*/
function initializeFocusRects(window) {
var _a;
var win = (window || getWindow_1.getWindow());
if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0 :
_a.disableFocusRects) === true) {
return;
}
if (!win.__hasInitializeFocusRects__) {
win.__hasInitializeFocusRects__ = true;
win.addEventListener('mousedown', _onMouseDown, true);
win.addEventListener('pointerdown', _onPointerDown, true);
win.addEventListener('keydown', _onKeyDown, true);
}
}
exports.initializeFocusRects = initializeFocusRects;
function _onMouseDown(ev) {
setFocusVisibility_1.setFocusVisibility(false, ev.target);
}
function _onPointerDown(ev) {
if (ev.pointerType !== 'mouse') {
}
}
function _onKeyDown(ev) {
keyboard_1.isDirectionalKeyCode(ev.which) &&
setFocusVisibility_1.setFocusVisibility(true, ev.target);
}
//# sourceMappingURL=initializeFocusRects.js.map
/***/ }),
/***/ 39629:
"use strict";
/**
* Regular expressions matching characters to ignore when calculating the initials.
*/
exports.getInitials = void 0;
/**
* Regular expression matching characters within various types of enclosures,
including the enclosures themselves
* so for example, (xyz) [xyz] {xyz} <xyz> all would be ignored
*/
var UNWANTED_ENCLOSURES_REGEX = /[$\[\{\<][^$\]\}\>]*[\)\]\}\>]/g;
/**
* Regular expression matching special ASCII characters except space, plus some
unicode special characters.
* Applies after unwanted enclosures have been removed
*/
var UNWANTED_CHARS_REGEX = /[\0-\u001F\!-/:-@\[-`\{-\u00BF\u0250-\u036F\uD800-\
uFFFF]/g;
/**
* Regular expression matching phone numbers. Applied after chars matching
UNWANTED_CHARS_REGEX have been removed
* and number has been trimmed for whitespaces
*/
var PHONENUMBER_REGEX = /^\d+[\d\s]*(:?ext|x|)\s*\d+$/i;
/** Regular expression matching one or more spaces. */
var MULTIPLE_WHITESPACES_REGEX = /\s+/g;
/**
* Regular expression matching languages for which we currently don't support
initials.
* Arabic: Arabic, Arabic Supplement, Arabic Extended-A.
* Korean: Hangul Jamo, Hangul Compatibility Jamo, Hangul Jamo Extended-A, Hangul
Syllables, Hangul Jamo Extended-B.
* Japanese: Hiragana, Katakana.
* CJK: CJK Unified Ideographs Extension A, CJK Unified Ideographs, CJK
Compatibility Ideographs,
* CJK Unified Ideographs Extension B
*/
var UNSUPPORTED_TEXT_REGEX = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\u1100-\
u11FF\u3130-\u318F\uA960-\uA97F\uAC00-\uD7AF\uD7B0-\uD7FF\u3040-\u309F\u30A0-\
u30FF\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]|[\uD840-\uD869][\uDC00-\uDED6]/;
function getInitialsLatin(displayName, isRtl) {
var initials = '';
var splits = displayName.split(' ');
if (splits.length === 2) {
initials += splits[0].charAt(0).toUpperCase();
}
else if (splits.length === 3) {
}
else if (splits.length !== 0) {
}
if (isRtl && initials.length > 1) {
return initials.charAt(1) + initials.charAt(0);
}
return initials;
}
function cleanupDisplayName(displayName) {
displayName = displayName.replace(UNWANTED_ENCLOSURES_REGEX, '');
displayName = displayName.replace(UNWANTED_CHARS_REGEX, '');
displayName = displayName.replace(MULTIPLE_WHITESPACES_REGEX, ' ');
displayName = displayName.trim();
return displayName;
}
/**
* Get (up to 2 characters) initials based on display name of the persona.
*
* @public
*/
function getInitials(displayName, isRtl, allowPhoneInitials) {
if (!displayName) {
return '';
}
displayName = cleanupDisplayName(displayName);
// For names containing CJK characters, and phone numbers, we don't display
initials
if (UNSUPPORTED_TEXT_REGEX.test(displayName) || (!allowPhoneInitials &&
PHONENUMBER_REGEX.test(displayName))) {
return '';
}
return getInitialsLatin(displayName, isRtl);
}
exports.getInitials = getInitials;
//# sourceMappingURL=initials.js.map
/***/ }),
/***/ 69889:
"use strict";
var _a;
exports.addDirectionalKeyCode = exports.isDirectionalKeyCode = void 0;
var DirectionalKeyCodes = (_a = {},
_a[KeyCodes_1.KeyCodes.up] = 1,
_a[KeyCodes_1.KeyCodes.down] = 1,
_a[KeyCodes_1.KeyCodes.left] = 1,
_a[KeyCodes_1.KeyCodes.right] = 1,
_a[KeyCodes_1.KeyCodes.home] = 1,
_a[KeyCodes_1.KeyCodes.end] = 1,
_a[KeyCodes_1.KeyCodes.tab] = 1,
_a[KeyCodes_1.KeyCodes.pageUp] = 1,
_a[KeyCodes_1.KeyCodes.pageDown] = 1,
_a);
/**
* Returns true if the keycode is a directional keyboard key.
*/
function isDirectionalKeyCode(which) {
return !!DirectionalKeyCodes[which];
}
exports.isDirectionalKeyCode = isDirectionalKeyCode;
/**
* Adds a keycode to the list of keys that, when pressed, should cause the focus
outlines to be visible.
* This can be used to add global shortcut keys that directionally move from
section to section within
* an app or between focus trap zones.
*/
function addDirectionalKeyCode(which) {
DirectionalKeyCodes[which] = 1;
}
exports.addDirectionalKeyCode = addDirectionalKeyCode;
//# sourceMappingURL=keyboard.js.map
/***/ }),
/***/ 84569:
"use strict";

exports.setLanguage = exports.getLanguage = void 0;
var localStorage = __webpack_require__(49038);
var sessionStorage = __webpack_require__(52074);
// Default to undefined so that we initialize on first read.
var _language;
var STORAGE_KEY = 'language';
/**
* Gets the language set for the page.
* @param persistenceType - Where to persist the value. Default is `sessionStorage`
if available.
*/
function getLanguage(persistenceType) {
if (persistenceType === void 0) { persistenceType = 'sessionStorage'; }
if (_language === undefined) {
var doc = getDocument_1.getDocument();
var savedLanguage = persistenceType === 'localStorage'
? localStorage.getItem(STORAGE_KEY)
: persistenceType === 'sessionStorage'
? sessionStorage.getItem(STORAGE_KEY)
: undefined;
if (savedLanguage) {
_language = savedLanguage;
}
if (_language === undefined && doc) {
_language = doc.documentElement.getAttribute('lang');
}
if (_language === undefined) {
_language = 'en';
}
}
return _language;
}
exports.getLanguage = getLanguage;
function setLanguage(language, persistenceParam) {
if (doc) {
doc.documentElement.setAttribute('lang', language);
}
var persistenceType = persistenceParam === true ? 'none' : !persistenceParam ?
'sessionStorage' : persistenceParam;
if (persistenceType === 'localStorage') {
localStorage.setItem(STORAGE_KEY, language);
}
else if (persistenceType === 'sessionStorage') {
sessionStorage.setItem(STORAGE_KEY, language);
}
_language = language;
}
exports.setLanguage = setLanguage;
//# sourceMappingURL=language.js.map
/***/ }),
/***/ 49038:
"use strict";

exports.setItem = exports.getItem = void 0;
/**
* Fetches an item from local storage without throwing an exception
* @param key The key of the item to fetch from local storage
*/
function getItem(key) {
var result = null;
try {
result = win ? win.localStorage.getItem(key) : null;
}
catch (e) {
/* Eat the exception */
}
return result;
}
exports.getItem = getItem;
/**
* Inserts an item into local storage without throwing an exception
* @param key The key of the item to add to local storage
* @param data The data to put into local storage
*/
function setItem(key, data) {
try {
win && win.localStorage.setItem(key, data);
}
catch (e) {
}
}
exports.setItem = setItem;
//# sourceMappingURL=localStorage.js.map
/***/ }),
/***/ 62607:
"use strict";

exports.precisionRound = exports.calculatePrecision = exports.fitContentToBounds =
exports.getDistanceBetweenPoints = void 0;
/**
* Determines the distance between two points.
*
* @public
*/
function getDistanceBetweenPoints(point1, point2) {
var left1 = point1.left || point1.x || 0;
var top1 = point1.top || point1.y || 0;
var left2 = point2.left || point2.x || 0;
var top2 = point2.top || point2.y || 0;
var distance = Math.sqrt(Math.pow(left1 - left2, 2) + Math.pow(top1 - top2,
2));
return distance;
}
exports.getDistanceBetweenPoints = getDistanceBetweenPoints;
/**
* Produces a proportionally-scaled version of an input content size when fit to a
bounding size.
* Given a `contentSize` and a `boundsSize`, this function scales `contentSize`
proportionally
* using either `contain` or `cover` fit behaviors.
* Use this function to pre-calculate the layout for the CSS òbject-fit` and
`background-fit` behaviors.
* With `contain`, the output size must be the largest it can be while completely
within the `boundsSize`.
* With `cover`, the output size must be the smallest it can be while completely
around the `boundsSize`.
* By default, there is a `maxScale` value of 1, which prevents the `contentSize`
from being scaled larger.
*
* @param options - the options for the bounds fit operation
*/
function fitContentToBounds(options) {
var contentSize = options.contentSize, boundsSize = options.boundsSize, _a =
options.mode, mode = _a === void 0 ? 'contain' : _a, _b = options.maxScale,
maxScale = _b === void 0 ? 1 : _b;
var contentAspectRatio = contentSize.width / contentSize.height;
var boundsAspectRatio = boundsSize.width / boundsSize.height;
var scale;
if (mode === 'contain' ? contentAspectRatio > boundsAspectRatio :
contentAspectRatio < boundsAspectRatio) {
scale = boundsSize.width / contentSize.width;
}
else {
scale = boundsSize.height / contentSize.height;
}
var finalScale = Math.min(maxScale, scale);
return {
width: contentSize.width * finalScale,
height: contentSize.height * finalScale,
};
}
exports.fitContentToBounds = fitContentToBounds;
/**
* Calculates a number's precision based on the number of trailing
* zeros if the number does not have a decimal indicated by a negative
* precision. Otherwise, it calculates the number of digits after
* the decimal point indicated by a positive precision.
* @param value - the value to determine the precision of
*/
function calculatePrecision(value) {
/**
* Group 1:
* [1-9]([0]+$) matches trailing zeros
* Group 2:
* \.([0-9]*) matches all digits after a decimal point.
*/
var groups = /[1-9]([0]+$)|\.([0-9]*)/.exec(String(value));
if (!groups) {
return 0;
}
if (groups[1]) {
return -groups[1].length;
}
if (groups[2]) {
return groups[2].length;
}
return 0;
}
exports.calculatePrecision = calculatePrecision;
/**
* Rounds a number to a certain level of precision. Accepts negative precision.
* @param value - The value that is being rounded.
* @param precision - The number of decimal places to round the number to
*/
function precisionRound(value, precision, base) {
if (base === void 0) { base = 10; }
var exp = Math.pow(base, precision);
return Math.round(value * exp) / exp;
}
exports.precisionRound = precisionRound;
//# sourceMappingURL=math.js.map
/***/ }),
/***/ 21519:
"use strict";

exports.createMemoizer = exports.memoizeFunction = exports.memoize =
exports.resetMemoizations = exports.setMemoizeWeakMap = void 0;
var _initializedStylesheetResets = false;
var _resetCounter = 0;
var _emptyObject = { empty: true };
var _dictionary = {};
var _weakMap = typeof WeakMap === 'undefined' ? null : WeakMap;
/**
* Test utility for providing a custom weakmap.
*
* @internal
* */
function setMemoizeWeakMap(weakMap) {
_weakMap = weakMap;
}
exports.setMemoizeWeakMap = setMemoizeWeakMap;
/**
* Reset memoizations.
*/
function resetMemoizations() {
_resetCounter++;
}
exports.resetMemoizations = resetMemoizations;
/**
* Memoize decorator to be used on class methods. WARNING: the `this` reference
* will be inaccessible within a memoized method, given that a cached method's
`this`
* would not be instance-specific.
*
* @public
*/
function memoize(_target, _key, descriptor) {
// We bind to "null" to prevent people from inadvertently pulling values from
"this",
// rather than passing them in as input values which can be memoized.
var fn = memoizeFunction(descriptor.value && descriptor.value.bind(null));
return {
configurable: true,
get: function () {
return fn;
},
};
}
exports.memoize = memoize;
/**
* Memoizes a function; when you pass in the same parameters multiple times, it
returns a cached result.
* Be careful when passing in objects, you need to pass in the same INSTANCE for
caching to work. Otherwise
* it will grow the cache unnecessarily. Also avoid using default values that
evaluate functions; passing in
* undefined for a value and relying on a default function will execute it the
first time, but will not
* re-evaluate subsequent times which may have been unexpected.
*
* By default, the cache will reset after 100 permutations, to avoid abuse cases
where the function is
* unintendedly called with unique objects. Without a reset, the cache could grow
infinitely, so we safeguard
* by resetting. To override this behavior, pass a value of 0 to the maxCacheSize
parameter.
*
* @public
* @param cb - The function to memoize.
* @param maxCacheSize - Max results to cache. If the cache exceeds this value, it
will reset on the next call.
* @param ignoreNullOrUndefinedResult - Flag to decide whether to cache callback
result if it is undefined/null.
* If the flag is set to true, the callback result is recomputed every time till
the callback result is
* not undefined/null for the first time, and then the non-undefined/null version
gets cached.
* @returns A memoized version of the function.
*/
function memoizeFunction(cb, maxCacheSize, ignoreNullOrUndefinedResult) {
if (maxCacheSize === void 0) { maxCacheSize = 100; }
if (ignoreNullOrUndefinedResult === void 0) { ignoreNullOrUndefinedResult =
false; }
// Avoid breaking scenarios which don't have weak map.
if (!_weakMap) {
return cb;
}
if (!_initializedStylesheetResets) {
merge_styles_1.Stylesheet.getInstance().onReset(resetMemoizations);
}
_initializedStylesheetResets = true;
}
var rootNode;
var cacheSize = 0;
var localResetCounter = _resetCounter;
return function memoizedFunction() {
var args = [];
}
var currentNode = rootNode;
if (rootNode === undefined ||
localResetCounter !== _resetCounter ||
(maxCacheSize > 0 && cacheSize > maxCacheSize)) {
rootNode = _createNode();
cacheSize = 0;
localResetCounter = _resetCounter;
}
currentNode = rootNode;
// Traverse the tree until we find the match.
for (var i = 0; i < args.length; i++) {
var arg = _normalizeArg(args[i]);
if (!currentNode.map.has(arg)) {
currentNode.map.set(arg, _createNode());
}
currentNode = currentNode.map.get(arg);
}
if (!currentNode.hasOwnProperty('value')) {
currentNode.value = cb.apply(void 0, args);
cacheSize++;
}
if (ignoreNullOrUndefinedResult && (currentNode.value === null ||
currentNode.value === undefined)) {
currentNode.value = cb.apply(void 0, args);
}
return currentNode.value;
};
}
exports.memoizeFunction = memoizeFunction;
/**
* Creates a memoizer for a single-value function, backed by a WeakMap.
* With a WeakMap, the memoized values are only kept as long as the source objects,
* ensuring that there is no memory leak.
*
* This function assumes that the input values passed to the wrapped function will
be
* `function` or òbject` types. To memoize functions which accept other inputs,
use
* `memoizeFunction`, which memoizes against arbitrary inputs using a lookup cache.
*
* @public
*/
function createMemoizer(getValue) {
if (!_weakMap) {
// Without a `WeakMap` implementation, memoization is not possible.
return getValue;
}
var cache = new _weakMap();
function memoizedGetValue(input) {
if (!input || (typeof input !== 'function' && typeof input !== 'object')) {
// A WeakMap can only be used to test against reference values, i.e.
'function' and 'object'.
// All other inputs cannot be memoized against in this manner.
return getValue(input);
}
if (cache.has(input)) {
return cache.get(input);
}
var value = getValue(input);
cache.set(input, value);
return value;
}
return memoizedGetValue;
}
exports.createMemoizer = createMemoizer;
function _normalizeArg(val) {
if (!val) {
return _emptyObject;
}
else if (typeof val === 'object' || typeof val === 'function') {
return val;
}
else if (!_dictionary[val]) {
_dictionary[val] = { val: val };
}
return _dictionary[val];
}
function _createNode() {
return {
map: _weakMap ? new _weakMap() : null,
};
}
//# sourceMappingURL=memoize.js.map
/***/ }),
/***/ 60035:
"use strict";

exports.merge = void 0;
/**
* Simple deep merge function. Takes all arguments and returns a deep copy of the
objects merged
* together in the order provided. If an object creates a circular reference, it
will assign the
* original reference.
*/
function merge(target) {
var args = [];
}
var arg = args_1[_a];
_merge(target || {}, arg);
}
return target;
}
exports.merge = merge;
/**
* The _merge helper iterates through all props on source and assigns them to
target.
* When the value is an object, we will create a deep clone of the object. However
if
* there is a circular reference, the value will not be deep cloned and will
persist
* the reference.
*/
function _merge(target, source, circularReferences) {
if (circularReferences === void 0) { circularReferences = []; }
circularReferences.push(source);
for (var name_1 in source) {
if (source.hasOwnProperty(name_1)) {
if (name_1 !== '__proto__' && name_1 !== 'constructor' && name_1 !==
'prototype') {
var value = source[name_1];
if (typeof value === 'object' && value !== null && !
Array.isArray(value)) {
var isCircularReference = circularReferences.indexOf(value) > -
1;
target[name_1] = (isCircularReference
? value
: _merge(target[name_1] || {}, value, circularReferences));
}
else {
target[name_1] = value;
}
}
}
}
circularReferences.pop();
return target;
}
//# sourceMappingURL=merge.js.map
/***/ }),
/***/ 2694:
"use strict";

exports.isIOS = void 0;
/**
* Returns true if and only if the user is on a iOS device.
* Used to determine whether iOS-specific behavior should be applied.
*/
var isIOS = function () {
if (!window || !window.navigator || !window.navigator.userAgent) {
return false;
}
return /iPad|iPhone|iPod/i.test(window.navigator.userAgent);
};
exports.isIOS = isIOS;
//# sourceMappingURL=mobileDetector.js.map
/***/ }),
/***/ 31594:
"use strict";
/**
* The helper functions here will make the target element as modal to screen
readers, by placing aria-hidden on elements
* that are siblings to the target element and the target element's ancestors
(because aria-hidden gets inherited).
* That way, all other elements on the page are hidden to the screen reader.
*/
exports.modalize = void 0;
/** Tag names to ignore when modalizing */
var tagsToIgnore = ['TEMPLATE', 'STYLE', 'SCRIPT'];
/**
* Call this on a target element to make it modal to screen readers.
* Returns a function that undoes the changes it made.
*/
function modalize(target) {
var targetDocument = getDocument_1.getDocument(target);
if (!targetDocument) {
// can't do this in SSR
return function () { return undefined; };
}
var affectedNodes = [];
// start at target, then recurse and do the same for parent, until we reach
<body>
while (target !== targetDocument.body && target.parentElement) {
// grab all siblings of current element
for (var _i = 0, _a = target.parentElement.children; _i < _a.length; _i++)
{
var sibling = _a[_i];
// but ignore elements that are already aria-hidden
var ariaHidden = sibling.getAttribute('aria-hidden');
if (sibling !== target && (ariaHidden === null || ariaHidden === void 0
? void 0 : ariaHidden.toLowerCase()) !== 'true' &&
tagsToIgnore.indexOf(sibling.tagName) === -1) {
affectedNodes.push([sibling, ariaHidden]);
}
}
target = target.parentElement;
}
// take all those elements and set aria-hidden=true on them
affectedNodes.forEach(function (_a) {
var node = _a[0];
node.setAttribute('aria-hidden', 'true');
});
unmodalize(affectedNodes);
affectedNodes = []; // dispose
};
}
exports.modalize = modalize;
/**
* Undoes the changes that modalize() did.
*/
function unmodalize(affectedNodes) {
affectedNodes.forEach(function (_a) {
var node = _a[0], originalValue = _a[1];
// Restore the original value (false or unset)
if (originalValue) {
node.setAttribute('aria-hidden', originalValue);
}
else {
node.removeAttribute('aria-hidden');
}
});
}
//# sourceMappingURL=modalize.js.map
/***/ }),
/***/ 28164:
"use strict";

exports.omit = exports.values = exports.mapEnumByName = exports.filteredAssign =
exports.assign = exports.shallowCompare = void 0;
/**
* Compares a to b and b to a.
*
* @public
*/
function shallowCompare(a, b) {
for (var propName in a) {
if (a.hasOwnProperty(propName)) {
if (!b.hasOwnProperty(propName) || b[propName] !== a[propName]) {
return false;
}
}
}
for (var propName in b) {
if (b.hasOwnProperty(propName)) {
if (!a.hasOwnProperty(propName)) {
return false;
}
}
}
return true;
}
exports.shallowCompare = shallowCompare;
/**
* Makes a resulting merge of a bunch of objects. Pass in the target object
followed by 1 or more
* objects as arguments and they will be merged sequentially into the target. Note
that this will
* shallow merge; it will not create new cloned values for target members.
*
* @public
* @param target - Target object to merge following object arguments into.
* @param args - One or more objects that will be mixed into the target in the
order they are provided.
* @returns Resulting merged target.
*/
function assign(target) {
var args = [];
}
return filteredAssign.apply(this, [null, target].concat(args));
}
exports.assign = assign;
/**
* Makes a resulting merge of a bunch of objects, but allows a filter function to
be passed in to filter
* the resulting merges. This allows for scenarios where you want to merge
"everything except that one thing"
* or "properties that start with data-". Note that this will shallow merge; it
will not create new cloned
* values for target members.
*
* @public
* @param isAllowed - Callback to determine if the given propName is allowed in the
result.
* @param target - Target object to merge following object arguments into.
* @param args - One or more objects that will be mixed into the target in the
order they are provided.
* @returns Resulting merged target.
*/
function filteredAssign(isAllowed, target) {
var args = [];
}
target = target || {};
var sourceObject = args_1[_a];
if (sourceObject) {
for (var propName in sourceObject) {
if (sourceObject.hasOwnProperty(propName) && (!isAllowed ||
isAllowed(propName))) {
target[propName] = sourceObject[propName];
}
}
}
}
return target;
}
exports.filteredAssign = filteredAssign;
/**
* Takes an enum and iterates over each value of the enum (as a string), running
the callback on each,
* returning a mapped array.
* @param theEnum - Enum to iterate over
* @param callback - The first parameter the name of the entry, and the second
parameter is the value
* of that entry, which is the value you'd normally use when using the enum
(usually a number).
*/
function mapEnumByName(
theEnum, callback) {
// map<any> to satisfy compiler since it doesn't realize we strip out
undefineds in the .filter() call
return Object.keys(theEnum)
.map(function (p) {
// map on each property name as a string
if (String(Number(p)) !== p) {
// if the property is not just a number (because enums in TypeScript
will map both ways)
return callback(p, theEnum[p]);
}
return undefined;
})
.filter(function (v) { return !!v; }); // only return elements with values
}
exports.mapEnumByName = mapEnumByName;
/**
* Get all values in an object dictionary
*
* @param obj - The dictionary to get values for
*/
function values(obj) {
return Object.keys(obj).reduce(function (arr, key) {
arr.push(obj[key]);
return arr;
}, []);
}
exports.values = values;
/**
* Tiny helper to do the minimal amount of work in duplicating an object but
omitting some
* props. This ends up faster than using object ...rest or reduce to filter.
*
* This behaves very much like filteredAssign, but does not merge many objects
together,
* uses an exclusion object map, and avoids spreads all for optimal performance.
*
* See perf test for background:
* https://jsperf.com/omit-vs-rest-vs-reduce/1
*
* @param obj - The object to clone
* @param exclusions - The array of keys to exclude
*/
function omit(obj, exclusions) {
var result = {};
for (var key in obj) {
if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {
result[key] = obj[key];
}
}
return result;
}
exports.omit = omit;
//# sourceMappingURL=object.js.map
/***/ }),
/***/ 5744:
"use strict";

exports.isMac = void 0;
var isMacResult;
/**
* Returns true if the user is on a Mac. Caches the result value.
* @param reset - Reset the cached result value (mainly for testing).
*/
function isMac(reset) {
var _a;
if (typeof isMacResult === 'undefined' || reset) {
// In certain SSR frameworks, `window` will be defined even on the server
but `navigator` will be undefined
var userAgent = (_a = win === null || win === void 0 ? void 0 :
win.navigator) === null || _a === void 0 ? void 0 : _a.userAgent;
isMacResult = !!userAgent && userAgent.indexOf('Macintosh') !== -1;
}
return !!isMacResult;
}
exports.isMac = isMac;
//# sourceMappingURL=osDetector.js.map
/***/ }),
/***/ 96430:
"use strict";

exports.hasOverflow = exports.hasVerticalOverflow = exports.hasHorizontalOverflow =
void 0;
/**
* Detects whether an element's content has horizontal overflow
*
* @public
* @param element - Element to check for overflow
* @returns True if element's content overflows
*/
function hasHorizontalOverflow(element) {
return element.clientWidth < element.scrollWidth;
}
exports.hasHorizontalOverflow = hasHorizontalOverflow;
/**
* Detects whether an element's content has vertical overflow
*
* @public
*/
function hasVerticalOverflow(element) {
return element.clientHeight < element.scrollHeight;
}
exports.hasVerticalOverflow = hasVerticalOverflow;
/**
* Detects whether an element's content has overflow in any direction
*
* @public
*/
function hasOverflow(element) {
return hasHorizontalOverflow(element) || hasVerticalOverflow(element);
}
exports.hasOverflow = hasOverflow;
//# sourceMappingURL=overflow.js.map
/***/ }),
/***/ 21850:
"use strict";

exports.getNativeProps = exports.divProperties = exports.imageProperties =
exports.imgProperties = exports.iframeProperties = exports.formProperties =
exports.colProperties = exports.colGroupProperties = exports.tdProperties =
exports.thProperties = exports.trProperties = exports.tableProperties =
exports.optionProperties = exports.selectProperties = exports.textAreaProperties =
exports.inputProperties = exports.buttonProperties = exports.anchorProperties =
exports.liProperties = exports.olProperties = exports.videoProperties =
exports.audioProperties = exports.labelProperties = exports.htmlElementProperties =
exports.baseElementProperties = exports.baseElementEvents = void 0;
var toObjectMap = function () {
var items = [];
items[_i] = arguments[_i];
}
var result = {};
for (var _a = 0, items_1 = items; _a < items_1.length; _a++) {
var item = items_1[_a];
var keys = Array.isArray(item) ? item : Object.keys(item);
for (var _b = 0, keys_1 = keys; _b < keys_1.length; _b++) {
var key = keys_1[_b];
result[key] = 1;
}
}
return result;
};
/**
* An array of events that are allowed on every html element type.
*
* @public
*/
exports.baseElementEvents = toObjectMap([
'onCopy',
'onCut',
'onPaste',
'onCompositionEnd',
'onCompositionStart',
'onCompositionUpdate',
'onFocus',
'onFocusCapture',
'onBlur',
'onBlurCapture',
'onChange',
'onInput',
'onSubmit',
'onLoad',
'onError',
'onKeyDown',
'onKeyDownCapture',
'onKeyPress',
'onKeyUp',
'onAbort',
'onCanPlay',
'onCanPlayThrough',
'onDurationChange',
'onEmptied',
'onEncrypted',
'onEnded',
'onLoadedData',
'onLoadedMetadata',
'onLoadStart',
'onPause',
'onPlay',
'onPlaying',
'onProgress',
'onRateChange',
'onSeeked',
'onSeeking',
'onStalled',
'onSuspend',
'onTimeUpdate',
'onVolumeChange',
'onWaiting',
'onClick',
'onClickCapture',
'onContextMenu',
'onDoubleClick',
'onDrag',
'onDragEnd',
'onDragEnter',
'onDragExit',
'onDragLeave',
'onDragOver',
'onDragStart',
'onDrop',
'onMouseDown',
'onMouseDownCapture',
'onMouseEnter',
'onMouseLeave',
'onMouseMove',
'onMouseOut',
'onMouseOver',
'onMouseUp',
'onMouseUpCapture',
'onSelect',
'onTouchCancel',
'onTouchEnd',
'onTouchMove',
'onTouchStart',
'onScroll',
'onWheel',
'onPointerCancel',
'onPointerDown',
'onPointerEnter',
'onPointerLeave',
'onPointerMove',
'onPointerOut',
'onPointerOver',
'onPointerUp',
'onGotPointerCapture',
'onLostPointerCapture',
]);
/**
* An array of element attributes which are allowed on every html element type.
*
* @public
*/
exports.baseElementProperties = toObjectMap([
'accessKey',
'children',
'className',
'contentEditable',
'dir',
'draggable',
'hidden',
'htmlFor',
'id',
'lang',
'ref',
'role',
'style',
'tabIndex',
'title',
'translate',
'spellCheck',
'name', // global
]);
/**
* An array of HTML element properties and events.
*
* @public
*/
exports.htmlElementProperties = toObjectMap(exports.baseElementProperties,
exports.baseElementEvents);
/**
* An array of LABEL tag properties and events.
*
* @public
*/
exports.labelProperties = toObjectMap(exports.htmlElementProperties, [
'form', // button, fieldset, input, label, meter, object, output, select,
textarea
]);
/**
* An array of AUDIO tag properties and events.
* @public
*/
exports.audioProperties = toObjectMap(exports.htmlElementProperties, [
'height',
'loop',
'muted',
'preload',
'src',
'width', // canvas, embed, iframe, img, input, object, video
]);
/**
* An array of VIDEO tag properties and events.
*
* @public
*/
exports.videoProperties = toObjectMap(exports.audioProperties, [
'poster', // video
]);
/**
* An array of OL tag properties and events.
*
* @public
*/
exports.olProperties = toObjectMap(exports.htmlElementProperties, [
'start', // ol
]);
/**
* An array of LI tag properties and events.
*
* @public
*/
exports.liProperties = toObjectMap(exports.htmlElementProperties, [
'value', // button, input, li, option, meter, progress, param
]);
/**
* An array of A tag properties and events.
*
* @public
*/
exports.anchorProperties = toObjectMap(exports.htmlElementProperties, [
'download',
'href',
'hrefLang',
'media',
'rel',
'target',
'type', // a, button, input, link, menu, object, script, source, style
]);
/**
* An array of BUTTON tag properties and events.
*
* @public
*/
exports.buttonProperties = toObjectMap(exports.htmlElementProperties, [
'autoFocus',
'disabled',
'form',
'formAction',
'formEncType',
'formMethod',
'formNoValidate',
'formTarget',
'type',
'value', // button, input, li, option, meter, progress, param,
]);
/**
* An array of INPUT tag properties and events.
*
* @public
*/
exports.inputProperties = toObjectMap(exports.buttonProperties, [
'accept',
'alt',
'autoCapitalize',
'autoComplete',
'checked',
'dirname',
'form',
'height',
'inputMode',
'list',
'max',
'maxLength',
'min',
'minLength',
'multiple',
'pattern',
'placeholder',
'readOnly',
'required',
'src',
'step',
'size',
'type',
'value',
]);
/**
* An array of TEXTAREA tag properties and events.
*
* @public
*/
exports.textAreaProperties = toObjectMap(exports.buttonProperties, [
'autoCapitalize',
'cols',
'dirname',
'form',
'maxLength',
'minLength',
'placeholder',
'readOnly',
'required',
'rows',
'wrap', // textarea
]);
/**
* An array of SELECT tag properties and events.
*
* @public
*/
exports.selectProperties = toObjectMap(exports.buttonProperties, [
'form',
'multiple',
'required', // input, select, textarea
]);
exports.optionProperties = toObjectMap(exports.htmlElementProperties, [
'selected',
'value', // button, input, li, option, meter, progress, param
]);
/**
* An array of TABLE tag properties and events.
*
* @public
*/
exports.tableProperties = toObjectMap(exports.htmlElementProperties, [
'cellPadding',
'cellSpacing', // table
]);
/**
* An array of TR tag properties and events.
*
* @public
*/
exports.trProperties = exports.htmlElementProperties;
/**
* An array of TH tag properties and events.
*
* @public
*/
exports.thProperties = toObjectMap(exports.htmlElementProperties, [
'rowSpan',
'scope', // th
]);
/**
* An array of TD tag properties and events.
*
* @public
*/
exports.tdProperties = toObjectMap(exports.htmlElementProperties, [
'colSpan',
'headers',
'rowSpan',
'scope', // th
]);
exports.colGroupProperties = toObjectMap(exports.htmlElementProperties, [
'span', // col, colgroup
]);
exports.colProperties = toObjectMap(exports.htmlElementProperties, [
'span', // col, colgroup
]);
/**
* An array of FORM tag properties and events.
*
* @public
*/
exports.formProperties = toObjectMap(exports.htmlElementProperties, [
'acceptCharset',
'action',
'encType',
'encType',
'method',
'noValidate',
'target', // form
]);
/**
* An array of IFRAME tag properties and events.
*
* @public
*/
exports.iframeProperties = toObjectMap(exports.htmlElementProperties, [
'allow',
'allowFullScreen',
'allowPaymentRequest',
'allowTransparency',
'csp',
'height',
'importance',
'referrerPolicy',
'sandbox',
'src',
'srcDoc',
'width', // canvas, embed, iframe, img, input, object, video,
]);
/**
* An array of IMAGE tag properties and events.
*
* @public
*/
exports.imgProperties = toObjectMap(exports.htmlElementProperties, [
'alt',
'crossOrigin',
'height',
'src',
'srcSet',
'useMap',
]);
/**
* @deprecated Use imgProperties for img elements.
*/
exports.imageProperties = exports.imgProperties;
/**
* An array of DIV tag properties and events.
*
* @public
*/
exports.divProperties = exports.htmlElementProperties;
/**
* Gets native supported props for an html element provided the allowance set. Use
one of the property
* sets defined (divProperties, buttonPropertes, etc) to filter out supported
properties from a given
* props set. Note that all data- and aria- prefixed attributes will be allowed.
* NOTE: getNativeProps should always be applied first when adding props to a react
component. The
* non-native props should be applied second. This will prevent getNativeProps from
overriding your custom props.
* For example, if props passed to getNativeProps has an onClick function and
getNativeProps is added to
* the component after an onClick function is added, then the getNativeProps
onClick will override it.
*
* @public
* @param props - The unfiltered input props
* @param allowedPropsNames - The array or record of allowed prop names.
* @returns The filtered props
*/
function getNativeProps(
props, allowedPropNames, excludedPropNames) {
// It'd be great to properly type this while allowing 'aria-` and 'data-'
attributes like TypeScript does for
// JSX attributes, but that ability is hardcoded into the TS compiler with no
analog in TypeScript typings.
// Then we'd be able to enforce props extends native props (including aria- and
data- attributes), and then
// return native props.
// We should be able to do this once this PR is merged:
https://github.com/microsoft/TypeScript/pull/26797
var isArray = Array.isArray(allowedPropNames);
var result = {};
var keys = Object.keys(props);
for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
var key = keys_2[_i];
var isNativeProp = (!isArray && allowedPropNames[key]) ||
(isArray && allowedPropNames.indexOf(key) >= 0) ||
key.indexOf('data-') === 0 ||
key.indexOf('aria-') === 0;
if (isNativeProp && (!excludedPropNames || (excludedPropNames === null ||
excludedPropNames === void 0 ? void 0 : excludedPropNames.indexOf(key)) === -1)) {
result[key] = props[key];
}
}
return result;
}
exports.getNativeProps = getNativeProps;
//# sourceMappingURL=properties.js.map
/***/ }),
/***/ 75731:
"use strict";

exports.composeRenderFunction = void 0;
function createComposedRenderFunction(outer) {
var outerMemoizer = memoize_1.createMemoizer(function (inner) {
var innerMemoizer = memoize_1.createMemoizer(function (defaultRender) {
return function (innerProps) {
return inner(innerProps, defaultRender);
};
});
return function (outerProps, defaultRender) {
return outer(outerProps, defaultRender ? innerMemoizer(defaultRender) :
inner);
};
});
return outerMemoizer;
}
var memoizer = memoize_1.createMemoizer(createComposedRenderFunction);
/**
* Composes two 'render functions' to produce a final render function that renders
* the outer function, passing the inner function as 'default render'. The inner
function
* is then passed the original 'default render' prop.
* @public
*/
function composeRenderFunction(outer, inner) {
return memoizer(outer)(inner);
}
exports.composeRenderFunction = composeRenderFunction;
//# sourceMappingURL=composeRenderFunction.js.map
/***/ }),
/***/ 90103:
"use strict";

exports.setBaseUrl = exports.getResourceUrl = void 0;
var _baseUrl = '';
/**
* @deprecated Unused as of version 8
*/
function getResourceUrl(url) {
return _baseUrl + url;
}
exports.getResourceUrl = getResourceUrl;
/**
* @deprecated Unused as of version 8
*/
function setBaseUrl(baseUrl) {
_baseUrl = baseUrl;
}
exports.setBaseUrl = setBaseUrl;
//# sourceMappingURL=resources.js.map
/***/ }),
/***/ 31820:
"use strict";

exports.getRTLSafeKeyCode = exports.setRTL = exports.getRTL = void 0;
var sessionStorage_1 = __webpack_require__(52074);
var RTL_LOCAL_STORAGE_KEY = 'isRTL';
// Default to undefined so that we initialize on first read.
var _isRTL;
/**
* Gets the rtl state of the page (returns true if in rtl.)
*/
function getRTL(theme) {
if (theme.rtl !== undefined) {
return theme.rtl;
}
if (_isRTL === undefined) {
// Fabric supports persisting the RTL setting between page refreshes via
session storage
var savedRTL = sessionStorage_1.getItem(RTL_LOCAL_STORAGE_KEY);
if (savedRTL !== null) {
_isRTL = savedRTL === '1';
setRTL(_isRTL);
}
if (_isRTL === undefined && doc) {
_isRTL = ((doc.body && doc.body.getAttribute('dir')) ||
doc.documentElement.getAttribute('dir')) === 'rtl';
merge_styles_1.setRTL(_isRTL);
}
}
return !!_isRTL;
}
exports.getRTL = getRTL;
/**
* Sets the rtl state of the page (by adjusting the dir attribute of the html
element.)
*/
function setRTL(isRTL, persistSetting) {
if (persistSetting === void 0) { persistSetting = false; }
if (doc) {
doc.documentElement.setAttribute('dir', isRTL ? 'rtl' : 'ltr');
}
if (persistSetting) {
sessionStorage_1.setItem(RTL_LOCAL_STORAGE_KEY, isRTL ? '1' : '0');
}
_isRTL = isRTL;
merge_styles_1.setRTL(_isRTL);
}
exports.setRTL = setRTL;
/**
* Returns the given key, but flips right/left arrows if necessary.
*/
function getRTLSafeKeyCode(key, theme) {
if (getRTL(theme)) {
if (key === KeyCodes_1.KeyCodes.left) {
key = KeyCodes_1.KeyCodes.right;
}
else if (key === KeyCodes_1.KeyCodes.right) {
key = KeyCodes_1.KeyCodes.left;
}
}
return key;
}
exports.getRTLSafeKeyCode = getRTLSafeKeyCode;
//# sourceMappingURL=rtl.js.map
/***/ }),
/***/ 71976:
"use strict";

exports.safeRequestAnimationFrame = void 0;
/**
* Generates a function to be attached to a React component, which can be called
* as a replacement to RAF. In-flight async calls will be auto canceled if the
component
* is unmounting before the async code is executed, preventing bugs where code
* accesses things within the component after being unmounted.
*/
var safeRequestAnimationFrame = function (component) {
var activeTimeouts;
return function (cb) {
if (!activeTimeouts) {
activeTimeouts = new Set();
extendComponent_1.extendComponent(component, {
componentWillUnmount: function () {
activeTimeouts.forEach(function (id) { return
cancelAnimationFrame(id); });
},
});
}
var timeoutId = requestAnimationFrame(function () {
activeTimeouts.delete(timeoutId);
cb();
});
activeTimeouts.add(timeoutId);
};
};
exports.safeRequestAnimationFrame = safeRequestAnimationFrame;
//# sourceMappingURL=safeRequestAnimationFrame.js.map
/***/ }),
/***/ 38816:
"use strict";

exports.safeSetTimeout = void 0;
/**
* Generates a function to be attached to a React component, which can be called
* as a replacement to setTimeout. In-flight async calls will be auto canceled if
the component
* is unmounting before the async code is executed, preventing bugs where code
* accesses things within the component after being unmounted.
*/
var safeSetTimeout = function (component) {
var activeTimeouts;
return function (cb, duration) {
if (!activeTimeouts) {
activeTimeouts = new Set();
extendComponent_1.extendComponent(component, {
componentWillUnmount: function () {
activeTimeouts.forEach(function (id) { return clearTimeout(id);
});
},
});
}
var timeoutId = setTimeout(function () {
activeTimeouts.delete(timeoutId);
cb();
}, duration);
activeTimeouts.add(timeoutId);
};
};
exports.safeSetTimeout = safeSetTimeout;
//# sourceMappingURL=safeSetTimeout.js.map
/***/ }),
/***/ 99264:
"use strict";

exports.findScrollableParent = exports.getScrollbarWidth = exports.enableBodyScroll
= exports.disableBodyScroll = exports.allowOverscrollOnElement =
exports.allowScrollOnElement = exports.DATA_IS_SCROLLABLE_ATTRIBUTE = void 0;
var _scrollbarWidth;
var _bodyScrollDisabledCount = 0;
var DisabledScrollClassName = merge_styles_1.mergeStyles({
overflow: 'hidden !important',
});
/**
* Placing this attribute on scrollable divs optimizes detection to know
* if the div is scrollable or not (given we can avoid expensive operations
* like getComputedStyle.)
*
* @public
*/
exports.DATA_IS_SCROLLABLE_ATTRIBUTE = 'data-is-scrollable';
/**
* Allows the user to scroll within a element,
* while preventing the user from scrolling the body
*/
var allowScrollOnElement = function (element, events) {
if (!element) {
return;
}
var _previousClientY = 0;
var _element = null;
// remember the clientY for future calls of _preventOverscrolling
var _saveClientY = function (event) {
if (event.targetTouches.length === 1) {
_previousClientY = event.targetTouches[0].clientY;
}
};
// prevent the body from scrolling when the user attempts
// to scroll past the top or bottom of the element
var _preventOverscrolling = function (event) {
// only respond to a single-finger touch
if (event.targetTouches.length !== 1) {
return;
}
// prevent the body touchmove handler from firing
// so that scrolling is allowed within the element
if (!_element) {
return;
}
var clientY = event.targetTouches[0].clientY - _previousClientY;
var scrollableParent = findScrollableParent(event.target);
if (scrollableParent) {
_element = scrollableParent;
}
// if the element is scrolled to the top,
// prevent the user from scrolling up
if (_element.scrollTop === 0 && clientY > 0) {
}
// if the element is scrolled to the bottom,
// prevent the user from scrolling down
if (_element.scrollHeight - Math.ceil(_element.scrollTop) <=
_element.clientHeight && clientY < 0) {
}
};
events.on(element, 'touchstart', _saveClientY, { passive: false });
events.on(element, 'touchmove', _preventOverscrolling, { passive: false });
_element = element;
};
exports.allowScrollOnElement = allowScrollOnElement;
/**
* Same as allowScrollOnElement but does not prevent overscrolling.
*/
var allowOverscrollOnElement = function (element, events) {
if (!element) {
return;
}
var _allowElementScroll = function (event) {
};
events.on(element, 'touchmove', _allowElementScroll, { passive: false });
};
exports.allowOverscrollOnElement = allowOverscrollOnElement;
var _disableIosBodyScroll = function (event) {
};
/**
* Disables the body scrolling.
*
* @public
*/
function disableBodyScroll() {
if (doc && doc.body && !_bodyScrollDisabledCount) {
doc.body.classList.add(DisabledScrollClassName);
doc.body.addEventListener('touchmove', _disableIosBodyScroll, { passive:
false, capture: false });
}
_bodyScrollDisabledCount++;
}
exports.disableBodyScroll = disableBodyScroll;
/**
* Enables the body scrolling.
*
* @public
*/
function enableBodyScroll() {
if (_bodyScrollDisabledCount > 0) {
if (doc && doc.body && _bodyScrollDisabledCount === 1) {
doc.body.classList.remove(DisabledScrollClassName);
doc.body.removeEventListener('touchmove', _disableIosBodyScroll);
}
_bodyScrollDisabledCount--;
}
}
exports.enableBodyScroll = enableBodyScroll;
/**
* Calculates the width of a scrollbar for the browser/os.
*
* @public
*/
function getScrollbarWidth() {
if (_scrollbarWidth === undefined) {
var scrollDiv = document.createElement('div');
scrollDiv.style.setProperty('width', '100px');
scrollDiv.style.setProperty('height', '100px');
scrollDiv.style.setProperty('overflow', 'scroll');
scrollDiv.style.setProperty('position', 'absolute');
scrollDiv.style.setProperty('top', '-9999px');
document.body.appendChild(scrollDiv);
// Get the scrollbar width
_scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
// Delete the DIV
document.body.removeChild(scrollDiv);
}
return _scrollbarWidth;
}
exports.getScrollbarWidth = getScrollbarWidth;
/**
* Traverses up the DOM for the element with the data-is-scrollable=true attribute,
or returns
* document.body.
*
* @public
*/
function findScrollableParent(startingElement) {
var el = startingElement;
var doc = getDocument_1.getDocument(startingElement);
// First do a quick scan for the scrollable attribute.
while (el && el !== doc.body) {
if (el.getAttribute(exports.DATA_IS_SCROLLABLE_ATTRIBUTE) === 'true') {
return el;
}
el = el.parentElement;
}
// If we haven't found it, the use the slower method: compute styles to
evaluate if overflow is set.
el = startingElement;
while (el && el !== doc.body) {
if (el.getAttribute(exports.DATA_IS_SCROLLABLE_ATTRIBUTE) !== 'false') {
var computedStyles = getComputedStyle(el);
var overflowY = computedStyles ?
computedStyles.getPropertyValue('overflow-y') : '';
if (overflowY && (overflowY === 'scroll' || overflowY === 'auto')) {
return el;
}
}
el = el.parentElement;
}
// Fall back to window scroll.
if (!el || el === doc.body) {
el = getWindow_1.getWindow(startingElement);
}
return el;
}
exports.findScrollableParent = findScrollableParent;
//# sourceMappingURL=scroll.js.map
/***/ }),
/***/ 75455:
"use strict";

exports.Selection = void 0;
var Selection_types_1 = __webpack_require__(20430);
/**
*/
var Selection = /** @class */ (function () {
/**
* Create a new Selection. If `TItem` does not have a `key` property, you must
provide an options
* object with a `getKey` implementation. Providing options is optional
otherwise.
* (At most one òptions` object is accepted.)
*/
function Selection() {
var options = []; // Otherwise, arguments require options with `getKey`.
for (var _i = 0 // Otherwise, arguments require options with `getKey`.
; _i < arguments.length // Otherwise, arguments require options with
`getKey`.
; _i++ // Otherwise, arguments require options with `getKey`.
) {
options[_i] = arguments[_i]; // Otherwise, arguments require options
with `getKey`.
}
var _a = options[0] || {}, onSelectionChanged = _a.onSelectionChanged,
onItemsChanged = _a.onItemsChanged, getKey = _a.getKey, _b = _a.canSelectItem,
canSelectItem = _b === void 0 ? function () { return true; } : _b, items =
_a.items, _c = _a.selectionMode, selectionMode = _c === void 0 ?
Selection_types_1.SelectionMode.multiple : _c;
this.mode = selectionMode;
this._getKey = getKey || defaultGetKey;
this._changeEventSuppressionCount = 0;
this._exemptedCount = 0;
this._anchoredIndex = 0;
this._unselectableCount = 0;
this._onSelectionChanged = onSelectionChanged;
this._onItemsChanged = onItemsChanged;
this._canSelectItem = canSelectItem;
this._keyToIndexMap = {};
this._isModal = false;
this.setItems(items || [], true);
this.count = this.getSelectedCount();
}
Selection.prototype.canSelectItem = function (item, index) {
if (typeof index === 'number' && index < 0) {
return false;
}
return this._canSelectItem(item, index);
};
Selection.prototype.getKey = function (item, index) {
var key = this._getKey(item, index);
return typeof key === 'number' || key ? "" + key : '';
};
Selection.prototype.setChangeEvents = function (isEnabled, suppressChange) {
this._changeEventSuppressionCount += isEnabled ? -1 : 1;
if (this._changeEventSuppressionCount === 0 && this._hasChanged) {
this._hasChanged = false;
if (!suppressChange) {
this._change();
}
}
};
Selection.prototype.isModal = function () {
return this._isModal;
};
Selection.prototype.setModal = function (isModal) {
if (this._isModal !== isModal) {
this.setChangeEvents(false);
this._isModal = isModal;
if (!isModal) {
this.setAllSelected(false);
}
this._change();
this.setChangeEvents(true);
}
};
/**
* Selection needs the items, call this method to set them. If the set
* of items is the same, this will re-evaluate selection and index maps.
* Otherwise, shouldClear should be set to true, so that selection is
* cleared.
*/
Selection.prototype.setItems = function (items, shouldClear) {
if (shouldClear === void 0) { shouldClear = true; }
var newKeyToIndexMap = {};
var newUnselectableIndices = {};
var hasSelectionChanged = false;
// Reset the unselectable count.
this._unselectableCount = 0;
var haveItemsChanged = false;
// Build lookup table for quick selection evaluation.
var item = items[i];
if (item) {
var key = this.getKey(item, i);
if (key) {
if (!haveItemsChanged && (!(key in this._keyToIndexMap) ||
this._keyToIndexMap[key] !== i)) {
haveItemsChanged = true;
}
newKeyToIndexMap[key] = i;
}
}
newUnselectableIndices[i] = item && !this.canSelectItem(item);
if (newUnselectableIndices[i]) {
this._unselectableCount++;
}
}
if (shouldClear || items.length === 0) {
this._setAllSelected(false, true);
}
// Check the exemption list for discrepencies.
var newExemptedIndicies = {};
var newExemptedCount = 0;
for (var indexProperty in this._exemptedIndices) {
if (this._exemptedIndices.hasOwnProperty(indexProperty)) {
var index = Number(indexProperty);
var item = this._items[index];
var exemptKey = item ? this.getKey(item, Number(index)) :
undefined;
var newIndex = exemptKey ? newKeyToIndexMap[exemptKey] : index;
if (newIndex === undefined) {
// The item has likely been replaced or removed.
hasSelectionChanged = true;
}
else {
// We know the new index of the item. update the existing
exemption table.
newExemptedIndicies[newIndex] = true;
newExemptedCount++;
hasSelectionChanged = hasSelectionChanged || newIndex !==
index;
}
}
}
if (this._items && this._exemptedCount === 0 && items.length !==
this._items.length && this._isAllSelected) {
// If everything was selected but the number of items has changed,
selection has changed.
hasSelectionChanged = true;
}
if (!haveItemsChanged) {
for (var _i = 0, _a = Object.keys(this._keyToIndexMap); _i < _a.length;
_i++) {
var key = _a[_i];
if (!(key in newKeyToIndexMap)) {
haveItemsChanged = true;
break;
}
}
}
this._exemptedIndices = newExemptedIndicies;
this._exemptedCount = newExemptedCount;
this._keyToIndexMap = newKeyToIndexMap;
this._unselectableIndices = newUnselectableIndices;
this._items = items;
this._selectedItems = null;
if (hasSelectionChanged) {
this._updateCount();
}
if (haveItemsChanged) {
EventGroup_1.EventGroup.raise(this,
Selection_types_1.SELECTION_ITEMS_CHANGE);
if (this._onItemsChanged) {
this._onItemsChanged();
}
}
if (hasSelectionChanged) {
this._change();
}
};
Selection.prototype.getItems = function () {
return this._items;
};
Selection.prototype.getSelection = function () {
if (!this._selectedItems) {
this._selectedItems = [];
var items = this._items;
if (items) {
if (this.isIndexSelected(i)) {
this._selectedItems.push(items[i]);
}
}
}
}
return this._selectedItems;
};
Selection.prototype.getSelectedCount = function () {
return this._isAllSelected
? this._items.length - this._exemptedCount - this._unselectableCount
: this._exemptedCount;
};
Selection.prototype.getSelectedIndices = function () {
if (!this._selectedIndices) {
this._selectedIndices = [];
var items = this._items;
if (items) {
if (this.isIndexSelected(i)) {
this._selectedIndices.push(i);
}
}
}
}
return this._selectedIndices;
};
Selection.prototype.getItemIndex = function (key) {
var index = this._keyToIndexMap[key];
return index !== null && index !== void 0 ? index : -1;
};
Selection.prototype.isRangeSelected = function (fromIndex, count) {
if (count === 0) {
return false;
}
var endIndex = fromIndex + count;
for (var i = fromIndex; i < endIndex; i++) {
if (!this.isIndexSelected(i)) {
return false;
}
}
return true;
};
Selection.prototype.isAllSelected = function () {
var selectableCount = this._items.length - this._unselectableCount;
// In single mode, we can only have a max of 1 item.
if (this.mode === Selection_types_1.SelectionMode.single) {
selectableCount = Math.min(selectableCount, 1);
}
return ((this.count > 0 && this._isAllSelected && this._exemptedCount ===
0) ||
(!this._isAllSelected && this._exemptedCount === selectableCount &&
selectableCount > 0));
};
Selection.prototype.isKeySelected = function (key) {
return this.isIndexSelected(index);
};
Selection.prototype.isIndexSelected = function (index) {
return !!((this.count > 0 && this._isAllSelected && !
this._exemptedIndices[index] && !this._unselectableIndices[index]) ||
(!this._isAllSelected && this._exemptedIndices[index]));
};
Selection.prototype.setAllSelected = function (isAllSelected) {
if (isAllSelected && this.mode !==
Selection_types_1.SelectionMode.multiple) {
return;
}
var selectableCount = this._items ? this._items.length -
this._unselectableCount : 0;
if (selectableCount > 0 && (this._exemptedCount > 0 || isAllSelected !==
this._isAllSelected)) {
this._exemptedIndices = {};
if (isAllSelected !== this._isAllSelected || this._exemptedCount > 0) {
this._isAllSelected = isAllSelected;
this._change();
}
}
};
Selection.prototype.setKeySelected = function (key, isSelected, shouldAnchor) {
if (index >= 0) {
this.setIndexSelected(index, isSelected, shouldAnchor);
}
};
Selection.prototype.setIndexSelected = function (index, isSelected,
shouldAnchor) {
if (this.mode === Selection_types_1.SelectionMode.none) {
return;
}
// Clamp the index.
index = Math.min(Math.max(0, index), this._items.length - 1);
// No-op on out of bounds selections.
if (index < 0 || index >= this._items.length) {
return;
}
var isExempt = this._exemptedIndices[index];
var canSelect = !this._unselectableIndices[index];
if (canSelect) {
if (isSelected && this.mode === Selection_types_1.SelectionMode.single)
{
// If this is single-select, the previous selection should be
removed.
}
// Determine if we need to remove the exemption.
if (isExempt && ((isSelected && this._isAllSelected) || (!isSelected &&
!this._isAllSelected))) {
delete this._exemptedIndices[index];
this._exemptedCount--;
}
// Determine if we need to add the exemption.
if (!isExempt && ((isSelected && !this._isAllSelected) || (!isSelected
&& this._isAllSelected))) {
this._exemptedIndices[index] = true;
this._exemptedCount++;
}
if (shouldAnchor) {
this._anchoredIndex = index;
}
}
};
Selection.prototype.selectToKey = function (key, clearSelection) {
this.selectToIndex(this._keyToIndexMap[key], clearSelection);
};
Selection.prototype.selectToIndex = function (index, clearSelection) {
return;
}
if (this.mode === Selection_types_1.SelectionMode.single) {
this.setIndexSelected(index, true, true);
return;
}
var anchorIndex = this._anchoredIndex || 0;
var startIndex = Math.min(index, anchorIndex);
var endIndex = Math.max(index, anchorIndex);
if (clearSelection) {
}
for (; startIndex <= endIndex; startIndex++) {
this.setIndexSelected(startIndex, true, false);
}
};
Selection.prototype.toggleAllSelected = function () {
this.setAllSelected(!this.isAllSelected());
};
Selection.prototype.toggleKeySelected = function (key) {
this.setKeySelected(key, !this.isKeySelected(key), true);
};
Selection.prototype.toggleIndexSelected = function (index) {
this.setIndexSelected(index, !this.isIndexSelected(index), true);
};
Selection.prototype.toggleRangeSelected = function (fromIndex, count) {
return;
}
var isRangeSelected = this.isRangeSelected(fromIndex, count);
var endIndex = fromIndex + count;
if (this.mode === Selection_types_1.SelectionMode.single && count > 1) {
return;
}
for (var i = fromIndex; i < endIndex; i++) {
this.setIndexSelected(i, !isRangeSelected, false);
}
};
Selection.prototype._updateCount = function (preserveModalState) {
if (preserveModalState === void 0) { preserveModalState = false; }
var count = this.getSelectedCount();
if (count !== this.count) {
this.count = count;
this._change();
}
if (!this.count && !preserveModalState) {
this.setModal(false);
}
};
Selection.prototype._setAllSelected = function (isAllSelected,
preserveModalState) {
if (preserveModalState === void 0) { preserveModalState = false; }
if (isAllSelected && this.mode !==
Selection_types_1.SelectionMode.multiple) {
return;
}
var selectableCount = this._items ? this._items.length -
this._unselectableCount : 0;
if (selectableCount > 0 && (this._exemptedCount > 0 || isAllSelected !==
this._isAllSelected)) {
this._exemptedIndices = {};
if (isAllSelected !== this._isAllSelected || this._exemptedCount > 0) {
this._isAllSelected = isAllSelected;
this._change();
}
this._updateCount(preserveModalState);
}
};
Selection.prototype._change = function () {
if (this._changeEventSuppressionCount === 0) {
this._selectedItems = null;
this._selectedIndices = undefined;
EventGroup_1.EventGroup.raise(this,
Selection_types_1.SELECTION_CHANGE);
if (this._onSelectionChanged) {
this._onSelectionChanged();
}
}
else {
this._hasChanged = true;
}
};
return Selection;
}());
exports.Selection = Selection;
function defaultGetKey(item, index) {
// 0 may be used as a key
var _a = (item || {}).key, key = _a === void 0 ? "" + index : _a;
return key;
}
/***/ }),
/***/ 20430:
"use strict";

exports.SelectionDirection = exports.SelectionMode = exports.SELECTION_ITEMS_CHANGE
= exports.SELECTION_CHANGE = void 0;
exports.SELECTION_CHANGE = 'change';
exports.SELECTION_ITEMS_CHANGE = 'items-change';
/**
*/
var SelectionMode;
(function (SelectionMode) {
SelectionMode[SelectionMode["none"] = 0] = "none";
SelectionMode[SelectionMode["single"] = 1] = "single";
SelectionMode[SelectionMode["multiple"] = 2] = "multiple";
})(SelectionMode = exports.SelectionMode || (exports.SelectionMode = {}));
/**
*/
var SelectionDirection;
(function (SelectionDirection) {
SelectionDirection[SelectionDirection["horizontal"] = 0] = "horizontal";
SelectionDirection[SelectionDirection["vertical"] = 1] = "vertical";
})(SelectionDirection = exports.SelectionDirection || (exports.SelectionDirection =
{}));
//# sourceMappingURL=Selection.types.js.map
/***/ }),
/***/ 6772:
"use strict";

exports.Selection = exports.SelectionMode = exports.SelectionDirection =
exports.SELECTION_ITEMS_CHANGE = exports.SELECTION_CHANGE = void 0;
var Selection_types_1 = __webpack_require__(20430);
function () { return Selection_types_1.SELECTION_CHANGE; } }));
Object.defineProperty(exports, "SELECTION_ITEMS_CHANGE", ({ enumerable: true, get:
function () { return Selection_types_1.SELECTION_ITEMS_CHANGE; } }));
function () { return Selection_types_1.SelectionDirection; } }));
() { return Selection_types_1.SelectionMode; } }));
return Selection_1.Selection; } }));
/***/ }),
/***/ 52074:
"use strict";

exports.setItem = exports.getItem = void 0;
/**
* Fetches an item from session storage without throwing an exception
* @param key The key of the item to fetch from session storage
*/
function getItem(key) {
var result = null;
try {
result = win ? win.sessionStorage.getItem(key) : null;
}
catch (e) {
}
return result;
}
exports.getItem = getItem;
/**
* Inserts an item into session storage without throwing an exception
* @param key The key of the item to add to session storage
* @param data The data to put into session storage
*/
function setItem(key, data) {
var _a;
try {
(_a = getWindow_1.getWindow()) === null || _a === void 0 ? void 0 :
_a.sessionStorage.setItem(key, data);
}
catch (e) {
}
}
exports.setItem = setItem;
//# sourceMappingURL=sessionStorage.js.map
/***/ }),
/***/ 11795:
"use strict";

exports.setFocusVisibility = exports.IsFocusHiddenClassName =
exports.IsFocusVisibleClassName = void 0;
exports.IsFocusVisibleClassName = 'ms-Fabric--isFocusVisible';
exports.IsFocusHiddenClassName = 'ms-Fabric--isFocusHidden';
/**
* Sets the visibility of focus styling.
*
* By default, focus styles (the box surrounding a focused Button, for example)
only show up when navigational
* keypresses occur (through Tab, arrows, PgUp/PgDn, Home and End), and are hidden
when mouse interactions occur.
* This API provides an imperative way to turn them on/off.
*
* A use case might be when you have a keypress like ctrl-f6 navigate to a
particular region on the page,
* and want focus to show up.
*
* @param enabled - whether to remove or add focus
* @param target - optional target
*/
function setFocusVisibility(enabled, target) {
var win = target ? getWindow_1.getWindow(target) : getWindow_1.getWindow();
if (win) {
var classList = win.document.body.classList;
classList.add(enabled ? exports.IsFocusVisibleClassName :
exports.IsFocusHiddenClassName);
classList.remove(enabled ? exports.IsFocusHiddenClassName :
exports.IsFocusVisibleClassName);
}
}
exports.setFocusVisibility = setFocusVisibility;
//# sourceMappingURL=setFocusVisibility.js.map
/***/ }),
/***/ 67722:
"use strict";

exports.format = void 0;
// Regex that finds { and } so they can be removed on a lookup for string format
var FORMAT_ARGS_REGEX = /[\{\}]/g;
// Regex that finds {#} so it can be replaced by the arguments in string format
var FORMAT_REGEX = /\{\d+\}/g;
/**
* String format method, used for scenarios where at runtime you
* need to evaluate a formatted string given a tokenized string. This
* usually only is needed in localization scenarios.
* @example
* ```tsx
* "I love {0} every {1}".format("CXP")
* ```
* will result in a Debug Exception.
*
* @public
*/
function format(s) {
var values = [];
values[_i - 1] = arguments[_i];
}
var args = values;
// Callback match function
function replaceFunc(match) {
// looks up in the args
var replacement = args[match.replace(FORMAT_ARGS_REGEX, '')];
// catches undefined in nondebug and null in debug and nondebug
if (replacement === null || replacement === undefined) {
replacement = '';
}
return replacement;
}
return s.replace(FORMAT_REGEX, replaceFunc);
}
exports.format = format;
//# sourceMappingURL=string.js.map
/***/ }),
/***/ 93085:
"use strict";

exports.styled = void 0;
var useCustomizationSettings_1 = __webpack_require__(29640);
var DefaultFields = ['theme', 'styles'];
function styled(Component, baseStyles, getProps, customizable, pure) {
customizable = customizable || { scope: '', fields: undefined };
var scope = customizable.scope, _a = customizable.fields, fields = _a === void
0 ? DefaultFields : _a;
var Wrapped = React.forwardRef(function (props, forwardedRef) {
var styles = React.useRef();
var settings = useCustomizationSettings_1.useCustomizationSettings(fields,
scope);
var customizedStyles = settings.styles, dir = settings.dir, rest =
tslib_1.__rest(settings, ["styles", "dir"]);
var additionalProps = getProps ? getProps(props) : undefined;
var cache = (styles.current && styles.current.__cachedInputs__) || [];
var propStyles = props.styles;
if (!styles.current || customizedStyles !== cache[1] || propStyles !==
cache[2]) {
// Using styled components as the Component arg will result in nested
styling arrays.
// The function can be cached and in order to prevent the props from
being retained within it's closure
// we pass in just the styles and not the entire props
var concatenatedStyles = function (styleProps) {
return merge_styles_1.concatStyleSetsWithProps(styleProps,
baseStyles, customizedStyles, propStyles);
};
// The __cachedInputs__ array is attached to the function and consumed
by the
// classNamesFunction as a list of keys to include for memoizing
classnames.
concatenatedStyles.__cachedInputs__ = [
baseStyles,
customizedStyles,
propStyles,
];
concatenatedStyles.__noStyleOverride__ =
!customizedStyles && !propStyles;
styles.current = concatenatedStyles;
}
return React.createElement(Component, tslib_1.__assign({ ref:
forwardedRef }, rest, additionalProps, props, { styles: styles.current }));
});
// Function.prototype.name is an ES6 feature, so the cast to any is required
until we're
// able to drop IE 11 support and compile with ES6 libs
Wrapped.displayName = "Styled" + (Component.displayName || Component.name);
// This preserves backwards compatibility.
var pureComponent = pure ? React.memo(Wrapped) : Wrapped;
// Check if the wrapper has a displayName after it has been memoized. Then
assign it to the pure component.
if (Wrapped.displayName) {
pureComponent.displayName = Wrapped.displayName;
}
return pureComponent;
}
exports.styled = styled;
//# sourceMappingURL=styled.js.map
/***/ }),
/***/ 93984:
"use strict";

exports.FocusRects = exports.useFocusRects = void 0;
/**
* Counter for mounted component that uses focus rectangle.
* We want to cleanup the listners before last component that uses focus rectangle
unmounts.
*/
var mountCounters = new WeakMap();
function setMountCounters(key, delta) {
var newValue;
var currValue = mountCounters.get(key);
if (currValue) {
newValue = currValue + delta;
}
else {
newValue = 1;
}
mountCounters.set(key, newValue);
return newValue;
}
/**
* Initializes the logic which:
*
* 1. Subscribes keydown and mousedown events. (It will only do it once per window,
* so it's safe to call this method multiple times.)
* 2. When the user presses directional keyboard keys, adds the 'ms-Fabric--
isFocusVisible' classname
* to the document body, removes the 'ms-Fabric-isFocusHidden' classname.
* 3. When the user clicks a mouse button, adds the 'ms-Fabric-isFocusHidden'
classname to the
* document body, removes the 'ms-Fabric--isFocusVisible' classname.
*
* This logic allows components on the page to conditionally render focus
treatments based on
* the existence of global classnames, which simplifies logic overall.
*
* @param rootRef - A Ref object. Focus rectangle can be applied on itself and all
its children.
*/
function useFocusRects(rootRef) {
var _a;
var win = getWindow_1.getWindow(rootRef === null || rootRef === void 0 ?
void 0 : rootRef.current);
if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0 :
_a.disableFocusRects) === true) {
return undefined;
}
var count = setMountCounters(win, 1);
if (count <= 1) {
win.addEventListener('mousedown', _onMouseDown, true);
win.addEventListener('pointerdown', _onPointerDown, true);
win.addEventListener('keydown', _onKeyDown, true);
}
var _a;
if (!win || ((_a = win.FabricConfig) === null || _a === void 0 ? void 0
: _a.disableFocusRects) === true) {
return;
}
count = setMountCounters(win, -1);
if (count === 0) {
win.removeEventListener('mousedown', _onMouseDown, true);
win.removeEventListener('pointerdown', _onPointerDown, true);
win.removeEventListener('keydown', _onKeyDown, true);
}
};
}, [rootRef]);
}
exports.useFocusRects = useFocusRects;
/**
* Function Component wrapper which enables calling ùseFocusRects` hook.
* Renders nothing.
*/
var FocusRects = function (props) {
useFocusRects(props.rootRef);
return null;
};
exports.FocusRects = FocusRects;
function _onMouseDown(ev) {
}
function _onPointerDown(ev) {
if (ev.pointerType !== 'mouse') {
}
}
function _onKeyDown(ev) {
if (keyboard_1.isDirectionalKeyCode(ev.which)) {
setFocusVisibility_1.setFocusVisibility(true, ev.target);
}
}
//# sourceMappingURL=useFocusRects.js.map
/***/ }),
/***/ 60821:
"use strict";

exports.useIsomorphicLayoutEffect = void 0;
// This hook must live in @fluentui/utilities because _isSSR is not exported
/**
* React currently throws a warning when using ùseLayoutEffect` on the server. To
get around it,
* this hook calls ùseEffect` on the server (no-op) and ùseLayoutEffect` in the
browser.
*
* Prefer ùseEffect` unless you have a specific need to do something after mount
and before paint,
* such as to avoid a render flash for certain operations.
*
* Server-side rendering is detected based on `setSSR` from `@fluentui/utilities`.
*
* https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
*
https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEff
ect.js
*/
// eslint-disable-next-line no-restricted-properties
exports.useIsomorphicLayoutEffect = setSSR_1._isSSR ? React.useEffect :
React.useLayoutEffect;
//# sourceMappingURL=useIsomorphicLayoutEffect.js.map
/***/ }),
/***/ 91913:
"use strict";

set_version_1.setVersion('@fluentui/utilities', '8.8.3');
/***/ }),
/***/ 77060:
"use strict";

exports.warnMutuallyExclusive = exports.warnDeprecations =
exports.warnControlledUsage = exports.resetControlledWarnings =
exports.warnConditionallyRequiredProps = exports.warn = exports.setWarningCallback
= void 0;
function () { return warn_1.setWarningCallback; } }));
{ return warn_1.warn; } }));
var warnConditionallyRequiredProps_1 = __webpack_require__(9931);
warnConditionallyRequiredProps_1.warnConditionallyRequiredProps; } }));
var warnControlledUsage_1 = __webpack_require__(10156);
function () { return warnControlledUsage_1.resetControlledWarnings; } }));
function () { return warnControlledUsage_1.warnControlledUsage; } }));
var warnDeprecations_1 = __webpack_require__(68100);
function () { return warnDeprecations_1.warnDeprecations; } }));
var warnMutuallyExclusive_1 = __webpack_require__(17269);
function () { return warnMutuallyExclusive_1.warnMutuallyExclusive; } }));
//# sourceMappingURL=warn.js.map
/***/ }),
/***/ 91077:
"use strict";
/* eslint-disable no-console */
exports.setWarningCallback = exports.warn = void 0;
var _warningCallback = undefined;
/**
* Sends a warning to console, if the api is present.
*
* @public
* @param message - Warning message.
*/
function warn(message) {
if (_warningCallback && "production" !== 'production') {}
else if (console && console.warn) {
console.warn(message);
}
}
exports.warn = warn;
/**
* Configures the warning callback. Passing in undefined will reset it to use the
default
* console.warn function.
*
* @public
* @param warningCallback - Callback to override the generated warnings.
*/
function setWarningCallback(warningCallback) {
_warningCallback = warningCallback;
}
exports.setWarningCallback = setWarningCallback;
//# sourceMappingURL=warn.js.map
/***/ }),
/***/ 9931:
"use strict";

exports.warnConditionallyRequiredProps = void 0;
/**
* Warns when props are required if a condition is met.
*
* @public
* @param componentName - The name of the component being used.
* @param props - The props passed into the component.
* @param requiredProps - The name of the props that are required when the
condition is met.
* @param conditionalPropName - The name of the prop that the condition is based
on.
* @param condition - Whether the condition is met.
*/
function warnConditionallyRequiredProps(componentName, props, requiredProps,
conditionalPropName, condition) {
if (condition === true && "production" !== 'production') { var
requiredPropName, _i, requiredProps_1; }
}
exports.warnConditionallyRequiredProps = warnConditionallyRequiredProps;
//# sourceMappingURL=warnConditionallyRequiredProps.js.map
/***/ }),
/***/ 10156:
"use strict";

exports.warnControlledUsage = exports.resetControlledWarnings = void 0;
var controlled_1 = __webpack_require__(54206);
var warningsMap;
if (false) {}
/** Reset controlled usage warnings for testing purposes. */
function resetControlledWarnings() {
if (false) {}
}
exports.resetControlledWarnings = resetControlledWarnings;
/**
* Check for and warn on the following error conditions with a form component:
* - A value prop is provided (indicated it's being used as controlled) without a
change handler,
* and the component is not read-only
* - Both the value and defaultValue props are provided
* - The component is attempting to switch between controlled and uncontrolled
*
* The messages mimic the warnings React gives for these error conditions on input
elements.
* The warning will only be displayed once per component ID.
*/
function warnControlledUsage(params) {
if (false) { var warnMap, newType, oldType, defaultValue, isReadOnly,
hasOnChange, newIsControlled, oldIsControlled, componentId, componentName,
defaultValueProp, props, oldProps, onChangeProp, readOnlyProp, valueProp; }
}
exports.warnControlledUsage = warnControlledUsage;
//# sourceMappingURL=warnControlledUsage.js.map
/***/ }),
/***/ 68100:
"use strict";

exports.warnDeprecations = void 0;
/**
* Warns when a deprecated props are being used.
*
* @public
* @param deprecationMap - The map of deprecations, where key is the prop name and
the value is
* either null or a replacement prop name.
*/
function warnDeprecations(componentName, props, deprecationMap) {
if (false) { var replacementPropName, deprecationMessage, propName; }
}
exports.warnDeprecations = warnDeprecations;
//# sourceMappingURL=warnDeprecations.js.map
/***/ }),
/***/ 17269:
"use strict";

exports.warnMutuallyExclusive = void 0;
/**
* Warns when two props which are mutually exclusive are both being used.
*
* @public
* @param exclusiveMap - A map where the key is a parameter, and the value is the
other parameter.
*/
function warnMutuallyExclusive(componentName, props, exclusiveMap) {
if (false) { var propInExclusiveMapValue, propName; }
}
exports.warnMutuallyExclusive = warnMutuallyExclusive;
//# sourceMappingURL=warnMutuallyExclusive.js.map
/***/ }),
/***/ 7465:
"use strict";
/******************************************************************************
***************************************************************************** */

b; }) ||
};
__());
}

s = arguments[i];
s[p];
}
return t;
}
}
var t = {};
< 0)
t[p] = s[p];
t[p[i]] = s[p[i]];
}
return t;
}

}

}

}

{ reject(e); } }
});
}

t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
}

}
o[k2] = m[k];
});
}
next: function () {
}
};
defined.");
}
if (!m) return o;
try {
}
finally {
try {
}
}
return ar;
}
/** @deprecated */
return ar;
}
/** @deprecated */
r[k] = a[j];
return r;
}

i++) {
ar[i] = from[i];
}
}
}
}

defined.");
e); } }
[1]); }
}
var i, p;
}
defined.");
}

return cooked;
};

o["default"] = v;
};
var result = {};
return result;
}
}

without a getter");
}

without a setter");
}

}
/***/ }),
/***/ 38660:
"use strict";
/* harmony export */ "clearStyles": () => (/* binding */ clearStyles),
/* harmony export */ "configureLoadStyles": () => (/* binding */
configureLoadStyles),
/* harmony export */ "configureRunMode": () => (/* binding */ configureRunMode),
/* harmony export */ "detokenize": () => (/* binding */ detokenize),
/* harmony export */ "flush": () => (/* binding */ flush),
/* harmony export */ "loadStyles": () => (/* binding */ loadStyles),
/* harmony export */ "loadTheme": () => (/* binding */ loadTheme),
/* harmony export */ "splitStyles": () => (/* binding */ splitStyles)
// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT
license.
// See LICENSE in the project root for license information.
var __assign = (undefined && undefined.__assign) || function () {
__assign = Object.assign || function(t) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
};
// Store the theming state in __themeState__ global scope for reuse in the case of
duplicate
// load-themed-styles hosted on the page.
var _root = typeof window === 'undefined' ? __webpack_require__.g : window; //
eslint-disable-line @typescript-eslint/no-explicit-any
// Nonce string to inject into script tag if one provided. This is used in CSP
(Content Security Policy).
var _styleNonce = _root && _root.CSPSettings && _root.CSPSettings.nonce;
var _themeState = initializeThemeState();
/**
* Matches theming tokens. For example, "[theme: themeSlotName, default: #FFF]"
(including the quotes).
*/
var _themeTokenRegex = /[\'\"]\[theme:\s*(\w+)\s*(?:\,\s*default:\s*([\\"\']?[\.\,\
(\)\#\-\s\w]*[\.\,\#\-\w][\"\']?))?\s*\][\'\"]/g;
var now = function () {
return typeof performance !== 'undefined' && !!performance.now ?
performance.now() : Date.now();
};
function measure(func) {
var start = now();
func();
var end = now();
_themeState.perf.duration += end - start;
}
/**
* initialize global state object
*/
function initializeThemeState() {
var state = _root.__themeState__ || {
theme: undefined,
lastStyleElement: undefined,
registeredStyles: []
};
if (!state.runState) {
state = __assign(__assign({}, state), { perf: {
count: 0,
duration: 0
}, runState: {
flushTimer: 0,
mode: 0 /* sync */,
buffer: []
} });
}
if (!state.registeredThemableStyles) {
state = __assign(__assign({}, state), { registeredThemableStyles: [] });
}
_root.__themeState__ = state;
return state;
}
/**
* Loads a set of style text. If it is registered too early, we will register it
when the window.load
* event is fired.
* @param {string | ThemableArray} styles Themable style text to register.
* @param {boolean} loadAsync When true, always load styles in async mode,
irrespective of current sync mode.
*/
function loadStyles(styles, loadAsync) {
if (loadAsync === void 0) { loadAsync = false; }
measure(function () {
var styleParts = Array.isArray(styles) ? styles : splitStyles(styles);
var _a = _themeState.runState, mode = _a.mode, buffer = _a.buffer,
flushTimer = _a.flushTimer;
if (loadAsync || mode === 1 /* async */) {
buffer.push(styleParts);
if (!flushTimer) {
_themeState.runState.flushTimer = asyncLoadStyles();
}
}
else {
applyThemableStyles(styleParts);
}
});
}
/**
* Allows for customizable loadStyles logic. e.g. for server side rendering
application
* @param {(processedStyles: string, rawStyles?: string | ThemableArray) => void}
* a loadStyles callback that gets called when styles are loaded or reloaded
*/
function configureLoadStyles(loadStylesFn) {
_themeState.loadStyles = loadStylesFn;
}
/**
* Configure run mode of load-themable-styles
* @param mode load-themable-styles run mode, async or sync
*/
function configureRunMode(mode) {
_themeState.runState.mode = mode;
}
/**
* external code can call flush to synchronously force processing of currently
buffered styles
*/
function flush() {
measure(function () {
var styleArrays = _themeState.runState.buffer.slice();
_themeState.runState.buffer = [];
var mergedStyleArray = [].concat.apply([], styleArrays);
if (mergedStyleArray.length > 0) {
applyThemableStyles(mergedStyleArray);
}
});
}
/**
* register async loadStyles
*/
function asyncLoadStyles() {
return setTimeout(function () {
_themeState.runState.flushTimer = 0;
flush();
}, 0);
}
/**
* Loads a set of style text. If it is registered too early, we will register it
when the window.load event
* is fired.
* @param {string} styleText Style to register.
* @param {IStyleRecord} styleRecord Existing style record to re-apply.
*/
function applyThemableStyles(stylesArray, styleRecord) {
if (_themeState.loadStyles) {
_themeState.loadStyles(resolveThemableArray(stylesArray).styleString,
stylesArray);
}
else {
registerStyles(stylesArray);
}
}
/**
* Registers a set theme tokens to find and replace. If styles were already
registered, they will be
* replaced.
* @param {theme} theme JSON object of theme tokens to values.
*/
function loadTheme(theme) {
_themeState.theme = theme;
// reload styles.
reloadStyles();
}
/**
* Clear already registered style elements and style records in theme_State object
* @param option - specify which group of registered styles should be cleared.
* Default to be both themable and non-themable styles will be cleared
*/
function clearStyles(option) {
if (option === void 0) { option = 3 /* all */; }
if (option === 3 /* all */ || option === 2 /* onlyNonThemable */) {
clearStylesInternal(_themeState.registeredStyles);
_themeState.registeredStyles = [];
}
if (option === 3 /* all */ || option === 1 /* onlyThemable */) {
clearStylesInternal(_themeState.registeredThemableStyles);
_themeState.registeredThemableStyles = [];
}
}
function clearStylesInternal(records) {
records.forEach(function (styleRecord) {
var styleElement = styleRecord && styleRecord.styleElement;
if (styleElement && styleElement.parentElement) {
styleElement.parentElement.removeChild(styleElement);
}
});
}
/**
* Reloads styles.
*/
function reloadStyles() {
if (_themeState.theme) {
var themableStyles = [];
for (var _i = 0, _a = _themeState.registeredThemableStyles; _i < _a.length;
_i++) {
var styleRecord = _a[_i];
themableStyles.push(styleRecord.themableStyle);
}
if (themableStyles.length > 0) {
clearStyles(1 /* onlyThemable */);
applyThemableStyles([].concat.apply([], themableStyles));
}
}
}
/**
* Find theme tokens and replaces them with provided theme values.
* @param {string} styles Tokenized styles to fix.
*/
function detokenize(styles) {
if (styles) {
styles = resolveThemableArray(splitStyles(styles)).styleString;
}
return styles;
}
/**
* Resolves ThemingInstruction objects in an array and joins the result into a
string.
* @param {ThemableArray} splitStyleArray ThemableArray to resolve and join.
*/
function resolveThemableArray(splitStyleArray) {
var theme = _themeState.theme;
var themable = false;
// Resolve the array of theming instructions to an array of strings.
// Then join the array to produce the final CSS string.
var resolvedArray = (splitStyleArray || []).map(function (currentValue) {
var themeSlot = currentValue.theme;
if (themeSlot) {
themable = true;
// A theming annotation. Resolve it.
var themedValue = theme ? theme[themeSlot] : undefined;
var defaultValue = currentValue.defaultValue || 'inherit';
// Warn to console if we hit an unthemed value even when themes are
provided, but only if "DEBUG" is true.
// Allow the themedValue to be undefined to explicitly request the
default value.
if (theme &&
!themedValue &&
console &&
!(themeSlot in theme) &&
typeof DEBUG !== 'undefined' &&
DEBUG) {
console.warn("Theming value not provided for \"".concat(themeSlot,
"\". Falling back to \"").concat(defaultValue, "\"."));
}
return themedValue || defaultValue;
}
else {
// A non-themable string. Preserve it.
return currentValue.rawString;
}
});
return {
styleString: resolvedArray.join(''),
themable: themable
};
}
/**
* Split tokenized CSS into an array of strings and theme specification objects
* @param {string} styles Tokenized styles to split.
*/
function splitStyles(styles) {
var result = [];
if (styles) {
var pos = 0; // Current position in styles.
var tokenMatch = void 0;
while ((tokenMatch = _themeTokenRegex.exec(styles))) {
var matchIndex = tokenMatch.index;
if (matchIndex > pos) {
result.push({
rawString: styles.substring(pos, matchIndex)
});
}
result.push({
theme: tokenMatch[1],
defaultValue: tokenMatch[2] // May be undefined
});
// index of the first character after the current match
pos = _themeTokenRegex.lastIndex;
}
// Push the rest of the string after the last match.
result.push({
rawString: styles.substring(pos)
});
}
return result;
}
/**
* Registers a set of style text. If it is registered too early, we will register
it when the
* window.load event is fired.
* @param {ThemableArray} styleArray Array of IThemingInstruction objects to
register.
* @param {IStyleRecord} styleRecord May specify a style Element to update.
*/
function registerStyles(styleArray) {
if (typeof document === 'undefined') {
return;
}
var head = document.getElementsByTagName('head')[0];
var styleElement = document.createElement('style');
var _a = resolveThemableArray(styleArray), styleString = _a.styleString,
themable = _a.themable;
styleElement.setAttribute('data-load-themed-styles', 'true');
if (_styleNonce) {
styleElement.setAttribute('nonce', _styleNonce);
}
styleElement.appendChild(document.createTextNode(styleString));
_themeState.perf.count++;
head.appendChild(styleElement);
var ev = document.createEvent('HTMLEvents');
ev.initEvent('styleinsert', true /* bubbleEvent */, false /* cancelable */);
ev.args = {
newStyle: styleElement
};
document.dispatchEvent(ev);
var record = {
styleElement: styleElement,
themableStyle: styleArray
};
if (themable) {
_themeState.registeredThemableStyles.push(record);
}
else {
_themeState.registeredStyles.push(record);
}
}
/***/ }),
/***/ 54680:
"use strict";
// ESM COMPAT FLAG
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
"MiddlewareArray": () => (/* binding */ MiddlewareArray),
"TaskAbortError": () => (/* binding */ TaskAbortError),
"__DO_NOT_USE__ActionTypes": () => (/* reexport */ ActionTypes),
"addListener": () => (/* binding */ addListener),
"applyMiddleware": () => (/* reexport */ applyMiddleware),
"bindActionCreators": () => (/* reexport */ bindActionCreators),
"clearAllListeners": () => (/* binding */ clearAllListeners),
"combineReducers": () => (/* reexport */ combineReducers),
"compose": () => (/* reexport */ compose),
"configureStore": () => (/* binding */ configureStore),
"createAction": () => (/* binding */ createAction),
"createAsyncThunk": () => (/* binding */ createAsyncThunk),
"createDraftSafeSelector": () => (/* binding */ createDraftSafeSelector),
"createEntityAdapter": () => (/* binding */ createEntityAdapter),
"createImmutableStateInvariantMiddleware": () => (/* binding */
createImmutableStateInvariantMiddleware),
"createListenerMiddleware": () => (/* binding */ createListenerMiddleware),
"createNextState": () => (/* reexport */ immer_esm),
"createReducer": () => (/* binding */ createReducer),
"createSelector": () => (/* reexport */ es/* createSelector */.P1),
"createSerializableStateInvariantMiddleware": () => (/* binding */
createSerializableStateInvariantMiddleware),
"createSlice": () => (/* binding */ createSlice),
"createStore": () => (/* reexport */ createStore),
"current": () => (/* reexport */ D),
"findNonSerializableValue": () => (/* binding */ findNonSerializableValue),
"freeze": () => (/* reexport */ d),
"getDefaultMiddleware": () => (/* binding */ getDefaultMiddleware),
"getType": () => (/* binding */ getType),
"isAllOf": () => (/* binding */ isAllOf),
"isAnyOf": () => (/* binding */ isAnyOf),
"isAsyncThunkAction": () => (/* binding */ isAsyncThunkAction),
"isDraft": () => (/* reexport */ t),
"isFulfilled": () => (/* binding */ isFulfilled),
"isImmutableDefault": () => (/* binding */ isImmutableDefault),
"isPending": () => (/* binding */ isPending),
"isPlain": () => (/* binding */ isPlain),
"isPlainObject": () => (/* binding */ redux_toolkit_esm_isPlainObject),
"isRejected": () => (/* binding */ isRejected),
"isRejectedWithValue": () => (/* binding */ isRejectedWithValue),
"miniSerializeError": () => (/* binding */ miniSerializeError),
"nanoid": () => (/* binding */ nanoid),
"original": () => (/* reexport */ e),
"removeListener": () => (/* binding */ removeListener),
"unwrapResult": () => (/* binding */ unwrapResult)
});
;// CONCATENATED MODULE: ./node_modules/immer/dist/immer.esm.js

function n(n){for(var t=arguments.length,r=Array(t>1?t-1:0),e=1;e<t;e++)r[e-
1]=arguments[e];if(false){ var i, o; }throw Error("[Immer] minified error nr: "+n+
(r.length?" "+r.map((function(n){return"'"+n+"'"})).join(","):"")+". Find the full
error at: https://bit.ly/3cXEKWf")}function t(n){return!!n&&!!n[Q]}function r(n)
{return!!n&&(function(n){if(!n||"object"!=typeof n)return!1;var
t=Object.getPrototypeOf(n);if(null===t)return!0;var
r=Object.hasOwnProperty.call(t,"constructor")&&t.constructor;return
r===Object||"function"==typeof r&&Function.toString.call(r)===Z}(n)||
Array.isArray(n)||!!n[L]||!!n.constructor[L]||s(n)||v(n))}function e(r){return
t(r)||n(23,r),r[Q].t}function i(n,t,r){void 0===r&&(r=!1),0===o(n)?(r?
Object.keys:nn)(n).forEach((function(e){r&&"symbol"==typeof e||
t(e,n[e],n)})):n.forEach((function(r,e){return t(e,r,n)}))}function o(n){var
t=n[Q];return t?t.i>3?t.i-4:t.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,t)
{return 2===o(n)?n.has(t):Object.prototype.hasOwnProperty.call(n,t)}function a(n,t)
{return 2===o(n)?n.get(t):n[t]}function f(n,t,r){var e=o(n);2===e?n.set(t,r):3===e?
(n.delete(t),n.add(r)):n[t]=r}function c(n,t){return n===t?0!==n||1/n==1/t:n!=n&&t!
=t}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof
Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return
Array.prototype.slice.call(n);var t=tn(n);delete t[Q];for(var
r=nn(t),e=0;e<r.length;e++){var i=r[e],o=t[i];!1===o.writable&&(o.writable=!
0,o.configurable=!0),(o.get||o.set)&&(t[i]={configurable:!0,writable:!
0,enumerable:o.enumerable,value:n[i]})}return
Object.create(Object.getPrototypeOf(n),t)}function d(n,e){return void 0===e&&(e=!
1),y(n)||t(n)||!r(n)?n:
(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,t)
{return d(t,!0)}),!0),n)}function h(){n(2)}function y(n){return null==n||"object"!
=typeof n||Object.isFrozen(n)}function b(t){var r=rn[t];return r||
n(18,t),r}function m(n,t){rn[n]||(rn[n]=t)}function _(){return true||0,U}function
j(n,t){t&&(b("Patches"),n.u=[],n.s=[],n.v=t)}function O(n)
{g(n),n.p.forEach(S),n.p=null}function g(n){n===U&&(U=n.l)}function w(n){return
U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var t=n[Q];0===t.i||1===t.i?t.j():t.O=!
0}function P(t,e){e._=e.p.length;var i=e.p[0],o=void 0!==t&&t!==i;return e.h.g||
b("ES5").S(e,t,o),o?(i[Q].P&&(O(e),n(4)),r(t)&&(t=M(e,t),e.l||
x(e,t)),e.u&&b("Patches").M(i[Q],t,e.u,e.s)):t=M(e,i,[]),O(e),e.u&&e.v(e.u,e.s),t!
==H?t:void 0}function M(n,t,r){if(y(t))return t;var e=t[Q];if(!e)return i(t,
(function(i,o){return A(n,e,t,i,o,r)}),!0),t;if(e.A!==n)return t;if(!e.P)return
x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?
e.o=l(e.k):e.o;i(3===e.i?new Set(o):o,(function(t,i){return
A(n,e,o,t,i,r)})),x(n,o,!1),r&&n.u&&b("Patches").R(e,r,n.u,n.s)}return e.o}function
A(e,i,o,a,c,s){if( false&&0,t(c)){var v=M(e,c,s&&i&&3!==i.i&&!u(i.D,a)?
s.concat(a):void 0);if(f(o,a,v),!t(v))return;e.m=!1}if(r(c)&&!y(c)){if(!
e.h.F&&e._<1)return;M(e,c),i&&i.A.l||x(e,c)}}function x(n,t,r){void 0===r&&(r=!
1),n.h.F&&n.m&&d(t,r)}function z(n,t){var r=n[Q];return(r?p(r):n)[t]}function
I(n,t){if(t in n)for(var r=Object.getPrototypeOf(n);r;){var
e=Object.getOwnPropertyDescriptor(r,t);if(e)return
e;r=Object.getPrototypeOf(r)}}function k(n){n.P||(n.P=!0,n.l&&k(n.l))}function E(n)
{n.o||(n.o=l(n.t))}function R(n,t,r){var e=s(t)?b("MapSet").N(t,r):v(t)?
b("MapSet").T(t,r):n.g?function(n,t){var r=Array.isArray(n),e={i:r?1:0,A:t?
t.A:_(),P:!1,I:!1,D:{},l:t,t:n,k:null,o:null,j:null,C:!
1},i=e,o=en;r&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return
e.k=f,e.j=a,f}(t,r):b("ES5").J(t,r);return(r?r.A:_()).p.push(e),e}function D(e)
{return t(e)||n(22,e),function n(t){if(!r(t))return t;var e,u=t[Q],c=o(t);if(u)
{if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=!0,e=F(t,c),u.I=!1}else
e=F(t,c);return i(e,(function(t,r){u&&a(u.t,t)===r||f(e,t,n(r))})),3===c?new
Set(e):e}(e)}function F(n,t){switch(t){case 2:return new Map(n);case 3:return
Array.from(n)}return l(n)}function N(){function r(n,t){var r=s[n];return r?
r.enumerable=t:s[n]=r={configurable:!0,enumerable:t,get:function(){var
t=this[Q];return false&&0,en.get(t,n)},set:function(t){var r=this[Q];
false&&0,en.set(r,n,t)}},r}function e(n){for(var t=n.length-1;t>=0;t--){var r=n[t]
[Q];if(!r.P)switch(r.i){case 5:a(r)&&k(r);break;case 4:o(r)&&k(r)}}}function o(n)
{for(var t=n.t,r=n.k,e=nn(r),i=e.length-1;i>=0;i--){var o=e[i];if(o!==Q){var
a=t[o];if(void 0===a&&!u(t,o))return!0;var f=r[o],s=f&&f[Q];if(s?s.t!==a:!
c(f,a))return!0}}var v=!!t[Q];return e.length!==nn(t).length+(v?0:1)}function a(n)
{var t=n.k;if(t.length!==n.t.length)return!0;var
r=Object.getOwnPropertyDescriptor(t,t.length-1);return!(!r||r.get)}function f(t)
{t.O&&n(3,JSON.stringify(p(t)))}var s={};m("ES5",{J:function(n,t){var
e=Array.isArray(n),i=function(n,t){if(n){for(var
e=Array(t.length),i=0;i<t.length;i++)Object.defineProperty(e,""+i,r(i,!0));return
e}var o=tn(t);delete o[Q];for(var u=nn(o),a=0;a<u.length;a++){var
f=u[a];o[f]=r(f,n||!!o[f].enumerable)}return
Object.create(Object.getPrototypeOf(t),o)}(e,n),o={i:e?5:4,A:t?t.A:_(),P:!1,I:!1,D:
{},l:t,t:n,k:i,o:null,O:!1,C:!1};return Object.defineProperty(i,Q,
{value:o,writable:!0}),i},S:function(n,r,o){o?t(r)&&r[Q].A===n&&e(n.p):
(n.u&&function n(t){if(t&&"object"==typeof t){var r=t[Q];if(r){var
e=r.t,o=r.k,f=r.D,c=r.i;if(4===c)i(o,(function(t){t!==Q&&(void 0!==e[t]||u(e,t)?
f[t]||n(o[t]):(f[t]=!0,k(r)))})),i(e,(function(n){void 0!==o[n]||u(o,n)||(f[n]=!
1,k(r))}));else if(5===c){if(a(r)&&(k(r),f.length=!0),o.length<e.length)for(var
s=o.length;s<e.length;s++)f[s]=!1;else for(var v=e.length;v<o.length;v++)f[v]=!
0;for(var p=Math.min(o.length,e.length),l=0;l<p;l++)void 0===f[l]&&n(o[l])}}}}
(n.p[0]),e(n.p))},K:function(n){return 4===n.i?o(n):a(n)}})}function T(){function
e(n){if(!r(n))return n;if(Array.isArray(n))return n.map(e);if(s(n))return new
Map(Array.from(n.entries()).map((function(n)
{return[n[0],e(n[1])]})));if(v(n))return new Set(Array.from(n).map(e));var
t=Object.create(Object.getPrototypeOf(n));for(var i in n)t[i]=e(n[i]);return
u(n,L)&&(t[L]=n[L]),t}function f(n){return t(n)?e(n):n}var c="add";m("Patches",
{$:function(t,r){return r.forEach((function(r){for(var
i=r.path,u=r.op,f=t,s=0;s<i.length-1;s++){var v=o(f),p=""+i[s];0!==v&&1!
==v||"__proto__"!==p&&"constructor"!==p||n(24),"function"==typeof
f&&"prototype"===p&&n(24),"object"!=typeof(f=a(f,p))&&n(15,i.join("/"))}var
l=o(f),d=e(r.value),h=i[i.length-1];switch(u){case"replace":switch(l){case 2:return
f.set(h,d);case 3:n(16);default:return f[h]=d}case c:switch(l){case
1:return"-"===h?f.push(d):f.splice(h,0,d);case 2:return f.set(h,d);case 3:return
f.add(d);default:return f[h]=d}case"remove":switch(l){case 1:return
f.splice(h,1);case 2:return f.delete(h);case 3:return
f.delete(r.value);default:return delete
f[h]}default:n(17,u)}})),t},R:function(n,t,r,e){switch(n.i){case 0:case 4:case
2:return function(n,t,r,e){var o=n.t,s=n.o;i(n.D,(function(n,i){var
v=a(o,n),p=a(s,n),l=i?u(o,n)?"replace":c:"remove";if(v!==p||"replace"!==l){var
d=t.concat(n);r.push("remove"===l?{op:l,path:d}:
{op:l,path:d,value:p}),e.push(l===c?{op:"remove",path:d}:"remove"===l?
{op:c,path:d,value:f(v)}:{op:"replace",path:d,value:f(v)})}}))}(n,t,r,e);case
5:case 1:return function(n,t,r,e){var i=n.t,o=n.D,u=n.o;if(u.length<i.length){var
a=[u,i];i=a[0],u=a[1];var s=[e,r];r=s[0],e=s[1]}for(var v=0;v<i.length;v+
+)if(o[v]&&u[v]!==i[v]){var
p=t.concat([v]);r.push({op:"replace",path:p,value:f(u[v])}),e.push({op:"replace",pa
th:p,value:f(i[v])})}for(var l=i.length;l<u.length;l++){var
d=t.concat([l]);r.push({op:c,path:d,value:f(u[l])})}i.length<u.length&&e.push({op:"
replace",path:t.concat(["length"]),value:i.length})}(n,t,r,e);case 3:return
function(n,t,r,e){var i=n.t,o=n.o,u=0;i.forEach((function(n){if(!o.has(n)){var
i=t.concat([u]);r.push({op:"remove",path:i,value:n}),e.unshift({op:c,path:i,value:n
})}u++})),u=0,o.forEach((function(n){if(!i.has(n)){var
o=t.concat([u]);r.push({op:c,path:o,value:n}),e.unshift({op:"remove",path:o,value:n
})}u++}))}(n,t,r,e)}},M:function(n,t,r,e){r.push({op:"replace",path:[],value:t===H?
void 0:t}),e.push({op:"replace",path:[],value:n.t})}})}function C(){function t(n,t)
{function r(){this.constructor=n}a(n,t),n.prototype=(r.prototype=t.prototype,new
r)}function e(n){n.o||(n.D=new Map,n.o=new Map(n.t))}function o(n){n.o||(n.o=new
Set,n.t.forEach((function(t){if(r(t)){var
e=R(n.A.h,t,n);n.p.set(t,e),n.o.add(e)}else n.o.add(t)})))}function u(t)
{t.O&&n(3,JSON.stringify(p(t)))}var a=function(n,t)
{return(a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,t)
{n.__proto__=t}||function(n,t){for(var r in t)t.hasOwnProperty(r)&&(n[r]=t[r])})
(n,t)},f=function(){function n(n,t){return this[Q]={i:2,l:t,A:t?t.A:_(),P:!1,I:!
1,o:void 0,D:void 0,t:n,k:this,C:!1,O:!1},this}t(n,Map);var o=n.prototype;return
Object.defineProperty(o,"size",{get:function(){return
p(this[Q]).size}}),o.has=function(n){return p(this[Q]).has(n)},o.set=function(n,t)
{var r=this[Q];return u(r),p(r).has(n)&&p(r).get(n)===t||(e(r),k(r),r.D.set(n,!
0),r.o.set(n,t),r.D.set(n,!0)),this},o.delete=function(n){if(!this.has(n))return!
1;var t=this[Q];return u(t),e(t),k(t),t.D.set(n,!1),t.o.delete(n),!
0},o.clear=function(){var n=this[Q];u(n),p(n).size&&(e(n),k(n),n.D=new Map,i(n.t,
(function(t){n.D.set(t,!1)})),n.o.clear())},o.forEach=function(n,t){var
r=this;p(this[Q]).forEach((function(e,i)
{n.call(t,r.get(i),i,r)}))},o.get=function(n){var t=this[Q];u(t);var
i=p(t).get(n);if(t.I||!r(i))return i;if(i!==t.t.get(n))return i;var
o=R(t.A.h,i,t);return e(t),t.o.set(n,o),o},o.keys=function(){return
p(this[Q]).keys()},o.values=function(){var n,t=this,r=this.keys();return(n={})
[V]=function(){return t.values()},n.next=function(){var n=r.next();return n.done?n:
{done:!1,value:t.get(n.value)}},n},o.entries=function(){var
n,t=this,r=this.keys();return(n={})[V]=function(){return
t.entries()},n.next=function(){var
n=r.next();if(n.done)return n;var e=t.get(n.value);return{done:!1,value:
[n.value,e]}},n},o[V]=function(){return this.entries()},n}(),c=function(){function
n(n,t){return this[Q]={i:3,l:t,A:t?t.A:_(),P:!1,I:!1,o:void 0,t:n,k:this,p:new
Map,O:!1,C:!1},this}t(n,Set);var r=n.prototype;return
Object.defineProperty(r,"size",{get:function(){return
p(this[Q]).size}}),r.has=function(n){var t=this[Q];return u(t),t.o?!!t.o.has(n)||!
(!t.p.has(n)||!t.o.has(t.p.get(n))):t.t.has(n)},r.add=function(n){var
t=this[Q];return u(t),this.has(n)||
(o(t),k(t),t.o.add(n)),this},r.delete=function(n){if(!this.has(n))return!1;var
t=this[Q];return u(t),o(t),k(t),t.o.delete(n)||!!
t.p.has(n)&&t.o.delete(t.p.get(n))},r.clear=function(){var
n=this[Q];u(n),p(n).size&&(o(n),k(n),n.o.clear())},r.values=function(){var
n=this[Q];return u(n),o(n),n.o.values()},r.entries=function(){var n=this[Q];return
u(n),o(n),n.o.entries()},r.keys=function(){return this.values()},r[V]=function()
{return this.values()},r.forEach=function(n,t){for(var r=this.values(),e=r.next();!
e.done;)n.call(t,e.value,e.value,this),e=r.next()},n}();m("MapSet",{N:function(n,t)
{return new f(n,t)},T:function(n,t){return new c(n,t)}})}function J()
{N(),C(),T()}function K(n){return n}function $(n){return n}var G,U,W="undefined"!
=typeof Symbol&&"symbol"==typeof Symbol("x"),X="undefined"!=typeof
Map,q="undefined"!=typeof Set,B="undefined"!=typeof Proxy&&void 0!
==Proxy.revocable&&"undefined"!=typeof Reflect,H=W?Symbol.for("immer-nothing"):
((G={})["immer-nothing"]=!0,G),L=W?Symbol.for("immer-
draftable"):"__$immer_draftable",Q=W?Symbol.for("immer-
state"):"__$immer_state",V="undefined"!=typeof
Symbol&&Symbol.iterator||"@@iterator",Y={0:"Illegal state",1:"Immer drafts cannot
have computed properties",2:"This object has been frozen and should not be
mutated",3:function(n){return"Cannot use a proxy that has been revoked. Did you
pass an object from inside an immer function to an async process? "+n},4:"An immer
producer returned a new value *and* modified its draft. Either return a new value
*or* modify the draft.",5:"Immer forbids circular references",6:"The first or
second argument to `produce` must be a function",7:"The third argument to `produce`
must be a function or undefined",8:"First argument to `createDraft` must be a plain
object, an array, or an immerable object",9:"First argument to `finishDraft` must
be a draft returned by `createDraft`",10:"The given draft is already
finalized",11:"Object.defineProperty() cannot be used on an Immer
draft",12:"Object.setPrototypeOf() cannot be used on an Immer draft",13:"Immer only
supports deleting array indices",14:"Immer only supports setting array indices and
the 'length' property",15:function(n){return"Cannot apply patch, path doesn't
resolve: "+n},16:'Sets cannot have "replace" patches.',17:function(n)
{return"Unsupported patch operation: "+n},18:function(n){return"The plugin for
'"+n+"' has not been loaded into Immer. To enable the plugin, import and call
ènable"+n+"()` when initializing your application."},20:"Cannot use proxies if
Proxy, Proxy.revocable or Reflect are not available",21:function(n){return"produce
can only be called on things that are draftable: plain objects, arrays, Map, Set or
classes that are marked with '[immerable]: true'. Got '"+n+"'"},22:function(n)
{return"'current' expects a draft, got: "+n},23:function(n){return"'original'
expects a draft, got: "+n},24:"Patching reserved attributes like __proto__,
prototype and constructor is not
allowed"},Z=""+Object.prototype.constructor,nn="undefined"!=typeof
Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?
function(n){return
Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOw
nPropertyNames,tn=Object.getOwnPropertyDescriptors||function(n){var t={};return
nn(n).forEach((function(r)
{t[r]=Object.getOwnPropertyDescriptor(n,r)})),t},rn={},en={get:function(n,t)
{if(t===Q)return n;var e=p(n);if(!u(e,t))return function(n,t,r){var
e,i=I(t,r);return i?"value"in i?i.value:null===(e=i.get)||void 0===e?void
0:e.call(n.k):void 0}(n,e,t);var i=e[t];return n.I||!r(i)?i:i===z(n.t,t)?
(E(n),n.o[t]=R(n.A.h,i,n)):i},has:function(n,t){return t in
p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,t,r){var
e=I(p(n),t);if(null==e?void 0:e.set)return e.set.call(n.k,r),!0;if(!n.P){var
i=z(p(n),t),o=null==i?void 0:i[Q];if(o&&o.t===r)return n.o[t]=r,n.D[t]=!1,!
0;if(c(r,i)&&(void 0!==r||u(n.t,t)))return!0;E(n),k(n)}return n.o[t]===r&&"number"!
=typeof r&&(void 0!==r||t in n.o)||(n.o[t]=r,n.D[t]=!0,!
0)},deleteProperty:function(n,t){return void 0!==z(n.t,t)||t in n.t?(n.D[t]=!
1,E(n),k(n)):delete n.D[t],n.o&&delete n.o[t],!
0},getOwnPropertyDescriptor:function(n,t){var
r=p(n),e=Reflect.getOwnPropertyDescriptor(r,t);return e?{writable:!
0,configurable:1!==n.i||"length"!
==t,enumerable:e.enumerable,value:r[t]}:e},defineProperty:function()
{n(11)},getPrototypeOf:function(n){return
Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12)}},on={};i(en,
(function(n,t){on[n]=function(){return arguments[0]=arguments[0]
[0],t.apply(this,arguments)}})),on.deleteProperty=function(t,r){return
false&&0,en.deleteProperty.call(this,t[0],r)},on.set=function(t,r,e){return
false&&0,en.set.call(this,t[0],r,e,t[0])};var un=function(){function e(t){var
e=this;this.g=B,this.F=!0,this.produce=function(t,i,o){if("function"==typeof
t&&"function"!=typeof i){var u=i;i=t;var a=e;return function(n){var t=this;void
0===n&&(n=u);for(var r=arguments.length,e=Array(r>1?r-1:0),o=1;o<r;o++)e[o-
1]=arguments[o];return a.produce(n,(function(n){var r;return(r=i).call.apply(r,
[t,n].concat(e))}))}}var f;if("function"!=typeof i&&n(6),void 0!==o&&"function"!
=typeof o&&n(7),r(t)){var c=w(e),s=R(e,t,void 0),v=!0;try{f=i(s),v=!1}finally{v?
O(c):g(c)}return"undefined"!=typeof Promise&&f instanceof Promise?
f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw O(c),n})):
(j(c,o),P(f,c))}if(!t||"object"!=typeof t){if((f=i(t))===H)return;return void
0===f&&(f=t),e.F&&d(f,!0),f}n(21,t)},this.produceWithPatches=function(n,t)
{return"function"==typeof n?function(t){for(var r=arguments.length,i=Array(r>1?r-
1:0),o=1;o<r;o++)i[o-1]=arguments[o];return e.produceWithPatches(t,(function(t)
{return n.apply(void 0,[t].concat(i))}))}:[e.produce(n,t,(function(n,t)
{r=n,i=t})),r,i];var r,i},"boolean"==typeof(null==t?void
0:t.useProxies)&&this.setUseProxies(t.useProxies),"boolean"==typeof(null==t?void
0:t.autoFreeze)&&this.setAutoFreeze(t.autoFreeze)}var i=e.prototype;return
i.createDraft=function(e){r(e)||n(8),t(e)&&(e=D(e));var i=w(this),o=R(this,e,void
0);return o[Q].C=!0,g(i),o},i.finishDraft=function(t,r){var e=t&&t[Q];
false&&(0);var i=e.A;return j(i,r),P(void 0,i)},i.setAutoFreeze=function(n)
{this.F=n},i.setUseProxies=function(t){t&&!
B&&n(20),this.g=t},i.applyPatches=function(n,r){var e;for(e=r.length-1;e>=0;e--)
{var i=r[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-
1&&(r=r.slice(e+1));var o=b("Patches").$;return t(n)?o(n,r):this.produce(n,
(function(n){return o(n,r)}))},e}(),an=new
un,fn=an.produce,cn=an.produceWithPatches.bind(an),sn=an.setAutoFreeze.bind(an),vn=
an.setUseProxies.bind(an),pn=an.applyPatches.bind(an),ln=an.createDraft.bind(an),dn
=an.finishDraft.bind(an);/* harmony default export */ const immer_esm = (fn);
//# sourceMappingURL=immer.esm.js.map
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js

var objectSpread2 = __webpack_require__(1413);
;// CONCATENATED MODULE: ./node_modules/redux/es/redux.js
/**
* Adapted from React:
https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessag
e.js
*
* Do not require this module directly! Use normal throw error calls. These
messages will be replaced with error codes
* during build.
* @param {number} code
*/
function formatProdErrorMessage(code) {
return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?
code=" + code + " for the full message or " + 'use the non-minified dev environment
for full errors. ';
}
// Inlined version of the `symbol-observable` polyfill

var $$observable = (function () {
return typeof Symbol === 'function' && Symbol.observable || '@@observable';
})();
/**
* These are private action types reserved by Redux.
* For any unknown actions, you must return the current state.
* If the current state is undefined, you must return the initial state.
* Do not reference these action types directly in your code.
*/
var randomString = function randomString() {
return Math.random().toString(36).substring(7).split('').join('.');
};
var ActionTypes = {
INIT: "@@redux/INIT" + randomString(),
REPLACE: "@@redux/REPLACE" + randomString(),
PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
}
};
/**
* @param {any} obj The object to inspect.
* @returns {boolean} True if the argument appears to be a plain object.
*/
function isPlainObject(obj) {
if (typeof obj !== 'object' || obj === null) return false;
var proto = obj;
while (Object.getPrototypeOf(proto) !== null) {

proto = Object.getPrototypeOf(proto);
}
return Object.getPrototypeOf(obj) === proto;
}
// Inlined / shortened version of `kindOf` from

https://github.com/jonschlinkert/kind-of
function miniKindOf(val) {
if (val === void 0) return 'undefined';
if (val === null) return 'null';
var type = typeof val;
switch (type) {
case 'boolean':
case 'string':
case 'number':
case 'symbol':
case 'function':
{
return type;
}
}
if (Array.isArray(val)) return 'array';

if (isDate(val)) return 'date';
if (isError(val)) return 'error';
var constructorName = ctorName(val);
switch (constructorName) {
case 'Symbol':
case 'Promise':
case 'WeakMap':
case 'WeakSet':
case 'Map':
case 'Set':
return constructorName;
} // other
return type.slice(8, -1).toLowerCase().replace(/\s/g, '');

}
function ctorName(val) {
return typeof val.constructor === 'function' ? val.constructor.name : null;
}
function isError(val) {
return val instanceof Error || typeof val.message === 'string' && val.constructor
&& typeof val.constructor.stackTraceLimit === 'number';
}
function isDate(val) {
if (val instanceof Date) return true;
return typeof val.toDateString === 'function' && typeof val.getDate ===
'function' && typeof val.setDate === 'function';
}
function kindOf(val) {
var typeOfVal = typeof val;
if (false) {}
return typeOfVal;
}
/**
* Creates a Redux store that holds the state tree.
* The only way to change the data in the store is to call `dispatch()` on it.
*
* There should only be a single store in your app. To specify how different
* parts of the state tree respond to actions, you may combine several reducers
* into a single reducer function by using `combineReducers`.
*
* @param {Function} reducer A function that returns the next state tree, given
* the current state tree and the action to handle.
*
* @param {any} [preloadedState] The initial state. You may optionally specify it
* to hydrate the state from the server in universal apps, or to restore a
* previously serialized user session.
* If you use `combineReducers` to produce the root reducer function, this must be
* an object with the same shape as `combineReducers` keys.
*
* @param {Function} [enhancer] The store enhancer. You may optionally specify it
* to enhance the store with third-party capabilities such as middleware,
* time travel, persistence, etc. The only store enhancer that ships with Redux
* is àpplyMiddleware()`.
*
* @returns {Store} A Redux store that lets you read the state, dispatch actions
* and subscribe to changes.
*/
function createStore(reducer, preloadedState, enhancer) {

var _ref2;
if (typeof preloadedState === 'function' && typeof enhancer === 'function' ||

typeof enhancer === 'function' && typeof arguments[3] === 'function') {
throw new Error( true ? formatProdErrorMessage(0) : 0);
}
if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {

enhancer = preloadedState;
preloadedState = undefined;
}
if (typeof enhancer !== 'undefined') {

if (typeof enhancer !== 'function') {
}
return enhancer(createStore)(reducer, preloadedState);

}
if (typeof reducer !== 'function') {

}
var currentReducer = reducer;

var currentState = preloadedState;
var currentListeners = [];
var nextListeners = currentListeners;
var isDispatching = false;
/**
* This makes a shallow copy of currentListeners so we can use
* nextListeners as a temporary list while dispatching.
*
* This prevents any bugs around consumers calling
* subscribe/unsubscribe in the middle of a dispatch.
*/
function ensureCanMutateNextListeners() {
if (nextListeners === currentListeners) {
nextListeners = currentListeners.slice();
}
}
/**
* Reads the state tree managed by the store.
*
* @returns {any} The current state tree of your application.
*/
function getState() {
if (isDispatching) {
}
return currentState;
}
/**
* Adds a change listener. It will be called any time an action is dispatched,
* and some part of the state tree may potentially have changed. You may then
* call `getState()` to read the current state tree inside the callback.
*
* You may call `dispatch()` from a change listener, with the following
* caveats:
*
* 1. The subscriptions are snapshotted just before every `dispatch()` call.
* If you subscribe or unsubscribe while the listeners are being invoked, this
* will not have any effect on the `dispatch()` that is currently in progress.
* However, the next `dispatch()` call, whether nested or not, will use a more
* recent snapshot of the subscription list.
*
* 2. The listener should not expect to see all state changes, as the state
* might have been updated multiple times during a nested `dispatch()` before
* the listener is called. It is, however, guaranteed that all subscribers
* registered before the `dispatch()` started will be called with the latest
* state by the time it exits.
*
* @param {Function} listener A callback to be invoked on every dispatch.
* @returns {Function} A function to remove this change listener.
*/
function subscribe(listener) {
if (typeof listener !== 'function') {
}
}
var isSubscribed = true;

ensureCanMutateNextListeners();
nextListeners.push(listener);
return function unsubscribe() {
if (!isSubscribed) {
return;
}
}
isSubscribed = false;
ensureCanMutateNextListeners();
var index = nextListeners.indexOf(listener);
nextListeners.splice(index, 1);
currentListeners = null;
};
}
/**
* Dispatches an action. It is the only way to trigger a state change.
*
* The `reducer` function, used to create the store, will be called with the
* current state tree and the given àction`. Its return value will
* be considered the **next** state of the tree, and the change listeners
* will be notified.
*
* The base implementation only supports plain object actions. If you want to
* dispatch a Promise, an Observable, a thunk, or something else, you need to
* wrap your store creating function into the corresponding middleware. For
* example, see the documentation for the `redux-thunk` package. Even the
* middleware will eventually dispatch plain object actions using this method.
*
* @param {Object} action A plain object representing “what changed”. It is
* a good idea to keep actions serializable so you can record and replay user
* sessions, or use the time travelling `redux-devtools`. An action must have
* a `type` property which may not be ùndefined`. It is a good idea to use
* string constants for action types.
*
* @returns {Object} For convenience, the same action object you dispatched.
*
* Note that, if you use a custom middleware, it may wrap `dispatch()` to
* return something else (for example, a Promise you can await).
*/
function dispatch(action) {
if (!isPlainObject(action)) {
}
if (typeof action.type === 'undefined') {

}
}
try {
isDispatching = true;
currentState = currentReducer(currentState, action);
} finally {
isDispatching = false;
}
var listeners = currentListeners = nextListeners;
for (var i = 0; i < listeners.length; i++) {

var listener = listeners[i];
listener();
}
return action;
}
/**
* Replaces the reducer currently used by the store to calculate the state.
*
* You might need this if your app implements code splitting and you want to
* load some of the reducers dynamically. You might also need this if you
* implement a hot reloading mechanism for Redux.
*
* @param {Function} nextReducer The reducer for the store to use instead.
* @returns {void}
*/
function replaceReducer(nextReducer) {
if (typeof nextReducer !== 'function') {
}
currentReducer = nextReducer; // This action has a similiar effect to

ActionTypes.INIT.
// Any reducers that existed in both the new and old rootReducer
// will receive the previous state. This effectively populates
// the new state tree with any relevant data from the old one.
dispatch({
type: ActionTypes.REPLACE
});
}
/**
* Interoperability point for observable/reactive libraries.
* @returns {observable} A minimal observable of state changes.
* For more information, see the observable proposal:
* https://github.com/tc39/proposal-observable
*/
function observable() {
var _ref;
var outerSubscribe = subscribe;

return _ref = {
/**
* The minimal observable subscription method.
* @param {Object} observer Any object that can be used as an observer.
* The observer object should have a `next` method.
* @returns {subscription} An object with an ùnsubscribe` method that can
* be used to unsubscribe the observable from the store, and prevent further
* emission of values from the observable.
*/
subscribe: function subscribe(observer) {
if (typeof observer !== 'object' || observer === null) {
}
function observeState() {
if (observer.next) {
observer.next(getState());
}
}
observeState();
var unsubscribe = outerSubscribe(observeState);
return {
unsubscribe: unsubscribe
};
}
}, _ref[$$observable] = function () {
return this;
}, _ref;
} // When a store is created, an "INIT" action is dispatched so that every
// reducer returns their initial state. This effectively populates
// the initial state tree.
dispatch({
type: ActionTypes.INIT
});
return _ref2 = {
dispatch: dispatch,
subscribe: subscribe,
getState: getState,
replaceReducer: replaceReducer
}, _ref2[$$observable] = observable, _ref2;
}
/**
* Prints a warning in the console if it exists.
*
* @param {String} message The warning message.
* @returns {void}
*/
function warning(message) {
/* eslint-disable no-console */
if (typeof console !== 'undefined' && typeof console.error === 'function') {
console.error(message);
}
/* eslint-enable no-console */
try {
// This error was thrown as a convenience so that if you enable
// "break on all exceptions" in your console,
// it would pause the execution at this line.
throw new Error(message);
} catch (e) {} // eslint-disable-line no-empty
function getUnexpectedStateShapeWarningMessage(inputState, reducers, action,

unexpectedKeyCache) {
var reducerKeys = Object.keys(reducers);
var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState
argument passed to createStore' : 'previous state received by the reducer';
if (reducerKeys.length === 0) {
return 'Store does not have a valid reducer. Make sure the argument passed ' +
'to combineReducers is an object whose values are reducers.';
}
if (!isPlainObject(inputState)) {
return "The " + argumentName + " has unexpected type of \"" +
kindOf(inputState) + "\". Expected argument to be an object with the following " +
("keys: \"" + reducerKeys.join('", "') + "\"");
}
var unexpectedKeys = Object.keys(inputState).filter(function (key) {

return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];
});
unexpectedKeys.forEach(function (key) {
unexpectedKeyCache[key] = true;
});
if (action && action.type === ActionTypes.REPLACE) return;
if (unexpectedKeys.length > 0) {
return "Unexpected " + (unexpectedKeys.length > 1 ? 'keys' : 'key') + " " +
("\"" + unexpectedKeys.join('", "') + "\" found in " + argumentName + ". ") +
"Expected to find one of the known reducer keys instead: " + ("\"" +
reducerKeys.join('", "') + "\". Unexpected keys will be ignored.");
}
}
function assertReducerShape(reducers) {
Object.keys(reducers).forEach(function (key) {
var reducer = reducers[key];
var initialState = reducer(undefined, {
type: ActionTypes.INIT
});
if (typeof initialState === 'undefined') {

}
if (typeof reducer(undefined, {
type: ActionTypes.PROBE_UNKNOWN_ACTION()
}) === 'undefined') {
}
});
}
/**
* Turns an object whose values are different reducer functions, into a single
* reducer function. It will call every child reducer, and gather their results
* into a single state object, whose keys correspond to the keys of the passed
* reducer functions.
*
* @param {Object} reducers An object whose values correspond to different
* reducer functions that need to be combined into one. One handy way to obtain
* it is to use ES6 ìmport * as reducers` syntax. The reducers may never return
* undefined for any action. Instead, they should return their initial state
* if the state passed to them was undefined, and the current state for any
* unrecognized action.
*
* @returns {Function} A reducer function that invokes every reducer inside the
* passed object, and builds a state object with the same shape.
*/
function combineReducers(reducers) {
var reducerKeys = Object.keys(reducers);
var finalReducers = {};
for (var i = 0; i < reducerKeys.length; i++) {

var key = reducerKeys[i];
if (false) {}
if (typeof reducers[key] === 'function') {

finalReducers[key] = reducers[key];
}
}
var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure

we don't warn about the same
// keys multiple times.
var unexpectedKeyCache;
if (false) {}
var shapeAssertionError;
try {
assertReducerShape(finalReducers);
} catch (e) {
shapeAssertionError = e;
}
return function combination(state, action) {

if (state === void 0) {
state = {};
}
if (shapeAssertionError) {
throw shapeAssertionError;
}
if (false) { var warningMessage; }

var hasChanged = false;
var nextState = {};
for (var _i = 0; _i < finalReducerKeys.length; _i++) {

var _key = finalReducerKeys[_i];
var reducer = finalReducers[_key];
var previousStateForKey = state[_key];
var nextStateForKey = reducer(previousStateForKey, action);
if (typeof nextStateForKey === 'undefined') {

var actionType = action && action.type;
}
nextState[_key] = nextStateForKey;
hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
}
hasChanged = hasChanged || finalReducerKeys.length !==

Object.keys(state).length;
return hasChanged ? nextState : state;
};
}
function bindActionCreator(actionCreator, dispatch) {

return dispatch(actionCreator.apply(this, arguments));
};
}
/**
* Turns an object whose values are action creators, into an object with the
* same keys, but with every function wrapped into a `dispatch` call so they
* may be invoked directly. This is just a convenience method, as you can call
* `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
*
* For convenience, you can also pass an action creator as the first argument,
* and get a dispatch wrapped function in return.
*
* @param {Function|Object} actionCreators An object whose values are action
* creator functions. One handy way to obtain it is to use ES6 ìmport * as`
* syntax. You may also pass a single function.
*
* @param {Function} dispatch The `dispatch` function available on your Redux
* store.
*
* @returns {Function|Object} The object mimicking the original object, but with
* every action creator wrapped into the `dispatch` call. If you passed a
* function as àctionCreators`, the return value will also be a single
* function.
*/
function bindActionCreators(actionCreators, dispatch) {

if (typeof actionCreators === 'function') {
return bindActionCreator(actionCreators, dispatch);
}
if (typeof actionCreators !== 'object' || actionCreators === null) {

}
var boundActionCreators = {};
for (var key in actionCreators) {

var actionCreator = actionCreators[key];
if (typeof actionCreator === 'function') {

boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
}
}
return boundActionCreators;
}
/**
* Composes single-argument functions from right to left. The rightmost
* function can take multiple arguments as it provides the signature for
* the resulting composite function.
*
* @param {...Function} funcs The functions to compose.
* @returns {Function} A function obtained by composing the argument functions
* from right to left. For example, compose(f, g, h) is identical to doing
* (...args) => f(g(h(...args))).
*/
function compose() {
for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len;
_key++) {
funcs[_key] = arguments[_key];
}
if (funcs.length === 0) {
return function (arg) {
return arg;
};
}
if (funcs.length === 1) {
return funcs[0];
}
return funcs.reduce(function (a, b) {

return a(b.apply(void 0, arguments));
};
});
}
/**
* Creates a store enhancer that applies middleware to the dispatch method
* of the Redux store. This is handy for a variety of tasks, such as expressing
* asynchronous actions in a concise manner, or logging every action payload.
*
* See `redux-thunk` package as an example of the Redux middleware.
*
* Because middleware is potentially asynchronous, this should be the first
* store enhancer in the composition chain.
*
* Note that each middleware will be given the `dispatch` and `getState` functions
* as named arguments.
*
* @param {...Function} middlewares The middleware chain to be applied.
* @returns {Function} A store enhancer applying the middleware.
*/
function applyMiddleware() {
for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key <
_len; _key++) {
middlewares[_key] = arguments[_key];
}
return function (createStore) {

var store = createStore.apply(void 0, arguments);
var _dispatch = function dispatch() {

};
var middlewareAPI = {
getState: store.getState,
dispatch: function dispatch() {
return _dispatch.apply(void 0, arguments);
}
};
var chain = middlewares.map(function (middleware) {
return middleware(middlewareAPI);
});
_dispatch = compose.apply(void 0, chain)(store.dispatch);
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({},
store), {}, {
dispatch: _dispatch
});
};
};
}
/*
* This is a dummy function to check if the function name has been altered by
minification.
* If the function has been minified and NODE_ENV !== 'production', warn the user.
*/
function isCrushed() {}
if (false) {}
// EXTERNAL MODULE: ./node_modules/reselect/es/index.js

var es = __webpack_require__(22222);
// EXTERNAL MODULE: ./node_modules/redux-thunk/es/index.js
var redux_thunk_es = __webpack_require__(53894);
;// CONCATENATED MODULE: ./node_modules/@reduxjs/toolkit/dist/redux-toolkit.esm.js
var __extends = (undefined && undefined.__extends) || (function () {
var extendStatics = function (d, b) {
b; }) ||
};
return function (d, b) {
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype,
new __());
};
})();
var __generator = (undefined && undefined.__generator) || function (thisArg, body)
{
t[1]; }, trys: [], ops: [] }, f, y, t, g;
function step(op) {
while (_) try {
return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
default:
(op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3])))
break; }
break; }
}
true };
}
};
var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = function (obj, key, value) { return key in obj ?
__defProp(obj, key, { enumerable: true, configurable: true, writable: true, value:
value }) : obj[key] = value; };
var __spreadValues = function (a, b) {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) {
var prop = _c[_i];
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = function (a, b) { return __defProps(a,
__getOwnPropDescs(b)); };
var __async = function (__this, __arguments, generator) {
return new Promise(function (resolve, reject) {
var fulfilled = function (value) {
try {
step(generator.next(value));
}
catch (e) {
reject(e);
}
};
var rejected = function (value) {
try {
step(generator.throw(value));
}
catch (e) {
reject(e);
}
};
var step = function (x) { return x.done ? resolve(x.value) :
Promise.resolve(x.value).then(fulfilled, rejected); };
step((generator = generator.apply(__this, __arguments)).next());
});
};
// src/index.ts
// src/createDraftSafeSelector.ts
var createDraftSafeSelector = function () {

var args = [];
}
var selector = es/* createSelector.apply */.P1.apply(void 0, args);
var wrappedSelector = function (value) {
var rest = [];
rest[_i - 1] = arguments[_i];
}
return selector.apply(void 0, __spreadArray([t(value) ? D(value) : value],
rest));
};
return wrappedSelector;
};
// src/configureStore.ts
// src/devtoolsExtension.ts
var composeWithDevTools = typeof window !== "undefined" &&

window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ?
window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function () {
if (arguments.length === 0)
return void 0;
if (typeof arguments[0] === "object")
return compose;
return compose.apply(null, arguments);
};
var devToolsEnhancer = typeof window !== "undefined" &&
window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ :
function () {
return function (noop2) {
return noop2;
};
};
// src/isPlainObject.ts
function redux_toolkit_esm_isPlainObject(value) {
if (typeof value !== "object" || value === null)
return false;
var proto = Object.getPrototypeOf(value);
if (proto === null)
return true;
var baseProto = proto;
while (Object.getPrototypeOf(baseProto) !== null) {
baseProto = Object.getPrototypeOf(baseProto);
}
return proto === baseProto;
}
// src/getDefaultMiddleware.ts
// src/utils.ts
function getTimeMeasureUtils(maxDelay, fnName) {
var elapsed = 0;
return {
measureTime: function (fn) {
var started = Date.now();
try {
return fn();
}
finally {
var finished = Date.now();
elapsed += finished - started;
}
},
warnIfExceeded: function () {
if (elapsed > maxDelay) {
console.warn(fnName + " took " + elapsed + "ms, which is more than
the warning threshold of " + maxDelay + "ms. \nIf your state or actions are very
large, you may want to disable the middleware as it might cause too much of a
slowdown in development mode. See
https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.\nIt is
disabled in production builds, so you don't need to worry about that.");
}
}
};
}
var MiddlewareArray = /** @class */ (function (_super) {
__extends(MiddlewareArray, _super);
function MiddlewareArray() {
var args = [];
}
var _this = _super.apply(this, args) || this;
Object.setPrototypeOf(_this, MiddlewareArray.prototype);
return _this;
}
Object.defineProperty(MiddlewareArray, Symbol.species, {
get: function () {
return MiddlewareArray;
},
enumerable: false,
configurable: true
});
MiddlewareArray.prototype.concat = function () {
var arr = [];
arr[_i] = arguments[_i];
}
return _super.prototype.concat.apply(this, arr);
};
MiddlewareArray.prototype.prepend = function () {
var arr = [];
arr[_i] = arguments[_i];
}
if (arr.length === 1 && Array.isArray(arr[0])) {
return new (MiddlewareArray.bind.apply(MiddlewareArray,
__spreadArray([void 0], arr[0].concat(this))))();
}
return new (MiddlewareArray.bind.apply(MiddlewareArray, __spreadArray([void
0], arr.concat(this))))();
};
return MiddlewareArray;
}(Array));
// src/immutableStateInvariantMiddleware.ts
var isProduction = "production" === "production";
var prefix = "Invariant failed";
function invariant(condition, message) {
if (condition) {
return;
}
if (isProduction) {
throw new Error(prefix);
}
throw new Error(prefix + ": " + (message || ""));
}
function stringify(obj, serializer, indent, decycler) {
return JSON.stringify(obj, getSerialize(serializer, decycler), indent);
}
function getSerialize(serializer, decycler) {
var stack = [], keys = [];
if (!decycler)
decycler = function (_, value) {
if (stack[0] === value)
return "[Circular ~]";
return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") +
"]";
};
return function (key, value) {
if (stack.length > 0) {
var thisPos = stack.indexOf(this);
~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
if (~stack.indexOf(value))
value = decycler.call(this, key, value);
}
else
stack.push(value);
return serializer == null ? value : serializer.call(this, key, value);
};
}
function isImmutableDefault(value) {
return typeof value !== "object" || value === null || typeof value ===
"undefined" || Object.isFrozen(value);
}
function trackForMutations(isImmutable, ignorePaths, obj) {
var trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
return {
detectMutations: function () {
return detectMutations(isImmutable, ignorePaths, trackedProperties,
obj);
}
};
}
function trackProperties(isImmutable, ignorePaths, obj, path) {
if (ignorePaths === void 0) { ignorePaths = []; }
if (path === void 0) { path = ""; }
var tracked = { value: obj };
if (!isImmutable(obj)) {
tracked.children = {};
var childPath = path ? path + "." + key : key;
if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
continue;
}
tracked.children[key] = trackProperties(isImmutable, ignorePaths,
obj[key], childPath);
}
}
return tracked;
}
function detectMutations(isImmutable, ignorePaths, trackedProperty, obj,
sameParentRef, path) {
if (ignorePaths === void 0) { ignorePaths = []; }
if (sameParentRef === void 0) { sameParentRef = false; }
var prevObj = trackedProperty ? trackedProperty.value : void 0;
var sameRef = prevObj === obj;
if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
return { wasMutated: true, path: path };
}
if (isImmutable(prevObj) || isImmutable(obj)) {
return { wasMutated: false };
}
var keysToDetect = {};
for (var key in trackedProperty.children) {
keysToDetect[key] = true;
}
keysToDetect[key] = true;
}
for (var key in keysToDetect) {
var childPath = path ? path + "." + key : key;
if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
continue;
}
var result = detectMutations(isImmutable, ignorePaths,
trackedProperty.children[key], obj[key], sameRef, childPath);
if (result.wasMutated) {
return result;
}
}
return { wasMutated: false };
}
function createImmutableStateInvariantMiddleware(options) {
if (true) {
return function () { return function (next) { return function (action)
{ return next(action); }; }; };
}
var _c = options.isImmutable, isImmutable = _c === void 0 ?
isImmutableDefault : _c, ignoredPaths = options.ignoredPaths, _d =
options.warnAfter, warnAfter = _d === void 0 ? 32 : _d, ignore = options.ignore;
ignoredPaths = ignoredPaths || ignore;
var track = trackForMutations.bind(null, isImmutable, ignoredPaths);
return function (_c) {
var getState = _c.getState;
var state = getState();
var tracker = track(state);
var result;
return function (next) { return function (action) {
var measureUtils = getTimeMeasureUtils(warnAfter,
"ImmutableStateInvariantMiddleware");
measureUtils.measureTime(function () {
state = getState();
result = tracker.detectMutations();
tracker = track(state);
invariant(!result.wasMutated, "A state mutation was detected
between dispatches, in the path '" + (result.path || "") + "'. This may cause
incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-
state)");
});
var dispatchedAction = next(action);
state = getState();
result = tracker.detectMutations();
tracker = track(state);
result.wasMutated && invariant(!result.wasMutated, "A state
mutation was detected inside a dispatch, in the path: " + (result.path || "") + ".
Take a look at the reducer(s) handling the action " + stringify(action) + ".
(https://redux.js.org/style-guide/style-guide#do-not-mutate-state)");
});
measureUtils.warnIfExceeded();
return dispatchedAction;
}; };
};
}
// src/serializableStateInvariantMiddleware.ts
function isPlain(val) {
var type = typeof val;
return type === "undefined" || val === null || type === "string" || type ===
"boolean" || type === "number" || Array.isArray(val) ||
redux_toolkit_esm_isPlainObject(val);
}
function findNonSerializableValue(value, path, isSerializable, getEntries,
ignoredPaths) {
if (isSerializable === void 0) { isSerializable = isPlain; }
if (ignoredPaths === void 0) { ignoredPaths = []; }
var foundNestedSerializable;
if (!isSerializable(value)) {
return {
keyPath: path || "<root>",
value: value
};
}
if (typeof value !== "object" || value === null) {
return false;
}
var entries = getEntries != null ? getEntries(value) : Object.entries(value);
var hasIgnoredPaths = ignoredPaths.length > 0;
for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
var _c = entries_1[_i], key = _c[0], nestedValue = _c[1];
var nestedPath = path ? path + "." + key : key;
if (hasIgnoredPaths && ignoredPaths.indexOf(nestedPath) >= 0) {
continue;
}
if (!isSerializable(nestedValue)) {
return {
keyPath: nestedPath,
value: nestedValue
};
}
if (typeof nestedValue === "object") {
foundNestedSerializable = findNonSerializableValue(nestedValue,
nestedPath, isSerializable, getEntries, ignoredPaths);
if (foundNestedSerializable) {
return foundNestedSerializable;
}
}
}
return false;
}
function createSerializableStateInvariantMiddleware(options) {
if (true) {
return function () { return function (next) { return function (action)
{ return next(action); }; }; };
}
var _c = options.isSerializable, isSerializable = _c === void 0 ? isPlain : _c,
getEntries = options.getEntries, _d = options.ignoredActions, ignoredActions = _d
=== void 0 ? [] : _d, _e = options.ignoredActionPaths, ignoredActionPaths = _e ===
void 0 ? ["meta.arg", "meta.baseQueryMeta"] : _e, _f = options.ignoredPaths,
ignoredPaths = _f === void 0 ? [] : _f, _g = options.warnAfter, warnAfter = _g ===
void 0 ? 32 : _g, _h = options.ignoreState, ignoreState = _h === void 0 ? false :
_h, _j = options.ignoreActions, ignoreActions = _j === void 0 ? false : _j;
return function (storeAPI) { return function (next) { return function (action)
{
var result = next(action);
var measureUtils = getTimeMeasureUtils(warnAfter,
"SerializableStateInvariantMiddleware");
if (!ignoreActions && !(ignoredActions.length &&
ignoredActions.indexOf(action.type) !== -1)) {
var foundActionNonSerializableValue =
findNonSerializableValue(action, "", isSerializable, getEntries,
ignoredActionPaths);
if (foundActionNonSerializableValue) {
var keyPath = foundActionNonSerializableValue.keyPath, value =
foundActionNonSerializableValue.value;
console.error("A non-serializable value was detected in an
action, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the logic
that dispatched this action: ", action, "\n(See
https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-
serializable-why-should-my-action-types-be-constants)", "\n(To allow non-
serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-
with-non-serializable-data)");
}
});
}
if (!ignoreState) {
var state = storeAPI.getState();
var foundStateNonSerializableValue =
findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths);
if (foundStateNonSerializableValue) {
var keyPath = foundStateNonSerializableValue.keyPath, value =
foundStateNonSerializableValue.value;
console.error("A non-serializable value was detected in the
state, in the path: `" + keyPath + "`. Value:", value, "\nTake a look at the
reducer(s) handling this action type: " + action.type + ".\n(See
https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-
non-serializable-items-in-my-store-state)");
}
});
measureUtils.warnIfExceeded();
}
return result;
}; }; };
}
// src/getDefaultMiddleware.ts
function isBoolean(x) {
return typeof x === "boolean";
}
function curryGetDefaultMiddleware() {
return function curriedGetDefaultMiddleware(options) {
return getDefaultMiddleware(options);
};
}
function getDefaultMiddleware(options) {
var _c = options.thunk, thunk = _c === void 0 ? true : _c, _d =
options.immutableCheck, immutableCheck = _d === void 0 ? true : _d, _e =
options.serializableCheck, serializableCheck = _e === void 0 ? true : _e;
var middlewareArray = new MiddlewareArray();
if (thunk) {
if (isBoolean(thunk)) {
middlewareArray.push(redux_thunk_es/* default */.Z);
}
else {
middlewareArray.push(redux_thunk_es/* default.withExtraArgument
*/.Z.withExtraArgument(thunk.extraArgument));
}
}
if (false) { var serializableOptions, immutableOptions; }
return middlewareArray;
}
// src/configureStore.ts
var IS_PRODUCTION = "production" === "production";
function configureStore(options) {
var curriedGetDefaultMiddleware = curryGetDefaultMiddleware();
var _c = options || {}, _d = _c.reducer, reducer = _d === void 0 ? void 0 : _d,
_e = _c.middleware, middleware = _e === void 0 ? curriedGetDefaultMiddleware() :
_e, _f = _c.devTools, devTools = _f === void 0 ? true : _f, _g = _c.preloadedState,
preloadedState = _g === void 0 ? void 0 : _g, _h = _c.enhancers, enhancers = _h ===
void 0 ? void 0 : _h;
var rootReducer;
if (typeof reducer === "function") {
rootReducer = reducer;
}
else if (redux_toolkit_esm_isPlainObject(reducer)) {
rootReducer = combineReducers(reducer);
}
else {
throw new Error('"reducer" is a required argument, and must be a function
or an object of functions that can be passed to combineReducers');
}
var finalMiddleware = middleware;
if (typeof finalMiddleware === "function") {
finalMiddleware = finalMiddleware(curriedGetDefaultMiddleware);
if (!IS_PRODUCTION && !Array.isArray(finalMiddleware)) {
throw new Error("when using a middleware builder function, an array of
middleware must be returned");
}
}
if (!IS_PRODUCTION && finalMiddleware.some(function (item) { return typeof item
!== "function"; })) {
throw new Error("each middleware provided to configureStore must be a
function");
}
var middlewareEnhancer = applyMiddleware.apply(void 0, finalMiddleware);
var finalCompose = compose;
if (devTools) {
finalCompose = composeWithDevTools(__spreadValues({
trace: !IS_PRODUCTION
}, typeof devTools === "object" && devTools));
}
var storeEnhancers = [middlewareEnhancer];
if (Array.isArray(enhancers)) {
storeEnhancers = __spreadArray([middlewareEnhancer], enhancers);
}
else if (typeof enhancers === "function") {
storeEnhancers = enhancers(storeEnhancers);
}
var composedEnhancer = finalCompose.apply(void 0, storeEnhancers);
return createStore(rootReducer, preloadedState, composedEnhancer);
}
// src/createAction.ts
function createAction(type, prepareAction) {
function actionCreator() {
var args = [];
}
if (prepareAction) {
var prepared = prepareAction.apply(void 0, args);
if (!prepared) {
throw new Error("prepareAction did not return an object");
}
return __spreadValues(__spreadValues({
type: type,
payload: prepared.payload
}, "meta" in prepared && { meta: prepared.meta }), "error" in prepared
&& { error: prepared.error });
}
return { type: type, payload: args[0] };
}
actionCreator.toString = function () { return "" + type; };
actionCreator.type = type;
actionCreator.match = function (action) { return action.type === type; };
return actionCreator;
}
function isFSA(action) {
return redux_toolkit_esm_isPlainObject(action) && typeof action.type ===
"string" && Object.keys(action).every(isValidKey);
}
function isValidKey(key) {
return ["type", "payload", "error", "meta"].indexOf(key) > -1;
}
function getType(actionCreator) {
return "" + actionCreator;
}
// src/createReducer.ts
// src/mapBuilders.ts
function executeReducerBuilderCallback(builderCallback) {
var actionsMap = {};
var actionMatchers = [];
var defaultCaseReducer;
var builder = {
addCase: function (typeOrActionCreator, reducer) {
if (false) {}
var type = typeof typeOrActionCreator === "string" ?
typeOrActionCreator : typeOrActionCreator.type;
if (type in actionsMap) {
throw new Error("addCase cannot be called with two reducers for the
same action type");
}
actionsMap[type] = reducer;
return builder;
},
addMatcher: function (matcher, reducer) {
if (false) {}
actionMatchers.push({ matcher: matcher, reducer: reducer });
return builder;
},
addDefaultCase: function (reducer) {
if (false) {}
defaultCaseReducer = reducer;
return builder;
}
};
builderCallback(builder);
return [actionsMap, actionMatchers, defaultCaseReducer];
}
// src/createReducer.ts
function isStateFunction(x) {
return typeof x === "function";
}
function createReducer(initialState, mapOrBuilderCallback, actionMatchers,
defaultCaseReducer) {
if (actionMatchers === void 0) { actionMatchers = []; }
var _c = typeof mapOrBuilderCallback === "function" ?
executeReducerBuilderCallback(mapOrBuilderCallback) : [mapOrBuilderCallback,
actionMatchers, defaultCaseReducer], actionsMap = _c[0], finalActionMatchers =
_c[1], finalDefaultCaseReducer = _c[2];
var getInitialState;
if (isStateFunction(initialState)) {
getInitialState = function () { return immer_esm(initialState(), function
() {
}); };
}
else {
var frozenInitialState_1 = immer_esm(initialState, function () {
});
getInitialState = function () { return frozenInitialState_1; };
}
function reducer(state, action) {
if (state === void 0) { state = getInitialState(); }
var caseReducers = __spreadArray([
actionsMap[action.type]
], finalActionMatchers.filter(function (_c) {
var matcher = _c.matcher;
return matcher(action);
}).map(function (_c) {
var reducer2 = _c.reducer;
return reducer2;
}));
if (caseReducers.filter(function (cr) { return !!cr; }).length === 0) {
caseReducers = [finalDefaultCaseReducer];
}
return caseReducers.reduce(function (previousState, caseReducer) {
if (caseReducer) {
if (t(previousState)) {
var draft = previousState;
var result = caseReducer(draft, action);
if (typeof result === "undefined") {
}
return result;
}
else if (!r(previousState)) {
var result = caseReducer(previousState, action);
if (typeof result === "undefined") {
if (previousState === null) {
}
throw Error("A case reducer on a non-draftable value must
not return undefined");
}
return result;
}
else {
return immer_esm(previousState, function (draft) {
return caseReducer(draft, action);
});
}
}
}, state);
}
reducer.getInitialState = getInitialState;
return reducer;
}
// src/createSlice.ts
function getType2(slice, actionKey) {
return slice + "/" + actionKey;
}
function createSlice(options) {
var name = options.name;
if (!name) {
throw new Error("`name` is a required option for createSlice");
}
var initialState = typeof options.initialState == "function" ?
options.initialState : immer_esm(options.initialState, function () {
});
var reducers = options.reducers || {};
var reducerNames = Object.keys(reducers);
var sliceCaseReducersByName = {};
var sliceCaseReducersByType = {};
var actionCreators = {};
reducerNames.forEach(function (reducerName) {
var maybeReducerWithPrepare = reducers[reducerName];
var type = getType2(name, reducerName);
var caseReducer;
var prepareCallback;
if ("reducer" in maybeReducerWithPrepare) {
caseReducer = maybeReducerWithPrepare.reducer;
prepareCallback = maybeReducerWithPrepare.prepare;
}
else {
caseReducer = maybeReducerWithPrepare;
}
sliceCaseReducersByName[reducerName] = caseReducer;
sliceCaseReducersByType[type] = caseReducer;
actionCreators[reducerName] = prepareCallback ? createAction(type,
prepareCallback) : createAction(type);
});
function buildReducer() {
var _c = typeof options.extraReducers === "function" ?
executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers], _d
= _c[0], extraReducers = _d === void 0 ? {} : _d, _e = _c[1], actionMatchers = _e
=== void 0 ? [] : _e, _f = _c[2], defaultCaseReducer = _f === void 0 ? void 0 : _f;
var finalCaseReducers = __spreadValues(__spreadValues({}, extraReducers),
sliceCaseReducersByType);
return createReducer(initialState, finalCaseReducers, actionMatchers,
defaultCaseReducer);
}
var _reducer;
return {
name: name,
reducer: function (state, action) {
if (!_reducer)
_reducer = buildReducer();
return _reducer(state, action);
},
actions: actionCreators,
caseReducers: sliceCaseReducersByName,
getInitialState: function () {
if (!_reducer)
_reducer = buildReducer();
return _reducer.getInitialState();
}
};
}
// src/entities/entity_state.ts
function getInitialEntityState() {
return {
ids: [],
entities: {}
};
}
function createInitialStateFactory() {
function getInitialState(additionalState) {
if (additionalState === void 0) { additionalState = {}; }
return Object.assign(getInitialEntityState(), additionalState);
}
return { getInitialState: getInitialState };
}
// src/entities/state_selectors.ts
function createSelectorsFactory() {
function getSelectors(selectState) {
var selectIds = function (state) { return state.ids; };
var selectEntities = function (state) { return state.entities; };
var selectAll = createDraftSafeSelector(selectIds, selectEntities, function
(ids, entities) { return ids.map(function (id) { return entities[id]; }); });
var selectId = function (_, id) { return id; };
var selectById = function (entities, id) { return entities[id]; };
var selectTotal = createDraftSafeSelector(selectIds, function (ids)
{ return ids.length; });
if (!selectState) {
return {
selectIds: selectIds,
selectEntities: selectEntities,
selectAll: selectAll,
selectTotal: selectTotal,
selectById: createDraftSafeSelector(selectEntities, selectId,
selectById)
};
}
var selectGlobalizedEntities = createDraftSafeSelector(selectState,
selectEntities);
return {
selectIds: createDraftSafeSelector(selectState, selectIds),
selectEntities: selectGlobalizedEntities,
selectAll: createDraftSafeSelector(selectState, selectAll),
selectTotal: createDraftSafeSelector(selectState, selectTotal),
selectById: createDraftSafeSelector(selectGlobalizedEntities, selectId,
selectById)
};
}
return { getSelectors: getSelectors };
}
// src/entities/state_adapter.ts
function createSingleArgumentStateOperator(mutator) {
var operator = createStateOperator(function (_, state) { return mutator(state);
});
return function operation(state) {
return operator(state, void 0);
};
}
function createStateOperator(mutator) {
return function operation(state, arg) {
function isPayloadActionArgument(arg2) {
return isFSA(arg2);
}
var runMutator = function (draft) {
if (isPayloadActionArgument(arg)) {
mutator(arg.payload, draft);
}
else {
mutator(arg, draft);
}
};
if (t(state)) {
runMutator(state);
return state;
}
else {
return immer_esm(state, runMutator);
}
};
}
// src/entities/utils.ts
function selectIdValue(entity, selectId) {
var key = selectId(entity);
if (false) {}
return key;
}
function ensureEntitiesArray(entities) {
if (!Array.isArray(entities)) {
entities = Object.values(entities);
}
return entities;
}
function splitAddedUpdatedEntities(newEntities, selectId, state) {
newEntities = ensureEntitiesArray(newEntities);
var added = [];
var updated = [];
for (var _i = 0, newEntities_1 = newEntities; _i < newEntities_1.length; _i++)
{
var entity = newEntities_1[_i];
var id = selectIdValue(entity, selectId);
if (id in state.entities) {
updated.push({ id: id, changes: entity });
}
else {
added.push(entity);
}
}
return [added, updated];
}
// src/entities/unsorted_state_adapter.ts
function createUnsortedStateAdapter(selectId) {
function addOneMutably(entity, state) {
var key = selectIdValue(entity, selectId);
if (key in state.entities) {
return;
}
state.ids.push(key);
state.entities[key] = entity;
}
function addManyMutably(newEntities, state) {
for (var _i = 0, newEntities_2 = newEntities; _i < newEntities_2.length;
_i++) {
addOneMutably(entity, state);
}
}
function setOneMutably(entity, state) {
var key = selectIdValue(entity, selectId);
if (!(key in state.entities)) {
state.ids.push(key);
}
state.entities[key] = entity;
}
function setManyMutably(newEntities, state) {
for (var _i = 0, newEntities_3 = newEntities; _i < newEntities_3.length;
_i++) {
setOneMutably(entity, state);
}
}
function setAllMutably(newEntities, state) {
state.ids = [];
state.entities = {};
addManyMutably(newEntities, state);
}
function removeOneMutably(key, state) {
return removeManyMutably([key], state);
}
function removeManyMutably(keys, state) {
var didMutate = false;
keys.forEach(function (key) {
if (key in state.entities) {
delete state.entities[key];
didMutate = true;
}
});
if (didMutate) {
state.ids = state.ids.filter(function (id) { return id in
state.entities; });
}
}
function removeAllMutably(state) {
Object.assign(state, {
ids: [],
entities: {}
});
}
function takeNewKey(keys, update, state) {
var original2 = state.entities[update.id];
var updated = Object.assign({}, original2, update.changes);
var newKey = selectIdValue(updated, selectId);
var hasNewKey = newKey !== update.id;
if (hasNewKey) {
keys[update.id] = newKey;
delete state.entities[update.id];
}
state.entities[newKey] = updated;
return hasNewKey;
}
function updateOneMutably(update, state) {
return updateManyMutably([update], state);
}
function updateManyMutably(updates, state) {
var newKeys = {};
var updatesPerEntity = {};
updates.forEach(function (update) {
if (update.id in state.entities) {
updatesPerEntity[update.id] = {
id: update.id,
changes: __spreadValues(__spreadValues({},
updatesPerEntity[update.id] ? updatesPerEntity[update.id].changes : null),
update.changes)
};
}
});
updates = Object.values(updatesPerEntity);
var didMutateEntities = updates.length > 0;
if (didMutateEntities) {
var didMutateIds = updates.filter(function (update) { return
takeNewKey(newKeys, update, state); }).length > 0;
if (didMutateIds) {
state.ids = state.ids.map(function (id) { return newKeys[id] || id;
});
}
}
}
function upsertOneMutably(entity, state) {
return upsertManyMutably([entity], state);
}
function upsertManyMutably(newEntities, state) {
var _c = splitAddedUpdatedEntities(newEntities, selectId, state), added =
_c[0], updated = _c[1];
updateManyMutably(updated, state);
addManyMutably(added, state);
}
return {
removeAll: createSingleArgumentStateOperator(removeAllMutably),
addOne: createStateOperator(addOneMutably),
addMany: createStateOperator(addManyMutably),
setOne: createStateOperator(setOneMutably),
setMany: createStateOperator(setManyMutably),
setAll: createStateOperator(setAllMutably),
updateOne: createStateOperator(updateOneMutably),
updateMany: createStateOperator(updateManyMutably),
upsertOne: createStateOperator(upsertOneMutably),
upsertMany: createStateOperator(upsertManyMutably),
removeOne: createStateOperator(removeOneMutably),
removeMany: createStateOperator(removeManyMutably)
};
}
// src/entities/sorted_state_adapter.ts
function createSortedStateAdapter(selectId, sort) {
var _c = createUnsortedStateAdapter(selectId), removeOne = _c.removeOne,
removeMany = _c.removeMany, removeAll = _c.removeAll;
function addOneMutably(entity, state) {
return addManyMutably([entity], state);
}
function addManyMutably(newEntities, state) {
var models = newEntities.filter(function (model) { return !
(selectIdValue(model, selectId) in state.entities); });
if (models.length !== 0) {
merge(models, state);
}
}
function setOneMutably(entity, state) {
return setManyMutably([entity], state);
}
function setManyMutably(newEntities, state) {
if (newEntities.length !== 0) {
merge(newEntities, state);
}
}
function setAllMutably(newEntities, state) {
state.entities = {};
state.ids = [];
addManyMutably(newEntities, state);
}
function updateOneMutably(update, state) {
return updateManyMutably([update], state);
}
function takeUpdatedModel(models, update, state) {
if (!(update.id in state.entities)) {
return false;
}
var original2 = state.entities[update.id];
var updated = Object.assign({}, original2, update.changes);
var newKey = selectIdValue(updated, selectId);
delete state.entities[update.id];
models.push(updated);
return newKey !== update.id;
}
function updateManyMutably(updates, state) {
var models = [];
updates.forEach(function (update) { return takeUpdatedModel(models, update,
state); });
if (models.length !== 0) {
merge(models, state);
}
}
function upsertOneMutably(entity, state) {
return upsertManyMutably([entity], state);
}
function upsertManyMutably(newEntities, state) {
var _c = splitAddedUpdatedEntities(newEntities, selectId, state), added =
_c[0], updated = _c[1];
updateManyMutably(updated, state);
addManyMutably(added, state);
}
function areArraysEqual(a, b) {
if (a.length !== b.length) {
return false;
}
for (var i = 0; i < a.length && i < b.length; i++) {
if (a[i] === b[i]) {
continue;
}
return false;
}
return true;
}
function merge(models, state) {
models.forEach(function (model) {
state.entities[selectId(model)] = model;
});
var allEntities = Object.values(state.entities);
allEntities.sort(sort);
var newSortedIds = allEntities.map(selectId);
var ids = state.ids;
if (!areArraysEqual(ids, newSortedIds)) {
state.ids = newSortedIds;
}
}
return {
removeOne: removeOne,
removeMany: removeMany,
removeAll: removeAll,
addOne: createStateOperator(addOneMutably),
updateOne: createStateOperator(updateOneMutably),
upsertOne: createStateOperator(upsertOneMutably),
setOne: createStateOperator(setOneMutably),
setMany: createStateOperator(setManyMutably),
setAll: createStateOperator(setAllMutably),
addMany: createStateOperator(addManyMutably),
updateMany: createStateOperator(updateManyMutably),
upsertMany: createStateOperator(upsertManyMutably)
};
}
// src/entities/create_adapter.ts
function createEntityAdapter(options) {
var _c = __spreadValues({
sortComparer: false,
selectId: function (instance) { return instance.id; }
}, options), selectId = _c.selectId, sortComparer = _c.sortComparer;
var stateFactory = createInitialStateFactory();
var selectorsFactory = createSelectorsFactory();
var stateAdapter = sortComparer ? createSortedStateAdapter(selectId,
sortComparer) : createUnsortedStateAdapter(selectId);
return __spreadValues(__spreadValues(__spreadValues({
selectId: selectId,
sortComparer: sortComparer
}, stateFactory), selectorsFactory), stateAdapter);
}
// src/nanoid.ts
var urlAlphabet = "ModuleSymbhasOwnPr-
0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
var nanoid = function (size) {
if (size === void 0) { size = 21; }
var id = "";
var i = size;
while (i--) {
id += urlAlphabet[Math.random() * 64 | 0];
}
return id;
};
// src/createAsyncThunk.ts
var commonProperties = [
"name",
"message",
"stack",
"code"
];
var RejectWithValue = /** @class */ (function () {
function RejectWithValue(payload, meta) {
this.payload = payload;
this.meta = meta;
}
return RejectWithValue;
}());
var FulfillWithMeta = /** @class */ (function () {
function FulfillWithMeta(payload, meta) {
this.payload = payload;
this.meta = meta;
}
return FulfillWithMeta;
}());
var miniSerializeError = function (value) {
if (typeof value === "object" && value !== null) {
var simpleError = {};
for (var _i = 0, commonProperties_1 = commonProperties; _i <
commonProperties_1.length; _i++) {
var property = commonProperties_1[_i];
if (typeof value[property] === "string") {
simpleError[property] = value[property];
}
}
return simpleError;
}
return { message: String(value) };
};
function createAsyncThunk(typePrefix, payloadCreator, options) {
var fulfilled = createAction(typePrefix + "/fulfilled", function (payload,
requestId, arg, meta) { return ({
payload: payload,
meta: __spreadProps(__spreadValues({}, meta || {}), {
arg: arg,
requestId: requestId,
requestStatus: "fulfilled"
})
}); });
var pending = createAction(typePrefix + "/pending", function (requestId, arg,
meta) { return ({
payload: void 0,
arg: arg,
requestStatus: "pending"
})
}); });
var rejected = createAction(typePrefix + "/rejected", function (error,
requestId, arg, payload, meta) { return ({
payload: payload,
error: (options && options.serializeError || miniSerializeError)(error ||
"Rejected"),
arg: arg,
rejectedWithValue: !!payload,
requestStatus: "rejected",
aborted: (error == null ? void 0 : error.name) === "AbortError",
condition: (error == null ? void 0 : error.name) === "ConditionError"
})
}); });
var displayedWarning = false;
var AC = typeof AbortController !== "undefined" ? AbortController : /** @class
*/ (function () {
function class_1() {
this.signal = {
aborted: false,
addEventListener: function () {
},
dispatchEvent: function () {
return false;
},
onabort: function () {
},
removeEventListener: function () {
}
};
}
class_1.prototype.abort = function () {
if (false) {}
};
return class_1;
}());
function actionCreator(arg) {
return function (dispatch, getState, extra) {
var requestId = (options == null ? void 0 : options.idGenerator) ?
options.idGenerator(arg) : nanoid();
var abortController = new AC();
var abortReason;
var abortedPromise = new Promise(function (_, reject) { return
abortController.signal.addEventListener("abort", function () { return
reject({ name: "AbortError", message: abortReason || "Aborted" }); }); });
var started = false;
function abort(reason) {
if (started) {
abortReason = reason;
abortController.abort();
}
}
var promise = function () {
return __async(this, null, function () {
var _a, _b, finalAction, conditionResult, err_1, skipDispatch;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_c.trys.push([0, 4, , 5]);
conditionResult = (_a = options == null ? void 0 :
options.condition) == null ? void 0 : _a.call(options, arg, { getState: getState,
extra: extra });
if (!isThenable(conditionResult)) return [3
/*break*/, 2];
return [4 /*yield*/, conditionResult];
case 1:
conditionResult = _c.sent();
_c.label = 2;
case 2:
if (conditionResult === false) {
throw {
name: "ConditionError",
message: "Aborted due to condition callback
returning false."
};
}
started = true;
dispatch(pending(requestId, arg, (_b = options ==
null ? void 0 : options.getPendingMeta) == null ? void 0 : _b.call(options,
{ requestId: requestId, arg: arg }, { getState: getState, extra: extra })));
return [4 /*yield*/, Promise.race([
abortedPromise,
Promise.resolve(payloadCreator(arg, {
dispatch: dispatch,
getState: getState,
extra: extra,
signal: abortController.signal,
rejectWithValue: function (value, meta)
{
return new RejectWithValue(value,
meta);
},
fulfillWithValue: function (value,
meta) {
return new FulfillWithMeta(value,
meta);
}
})).then(function (result) {
if (result instanceof RejectWithValue)
{
throw result;
}
if (result instanceof FulfillWithMeta)
{
return fulfilled(result.payload,
requestId, arg, result.meta);
}
return fulfilled(result, requestId,
arg);
})
])];
case 3:
finalAction = _c.sent();
return [3 /*break*/, 5];
case 4:
err_1 = _c.sent();
finalAction = err_1 instanceof RejectWithValue ?
rejected(null, requestId, arg, err_1.payload, err_1.meta) : rejected(err_1,
requestId, arg);
case 5:
skipDispatch = options && !
options.dispatchConditionRejection && rejected.match(finalAction) &&
finalAction.meta.condition;
if (!skipDispatch) {
dispatch(finalAction);
}
return [2 /*return*/, finalAction];
}
});
});
}();
return Object.assign(promise, {
abort: abort,
arg: arg,
unwrap: function () {
return promise.then(unwrapResult);
}
});
};
}
return Object.assign(actionCreator, {
pending: pending,
rejected: rejected,
fulfilled: fulfilled,
typePrefix: typePrefix
});
}
function unwrapResult(action) {
if (action.meta && action.meta.rejectedWithValue) {
throw action.payload;
}
if (action.error) {
throw action.error;
}
return action.payload;
}
function isThenable(value) {
return value !== null && typeof value === "object" && typeof value.then ===
"function";
}
// src/tsHelpers.ts
var hasMatchFunction = function (v) {
return v && typeof v.match === "function";
};
// src/matchers.ts
var matches = function (matcher, action) {
if (hasMatchFunction(matcher)) {
return matcher.match(action);
}
else {
return matcher(action);
}
};
function isAnyOf() {
var matchers = [];
matchers[_i] = arguments[_i];
}
return function (action) {
return matchers.some(function (matcher) { return matches(matcher,
action); });
};
}
function isAllOf() {
var matchers = [];
matchers[_i] = arguments[_i];
}
return matchers.every(function (matcher) { return matches(matcher, action);
});
};
}
function hasExpectedRequestMetadata(action, validStatus) {
if (!action || !action.meta)
return false;
var hasValidRequestId = typeof action.meta.requestId === "string";
var hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -
1;
return hasValidRequestId && hasValidRequestStatus;
}
function isAsyncThunkArray(a) {
return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0]
&& "rejected" in a[0];
}
function isPending() {
var asyncThunks = [];
asyncThunks[_i] = arguments[_i];
}
if (asyncThunks.length === 0) {
return function (action) { return hasExpectedRequestMetadata(action,
["pending"]); };
}
if (!isAsyncThunkArray(asyncThunks)) {
return isPending()(asyncThunks[0]);
}
var matchers = asyncThunks.map(function (asyncThunk) { return
asyncThunk.pending; });
var combinedMatcher = isAnyOf.apply(void 0, matchers);
return combinedMatcher(action);
};
}
function isRejected() {
}
["rejected"]); };
}
return isRejected()(asyncThunks[0]);
}
asyncThunk.rejected; });
};
}
function isRejectedWithValue() {
}
var hasFlag = function (action) {
return action && action.meta && action.meta.rejectedWithValue;
};
var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks),
hasFlag);
};
}
return isRejectedWithValue()(asyncThunks[0]);
}
var combinedMatcher = isAllOf(isRejected.apply(void 0, asyncThunks),
hasFlag);
};
}
function isFulfilled() {
}
["fulfilled"]); };
}
return isFulfilled()(asyncThunks[0]);
}
asyncThunk.fulfilled; });
};
}
function isAsyncThunkAction() {
}
["pending", "fulfilled", "rejected"]); };
}
return isAsyncThunkAction()(asyncThunks[0]);
}
var matchers = [];
for (var _i = 0, asyncThunks_1 = asyncThunks; _i < asyncThunks_1.length;
_i++) {
var asyncThunk = asyncThunks_1[_i];
matchers.push(asyncThunk.pending, asyncThunk.rejected,
asyncThunk.fulfilled);
}
};
}
// src/listenerMiddleware/utils.ts
var assertFunction = function (func, expected) {
if (typeof func !== "function") {
throw new TypeError(expected + " is not a function");
}
};
var noop = function () {
};
var catchRejection = function (promise, onError) {
if (onError === void 0) { onError = noop; }
promise.catch(onError);
return promise;
};
var addAbortSignalListener = function (abortSignal, callback) {
abortSignal.addEventListener("abort", callback, { once: true });
};
var abortControllerWithReason = function (abortController, reason) {
var signal = abortController.signal;
if (signal.aborted) {
return;
}
if (!("reason" in signal)) {
Object.defineProperty(signal, "reason", {
enumerable: true,
value: reason,
configurable: true,
writable: true
});
}
;
abortController.abort(reason);
};
// src/listenerMiddleware/exceptions.ts
var task = "task";
var listener = "listener";
var completed = "completed";
var cancelled = "cancelled";
var taskCancelled = "task-" + cancelled;
var taskCompleted = "task-" + completed;
var listenerCancelled = listener + "-" + cancelled;
var listenerCompleted = listener + "-" + completed;
var TaskAbortError = /** @class */ (function () {
function TaskAbortError(code) {
this.code = code;
this.name = "TaskAbortError";
this.message = task + " " + cancelled + " (reason: " + code + ")";
}
return TaskAbortError;
}());
// src/listenerMiddleware/task.ts
var validateActive = function (signal) {
throw new TaskAbortError(signal.reason);
}
};
var promisifyAbortSignal = function (signal) {
return catchRejection(new Promise(function (_, reject) {
var notifyRejection = function () { return reject(new
TaskAbortError(signal.reason)); };
notifyRejection();
}
else {
addAbortSignalListener(signal, notifyRejection);
}
}));
};
var runTask = function (task2, cleanUp) { return __async(void 0, null, function ()
{
var value, error_1;
switch (_c.label) {
case 0:
_c.trys.push([0, 3, 4, 5]);
return [4 /*yield*/, Promise.resolve()];
case 1:
_c.sent();
return [4 /*yield*/, task2()];
case 2:
value = _c.sent();
return [2 /*return*/, {
status: "ok",
value: value
}];
case 3:
error_1 = _c.sent();
return [2 /*return*/, {
status: error_1 instanceof TaskAbortError ? "cancelled" :
"rejected",
error: error_1
}];
case 4:
cleanUp == null ? void 0 : cleanUp();
return [7 /*endfinally*/];
case 5: return [2 /*return*/];
}
});
}); };
var createPause = function (signal) {
return function (promise) {
return catchRejection(Promise.race([promisifyAbortSignal(signal),
promise]).then(function (output) {
validateActive(signal);
return output;
}));
};
};
var createDelay = function (signal) {
var pause = createPause(signal);
return function (timeoutMs) {
return pause(new Promise(function (resolve) { return setTimeout(resolve,
timeoutMs); }));
};
};
// src/listenerMiddleware/index.ts
var redux_toolkit_esm_assign = Object.assign;
var INTERNAL_NIL_TOKEN = {};
var alm = "listenerMiddleware";
var createFork = function (parentAbortSignal) {
var linkControllers = function (controller) { return
addAbortSignalListener(parentAbortSignal, function () { return
abortControllerWithReason(controller, parentAbortSignal.reason); }); };
return function (taskExecutor) {
assertFunction(taskExecutor, "taskExecutor");
var childAbortController = new AbortController();
linkControllers(childAbortController);
var result = runTask(function () { return __async(void 0, null, function ()
{
var result2;
switch (_c.label) {
case 0:
validateActive(parentAbortSignal);
validateActive(childAbortController.signal);
return [4 /*yield*/, taskExecutor({
pause: createPause(childAbortController.signal),
delay: createDelay(childAbortController.signal),
signal: childAbortController.signal
})];
case 1:
result2 = _c.sent();
validateActive(childAbortController.signal);
return [2 /*return*/, result2];
}
});
}); }, function () { return abortControllerWithReason(childAbortController,
taskCompleted); });
return {
result: createPause(parentAbortSignal)(result),
cancel: function () {
abortControllerWithReason(childAbortController, taskCancelled);
}
};
};
};
var createTakePattern = function (startListening, signal) {
var take = function (predicate, timeout) { return __async(void 0, null,
function () {
var unsubscribe, tuplePromise, promises, output;
switch (_c.label) {
case 0:
unsubscribe = function () {
};
tuplePromise = new Promise(function (resolve) {
unsubscribe = startListening({
predicate: predicate,
effect: function (action, listenerApi) {
listenerApi.unsubscribe();
resolve([
action,
listenerApi.getState(),
listenerApi.getOriginalState()
]);
}
});
});
promises = [
promisifyAbortSignal(signal),
tuplePromise
];
if (timeout != null) {
promises.push(new Promise(function (resolve) { return
setTimeout(resolve, timeout, null); }));
}
_c.label = 1;
case 1:
_c.trys.push([1, , 3, 4]);
return [4 /*yield*/, Promise.race(promises)];
case 2:
output = _c.sent();
return [2 /*return*/, output];
case 3:
unsubscribe();
}
});
}); };
return function (predicate, timeout) { return catchRejection(take(predicate,
timeout)); };
};
var getListenerEntryPropsFrom = function (options) {
var type = options.type, actionCreator = options.actionCreator, matcher =
options.matcher, predicate = options.predicate, effect = options.effect;
if (type) {
predicate = createAction(type).match;
}
else if (actionCreator) {
type = actionCreator.type;
predicate = actionCreator.match;
}
else if (matcher) {
predicate = matcher;
}
else if (predicate) {
}
else {
throw new Error("Creating or removing a listener requires one of the known
fields for matching an action");
}
assertFunction(effect, "options.listener");
return { predicate: predicate, type: type, effect: effect };
};
var createListenerEntry = function (options) {
var _c = getListenerEntryPropsFrom(options), type = _c.type, predicate =
_c.predicate, effect = _c.effect;
var id = nanoid();
var entry = {
id: id,
effect: effect,
type: type,
predicate: predicate,
pending: new Set(),
unsubscribe: function () {
throw new Error("Unsubscribe not initialized");
}
};
return entry;
};
var createClearListenerMiddleware = function (listenerMap) {
listenerMap.forEach(cancelActiveListeners);
listenerMap.clear();
};
};
var safelyNotifyError = function (errorHandler, errorToNotify, errorInfo) {
try {
errorHandler(errorToNotify, errorInfo);
}
catch (errorHandlerError) {
throw errorHandlerError;
}, 0);
}
};
var addListener = createAction(alm + "/add");
var clearAllListeners = createAction(alm + "/removeAll");
var removeListener = createAction(alm + "/remove");
var defaultErrorHandler = function () {
var args = [];
}
console.error.apply(console, __spreadArray([alm + "/error"], args));
};
var cancelActiveListeners = function (entry) {
entry.pending.forEach(function (controller) {
abortControllerWithReason(controller, listenerCancelled);
});
};
function createListenerMiddleware(middlewareOptions) {
var _this = this;
if (middlewareOptions === void 0) { middlewareOptions = {}; }
var listenerMap = new Map();
var extra = middlewareOptions.extra, _c = middlewareOptions.onError, onError =
_c === void 0 ? defaultErrorHandler : _c;
assertFunction(onError, "onError");
var insertEntry = function (entry) {
entry.unsubscribe = function () { return listenerMap.delete(entry.id); };
listenerMap.set(entry.id, entry);
return function (cancelOptions) {
entry.unsubscribe();
if (cancelOptions == null ? void 0 : cancelOptions.cancelActive) {
cancelActiveListeners(entry);
}
};
};
var findListenerEntry = function (comparator) {
for (var _i = 0, _c = Array.from(listenerMap.values()); _i < _c.length; _i+
+) {
var entry = _c[_i];
if (comparator(entry)) {
return entry;
}
}
return void 0;
};
var startListening = function (options) {
var entry = findListenerEntry(function (existingEntry) { return
existingEntry.effect === options.effect; });
if (!entry) {
entry = createListenerEntry(options);
}
return insertEntry(entry);
};
var stopListening = function (options) {
var _c = getListenerEntryPropsFrom(options), type = _c.type, effect =
_c.effect, predicate = _c.predicate;
var entry = findListenerEntry(function (entry2) {
var matchPredicateOrType = typeof type === "string" ? entry2.type ===
type : entry2.predicate === predicate;
return matchPredicateOrType && entry2.effect === effect;
});
if (entry) {
entry.unsubscribe();
if (options.cancelActive) {
cancelActiveListeners(entry);
}
}
return !!entry;
};
var notifyListener = function (entry, action, api, getOriginalState) { return
__async(_this, null, function () {
var internalTaskController, take, listenerError_1;
switch (_c.label) {
case 0:
internalTaskController = new AbortController();
take = createTakePattern(startListening,
internalTaskController.signal);
_c.label = 1;
case 1:
_c.trys.push([1, 3, 4, 5]);
entry.pending.add(internalTaskController);
return [4 /*yield*/, Promise.resolve(entry.effect(action,
redux_toolkit_esm_assign({}, api, {
getOriginalState: getOriginalState,
condition: function (predicate, timeout) { return
take(predicate, timeout).then(Boolean); },
take: take,
delay: createDelay(internalTaskController.signal),
pause: createPause(internalTaskController.signal),
extra: extra,
signal: internalTaskController.signal,
fork: createFork(internalTaskController.signal),
unsubscribe: entry.unsubscribe,
subscribe: function () {
listenerMap.set(entry.id, entry);
},
cancelActiveListeners: function () {
entry.pending.forEach(function (controller, _, set)
{
if (controller !== internalTaskController) {
abortControllerWithReason(controller,
listenerCancelled);
set.delete(controller);
}
});
}
})))];
case 2:
_c.sent();
case 3:
listenerError_1 = _c.sent();
if (!(listenerError_1 instanceof TaskAbortError)) {
safelyNotifyError(onError, listenerError_1, {
raisedBy: "effect"
});
}
case 4:
abortControllerWithReason(internalTaskController,
listenerCompleted);
entry.pending.delete(internalTaskController);
}
});
}); };
var clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
var middleware = function (api) { return function (next) { return function
(action) {
if (addListener.match(action)) {
return startListening(action.payload);
}
if (clearAllListeners.match(action)) {
clearListenerMiddleware();
return;
}
if (removeListener.match(action)) {
return stopListening(action.payload);
}
var originalState = api.getState();
var getOriginalState = function () {
if (originalState === INTERNAL_NIL_TOKEN) {
throw new Error(alm + ": getOriginalState can only be called
synchronously");
}
return originalState;
};
var result;
try {
result = next(action);
if (listenerMap.size > 0) {
var currentState = api.getState();
var listenerEntries = Array.from(listenerMap.values());
for (var _i = 0, listenerEntries_1 = listenerEntries; _i <
listenerEntries_1.length; _i++) {
var entry = listenerEntries_1[_i];
var runListener = false;
try {
runListener = entry.predicate(action, currentState,
originalState);
}
catch (predicateError) {
runListener = false;
safelyNotifyError(onError, predicateError, {
raisedBy: "predicate"
});
}
if (!runListener) {
continue;
}
notifyListener(entry, action, api, getOriginalState);
}
}
}
finally {
originalState = INTERNAL_NIL_TOKEN;
}
return result;
}; }; };
return {
middleware: middleware,
startListening: startListening,
stopListening: stopListening,
clearListeners: clearListenerMiddleware
};
}
// src/index.ts
N();
//# sourceMappingURL=redux-toolkit.esm.js.map
/***/ }),
/***/ 21924:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var GetIntrinsic = __webpack_require__(40210);
var callBind = __webpack_require__(55559);
var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
module.exports = function callBoundIntrinsic(name, allowMissing) {

var intrinsic = GetIntrinsic(name, !!allowMissing);
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
return callBind(intrinsic);
}
return intrinsic;
};
/***/ }),
/***/ 55559:
"use strict";
var bind = __webpack_require__(58612);

var $apply = GetIntrinsic('%Function.prototype.apply%');

var $call = GetIntrinsic('%Function.prototype.call%');
var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call,
$apply);
var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);

var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
var $max = GetIntrinsic('%Math.max%');
if ($defineProperty) {
try {
$defineProperty({}, 'a', { value: 1 });
} catch (e) {
// IE 8 has a broken defineProperty
$defineProperty = null;
}
}
module.exports = function callBind(originalFunction) {

var func = $reflectApply(bind, $call, arguments);
if ($gOPD && $defineProperty) {
var desc = $gOPD(func, 'length');
if (desc.configurable) {
// original length, plus the receiver, minus any additional
arguments (after the receiver)
$defineProperty(
func,
'length',
{ value: 1 + $max(0, originalFunction.length -
(arguments.length - 1)) }
);
}
}
return func;
};
var applyBind = function applyBind() {

return $reflectApply(bind, $apply, arguments);
};
$defineProperty(module.exports, 'apply', { value: applyBind });
} else {
module.exports.apply = applyBind;
}
/***/ }),
/***/ 94184:
/***/ ((module, exports) => {
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

Copyright (c) 2018 Jed Watson.
Licensed under the MIT License (MIT), see
http://jedwatson.github.io/classnames
*/
/* global define */
(function () {
'use strict';
var hasOwn = {}.hasOwnProperty;
function classNames() {
var classes = [];
for (var i = 0; i < arguments.length; i++) {

var arg = arguments[i];
if (!arg) continue;
var argType = typeof arg;
if (argType === 'string' || argType === 'number') {

classes.push(arg);
} else if (Array.isArray(arg)) {
if (arg.length) {
var inner = classNames.apply(null, arg);
if (inner) {
classes.push(inner);
}
}
} else if (argType === 'object') {
if (arg.toString === Object.prototype.toString) {
for (var key in arg) {
if (hasOwn.call(arg, key) && arg[key]) {
classes.push(key);
}
}
} else {
classes.push(arg.toString());
}
}
}

}
if ( true && module.exports) {

classNames.default = classNames;
module.exports = classNames;
} else if (true) {
// register as 'classnames', consistent with npm package name
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ =
(function () {
return classNames;
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports =
__WEBPACK_AMD_DEFINE_RESULT__));
} else {}
}());
/***/ }),
/***/ 88638:
/***/ ((module, __webpack_exports__, __webpack_require__) => {
"use strict";
/* harmony export */ "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony import */ var
_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ =
_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default =
/*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_noSourceMaps_js__WEBPAC
K_IMPORTED_MODULE_0__);
_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ =
_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default =
/*#__PURE__*/__webpack_require__.n(_css_loader_dist_runtime_api_js__WEBPACK_IMPORTE
D_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ =
_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()
((_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()))
;
// Module
___CSS_LOADER_EXPORT___.push([module.id, ".react-responsive-modal-root {\n
position: fixed;\n top: 0;\n bottom: 0;\n left: 0;\n right: 0;\n z-index:
1000;\n}\n\n.react-responsive-modal-overlay {\n background: rgba(0, 0, 0, 0.5);\n
position: fixed;\n top: 0;\n bottom: 0;\n left: 0;\n right: 0;\n z-index: -1;\
n}\n\n.react-responsive-modal-container {\n height: 100%;\n outline: 0;\n
overflow-x: hidden;\n overflow-y: auto;\n text-align: center;\n}\n\n/* Used to
trick the browser to center the modal content properly */\n.react-responsive-
modal-containerCenter:after {\n width: 0;\n height: 100%;\n content: '';\n
display: inline-block;\n vertical-align: middle;\n}\n\n.react-responsive-modal-
modal {\n max-width: 800px;\n display: inline-block;\n text-align: left;\n
vertical-align: middle;\n background: #ffffff;\n box-shadow: 0 12px 15px 0
rgba(0, 0, 0, 0.25);\n margin: 1.2rem;\n padding: 1.2rem;\n position: relative;\
n overflow-y: auto;\n}\n\n.react-responsive-modal-closeButton {\n position:
absolute;\n top: 14px;\n right: 14px;\n border: none;\n padding: 0;\n cursor:
pointer;\n background-color: transparent;\n display: flex;\n}\n\n@keyframes
react-responsive-modal-overlay-in {\n 0% {\n opacity: 0;\n }\n 100% {\n
opacity: 1;\n }\n}\n\n@keyframes react-responsive-modal-overlay-out {\n 0% {\n
opacity: 1;\n }\n 100% {\n opacity: 0;\n }\n}\n\n@keyframes react-responsive-
modal-modal-in {\n 0% {\n transform: scale(0.96);\n opacity: 0;\n }\n 100%
{\n transform: scale(100%);\n opacity: 1;\n }\n}\n\n@keyframes react-
responsive-modal-modal-out {\n 0% {\n transform: scale(100%);\n opacity: 1;\
n }\n 100% {\n transform: scale(0.96);\n opacity: 0;\n }\n}\n", ""]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((/* runtime-
dependent pure expression or super */ 828 != __webpack_require__.j ?
(___CSS_LOADER_EXPORT___) : null));
/***/ }),
/***/ 23645:
/***/ ((module) => {
"use strict";
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
module.exports = function (cssWithMappingToString) {
var list = []; // return the list of modules as css string
list.toString = function toString() {

return this.map(function (item) {
var content = "";
var needLayer = typeof item[5] !== "undefined";
if (item[4]) {
content += "@supports (".concat(item[4], ") {");
}
if (item[2]) {
content += "@media ".concat(item[2], " {");
}
if (needLayer) {
content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", "
{");
}
content += cssWithMappingToString(item);
if (needLayer) {
content += "}";
}
if (item[2]) {
content += "}";
}
if (item[4]) {
content += "}";
}
return content;
}).join("");
}; // import a list of modules into the list
list.i = function i(modules, media, dedupe, supports, layer) {

if (typeof modules === "string") {
modules = [[null, modules, undefined]];
}
var alreadyImportedModules = {};
if (dedupe) {
for (var k = 0; k < this.length; k++) {
var id = this[k][0];
if (id != null) {
alreadyImportedModules[id] = true;
}
}
}
for (var _k = 0; _k < modules.length; _k++) {

var item = [].concat(modules[_k]);
if (dedupe && alreadyImportedModules[item[0]]) {

continue;
}
if (typeof layer !== "undefined") {

if (typeof item[5] === "undefined") {
item[5] = layer;
} else {
item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "",
" {").concat(item[1], "}");
item[5] = layer;
}
}
if (media) {
if (!item[2]) {
item[2] = media;
} else {
item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
item[2] = media;
}
}
if (supports) {
if (!item[4]) {
item[4] = "".concat(supports);
} else {
item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
item[4] = supports;
}
}
list.push(item);
}
};
return list;
};
/***/ }),
/***/ 8081:
/***/ ((module) => {
"use strict";
module.exports = function (i) {

return i[1];
};
/***/ }),
/***/ 10251:
"use strict";
var objectKeys = __webpack_require__(82215);

var isArguments = __webpack_require__(82584);
var is = __webpack_require__(20609);
var isRegex = __webpack_require__(98420);
var flags = __webpack_require__(2847);
var isArray = __webpack_require__(5826);
var isDate = __webpack_require__(18923);
var whichBoxedPrimitive = __webpack_require__(43679);
var callBound = __webpack_require__(21924);
var whichCollection = __webpack_require__(43483);
var getIterator = __webpack_require__(33216);
var getSideChannel = __webpack_require__(37478);
var whichTypedArray = __webpack_require__(86430);
var assign = __webpack_require__(33533);
var $getTime = callBound('Date.prototype.getTime');

var gPO = Object.getPrototypeOf;
var $objToString = callBound('Object.prototype.toString');
var $Set = GetIntrinsic('%Set%', true);

var $mapHas = callBound('Map.prototype.has', true);
var $mapGet = callBound('Map.prototype.get', true);
var $mapSize = callBound('Map.prototype.size', true);
var $setAdd = callBound('Set.prototype.add', true);
var $setDelete = callBound('Set.prototype.delete', true);
var $setHas = callBound('Set.prototype.has', true);
var $setSize = callBound('Set.prototype.size', true);
// taken from
https://github.com/browserify/commonjs-assert/blob/bba838e9ba9e28edf3127ce697462420
8502f6bc/internal/util/comparisons.js#L401-L414
function setHasEqualElement(set, val1, opts, channel) {
var i = getIterator(set);
var result;
while ((result = i.next()) && !result.done) {
if (internalDeepEqual(val1, result.value, opts, channel)) { // eslint-disable-
line no-use-before-define
// Remove the matching element to make sure we do not check that again.
$setDelete(set, result.value);
return true;
}
}
return false;
}
// taken from
function findLooseMatchingPrimitives(prim) {
if (typeof prim === 'undefined') {
return null;
}
if (typeof prim === 'object') { // Only pass in null as object!
return void 0;
}
if (typeof prim === 'symbol') {
return false;
}
if (typeof prim === 'string' || typeof prim === 'number') {
// Loose equal entries exist only if the string is possible to convert to a
regular number and not NaN.
return +prim === +prim; // eslint-disable-line no-implicit-coercion
}
return true;
}
// taken from
function mapMightHaveLoosePrim(a, b, prim, item, opts, channel) {
var altValue = findLooseMatchingPrimitives(prim);
if (altValue != null) {
return altValue;
}
var curB = $mapGet(b, altValue);
var looseOpts = assign({}, opts, { strict: false });
if (
(typeof curB === 'undefined' && !$mapHas(b, altValue))
// eslint-disable-next-line no-use-before-define
|| !internalDeepEqual(item, curB, looseOpts, channel)
) {
return false;
}
return !$mapHas(a, altValue) && internalDeepEqual(item, curB, looseOpts,
channel);
}
// taken from
function setMightHaveLoosePrim(a, b, prim) {
var altValue = findLooseMatchingPrimitives(prim);
if (altValue != null) {
return altValue;
}
return $setHas(b, altValue) && !$setHas(a, altValue);
}
// taken from
function mapHasEqualEntry(set, map, key1, item1, opts, channel) {
var i = getIterator(set);
var result;
var key2;
while ((result = i.next()) && !result.done) {
key2 = result.value;
if (
internalDeepEqual(key1, key2, opts, channel)
&& internalDeepEqual(item1, $mapGet(map, key2), opts, channel)
) {
$setDelete(set, key2);
return true;
}
}
return false;
}
function internalDeepEqual(actual, expected, options, channel) {

var opts = options || {};
// 7.1. All identical values are equivalent, as determined by ===.

if (opts.strict ? is(actual, expected) : actual === expected) {
return true;
}
var actualBoxed = whichBoxedPrimitive(actual);

var expectedBoxed = whichBoxedPrimitive(expected);
if (actualBoxed !== expectedBoxed) {
return false;
}
// 7.3. Other pairs that do not both pass typeof value == 'object', equivalence
is determined by ==.
if (!actual || !expected || (typeof actual !== 'object' && typeof expected !==
'object')) {
return opts.strict ? is(actual, expected) : actual == expected; // eslint-
disable-line eqeqeq
}
/*
* 7.4. For all other Object pairs, including Array objects, equivalence is
* determined by having the same number of owned properties (as verified
* with Object.prototype.hasOwnProperty.call), the same set of keys
* (although not necessarily the same order), equivalent values for every
* corresponding key, and an identical 'prototype' property. Note: this
* accounts for both named and indexed properties on Arrays.
*/
// see
https://github.com/nodejs/node/commit/d3aafd02efd3a403d646a3044adcf14e63a88d32 for
memos/channel inspiration
var hasActual = channel.has(actual);
var hasExpected = channel.has(expected);
var sentinel;
if (hasActual && hasExpected) {
if (channel.get(actual) === channel.get(expected)) {
return true;
}
} else {
sentinel = {};
}
if (!hasActual) { channel.set(actual, sentinel); }
if (!hasExpected) { channel.set(expected, sentinel); }
return objEquiv(actual, expected, opts, channel);
}
function isBuffer(x) {
if (!x || typeof x !== 'object' || typeof x.length !== 'number') {
return false;
}
if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
return false;
}
if (x.length > 0 && typeof x[0] !== 'number') {
return false;
}
return !!(x.constructor && x.constructor.isBuffer && x.constructor.isBuffer(x));

}
function setEquiv(a, b, opts, channel) {

if ($setSize(a) !== $setSize(b)) {
return false;
}
var iA = getIterator(a);
var iB = getIterator(b);
var resultA;
var resultB;
var set;
while ((resultA = iA.next()) && !resultA.done) {
if (resultA.value && typeof resultA.value === 'object') {
if (!set) { set = new $Set(); }
$setAdd(set, resultA.value);
} else if (!$setHas(b, resultA.value)) {
if (opts.strict) { return false; }
if (!setMightHaveLoosePrim(a, b, resultA.value)) {
return false;
}
$setAdd(set, resultA.value);
}
}
if (set) {
while ((resultB = iB.next()) && !resultB.done) {
// We have to check if a primitive value is already matching and only if it's
not, go hunting for it.
if (resultB.value && typeof resultB.value === 'object') {
if (!setHasEqualElement(set, resultB.value, opts.strict, channel)) {
return false;
}
} else if (
!opts.strict
&& !$setHas(a, resultB.value)
&& !setHasEqualElement(set, resultB.value, opts.strict, channel)
) {
return false;
}
}
return $setSize(set) === 0;
}
return true;
}
function mapEquiv(a, b, opts, channel) {

if ($mapSize(a) !== $mapSize(b)) {
return false;
}
var iA = getIterator(a);
var iB = getIterator(b);
var resultA;
var resultB;
var set;
var key;
var item1;
var item2;
while ((resultA = iA.next()) && !resultA.done) {
key = resultA.value[0];
item1 = resultA.value[1];
if (key && typeof key === 'object') {
$setAdd(set, key);
} else {
item2 = $mapGet(b, key);
if ((typeof item2 === 'undefined' && !$mapHas(b, key)) || !
internalDeepEqual(item1, item2, opts, channel)) {
if (opts.strict) {
return false;
}
if (!mapMightHaveLoosePrim(a, b, key, item1, opts, channel)) {
return false;
}
$setAdd(set, key);
}
}
}
if (set) {
while ((resultB = iB.next()) && !resultB.done) {
key = resultB.value[0];
item2 = resultB.value[1];
if (key && typeof key === 'object') {
if (!mapHasEqualEntry(set, a, key, item2, opts, channel)) {
return false;
}
} else if (
!opts.strict
&& (!a.has(key) || !internalDeepEqual($mapGet(a, key), item2, opts,
channel))
&& !mapHasEqualEntry(set, a, key, item2, assign({}, opts, { strict:
false }), channel)
) {
return false;
}
}
return $setSize(set) === 0;
}
return true;
}
function objEquiv(a, b, opts, channel) {

/* eslint max-statements: [2, 100], max-lines-per-function: [2, 120], max-depth:
[2, 5] */
var i, key;
if (typeof a !== typeof b) { return false; }

if (a == null || b == null) { return false; }
if ($objToString(a) !== $objToString(b)) { return false; }
if (isArguments(a) !== isArguments(b)) { return false; }
var aIsArray = isArray(a);

var bIsArray = isArray(b);
if (aIsArray !== bIsArray) { return false; }
// TODO: replace when a cross-realm brand check is available

var aIsError = a instanceof Error;
var bIsError = b instanceof Error;
if (aIsError !== bIsError) { return false; }
if (aIsError || bIsError) {
if (a.name !== b.name || a.message !== b.message) { return false; }
}
var aIsRegex = isRegex(a);

var bIsRegex = isRegex(b);
if (aIsRegex !== bIsRegex) { return false; }
if ((aIsRegex || bIsRegex) && (a.source !== b.source || flags(a) !== flags(b))) {
return false;
}
var aIsDate = isDate(a);

var bIsDate = isDate(b);
if (aIsDate !== bIsDate) { return false; }
if (aIsDate || bIsDate) { // && would work too, because both are true or both
false here
if ($getTime(a) !== $getTime(b)) { return false; }
}
if (opts.strict && gPO && gPO(a) !== gPO(b)) { return false; }
if (whichTypedArray(a) !== whichTypedArray(b)) {

return false;
}
var aIsBuffer = isBuffer(a);

var bIsBuffer = isBuffer(b);
if (aIsBuffer !== bIsBuffer) { return false; }
if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both
false here
if (a.length !== b.length) { return false; }
for (i = 0; i < a.length; i++) {
if (a[i] !== b[i]) { return false; }
}
return true;
}
if (typeof a !== typeof b) { return false; }
var ka = objectKeys(a);
var kb = objectKeys(b);
// having the same number of owned properties (keys incorporates hasOwnProperty)
if (ka.length !== kb.length) { return false; }
// the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
// ~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i]) { return false; } // eslint-disable-line eqeqeq
}
// equivalent values for every corresponding key, and ~~~possibly expensive deep
test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!internalDeepEqual(a[key], b[key], opts, channel)) { return false; }
}
var aCollection = whichCollection(a);

var bCollection = whichCollection(b);
if (aCollection !== bCollection) {
return false;
}
if (aCollection === 'Set' || bCollection === 'Set') { // aCollection ===
bCollection
return setEquiv(a, b, opts, channel);
}
if (aCollection === 'Map') { // aCollection === bCollection
return mapEquiv(a, b, opts, channel);
}
return true;
}
module.exports = function deepEqual(a, b, opts) {

return internalDeepEqual(a, b, opts, getSideChannel());
};
/***/ }),
/***/ 4289:
"use strict";
var keys = __webpack_require__(82215);

var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
var toStr = Object.prototype.toString;

var concat = Array.prototype.concat;
var origDefineProperty = Object.defineProperty;
var isFunction = function (fn) {

return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
};
var hasPropertyDescriptors = __webpack_require__(31044)();
var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
var defineProperty = function (object, name, value, predicate) {

if (name in object && (!isFunction(predicate) || !predicate())) {
return;
}
if (supportsDescriptors) {
origDefineProperty(object, name, {
configurable: true,
enumerable: false,
value: value,
writable: true
});
} else {
object[name] = value; // eslint-disable-line no-param-reassign
}
};
var defineProperties = function (object, map) {

var predicates = arguments.length > 2 ? arguments[2] : {};
var props = keys(map);
if (hasSymbols) {
props = concat.call(props, Object.getOwnPropertySymbols(map));
}
for (var i = 0; i < props.length; i += 1) {
defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
}
};
defineProperties.supportsDescriptors = !!supportsDescriptors;
module.exports = defineProperties;
/***/ }),
/***/ 47525:
"use strict";
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony import */ var webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__ =
/* harmony import */ var webextension_polyfill__WEBPACK_IMPORTED_MODULE_0___default
=
/*#__PURE__*/__webpack_require__.n(webextension_polyfill__WEBPACK_IMPORTED_MODULE_0
__);
// Sign up at https://extensionpay.com to use this library. AGPLv3 licensed.
// For running as a content script. Receive a message from the successful payments
page
// and pass it on to the background page to query if the user has paid.
if (typeof window !== 'undefined') {
window.addEventListener('message', (event) => {
if (event.origin !== 'https://extensionpay.com') return;
if (event.source != window) return;
if (event.data === 'fetch-user' || event.data === 'trial-start') {
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.runtime.sendMessage(event.data);
}
}, false);
}
function ExtPay(extension_id) {
const HOST = `https://extensionpay.com`;

const EXTENSION_URL = `${HOST}/extension/${extension_id}`;
function timeout(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
async function get(key) {
try {
return await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.storage.sync.get(key)
} catch(e) {
// if sync not available (like with Firefox temp addons), fall back to
local
return await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.storage.local.get(key)
}
}
async function set(dict) {
try {
return await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.storage.sync.set(dict)
} catch(e) {
// if sync not available (like with Firefox temp addons), fall back to
local
return await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.storage.local.set(dict)
}
}
// ----- start configuration checks

webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management &&
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management.getSelf().then(async
(ext_info) => {
if (!ext_info.permissions.includes('storage')) {
var permissions =
ext_info.hostPermissions.concat(ext_info.permissions);
throw ÈxtPay Setup Error: please include the "storage" permission in
manifest.json["permissions"] or else ExtensionPay won't work correctly.
You can copy and paste this to your manifest.json file to fix this error:
"permissions": [
${permissions.map(x => `" ${x}"`).join(',\n')}${permissions.length > 0 ? ','
: ''}
"storage"
]
`
}
});
// ----- end configuration checks
// run on "install"
get(['extensionpay_installed_at', 'extensionpay_user']).then(async (storage) =>
{
if (storage.extensionpay_installed_at) return;
// Migration code: before v2.1 installedAt came from the server

// so use that stored datetime instead of making a new one.
const user = storage.extensionpay_user;
const date = user ? user.installedAt : (new Date()).toISOString();
await set({'extensionpay_installed_at': date});
});
const paid_callbacks = [];

const trial_callbacks = [];
async function create_key() {

var body = {};
var ext_info;
if (webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management) {
ext_info = await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management.getSelf();
} else if (webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.runtime) {
ext_info = await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.runtime.sendMessage('extpay-
extinfo'); // ask background page for ext info
} else {
throw 'ExtPay needs to be run in a browser extension context'
}
if (ext_info.installType == 'development') {
body.development = true;
}
const resp = await fetch(`${EXTENSION_URL}/api/new-key`, {

method: 'POST',
headers: {
'Accept': 'application/json',
'Content-type': 'application/json',
},
body: JSON.stringify(body),
});
if (!resp.ok) {
throw resp.status, `${HOST}/home`
}
const api_key = await resp.json();
await set({extensionpay_api_key: api_key});
return api_key;
}
async function get_key() {

const storage = await get(['extensionpay_api_key']);
if (storage.extensionpay_api_key) {
return storage.extensionpay_api_key;
}
return null;
}
const datetime_re = /^\d\d\d\d-\d\d-\d\dT/;
async function fetch_user() {

var storage = await get(['extensionpay_user',
'extensionpay_installed_at']);
const api_key = await get_key();
if (!api_key) {
return {
paid: false,
paidAt: null,
installedAt: storage.extensionpay_installed_at ? new
Date(storage.extensionpay_installed_at) : new Date(), // sometimes this function
gets called before the initial install time can be flushed to storage
trialStartedAt: null,
}
}
const resp = await fetch(`${EXTENSION_URL}/api/user?api_key=${api_key}`, {

method: 'GET',
headers: {
'Accept': 'application/json',
}
});
// TODO: think harder about error states and what users will want (bad
connection, server error, id not found)
if (!resp.ok) throw 'ExtPay error while fetching user: '+(await
resp.text())
const user_data = await resp.json();
const parsed_user = {};

for (var [key, value] of Object.entries(user_data)) {
if (value && value.match && value.match(datetime_re)) {
value = new Date(value);
}
parsed_user[key] = value;
}
parsed_user.installedAt = new Date(storage.extensionpay_installed_at);
if (parsed_user.paidAt) {
if (!storage.extensionpay_user || (storage.extensionpay_user && !
storage.extensionpay_user.paidAt)) {
paid_callbacks.forEach(cb => cb(parsed_user));
}
}
if (parsed_user.trialStartedAt) {
if (!storage.extensionpay_user || (storage.extensionpay_user && !
storage.extensionpay_user.trialStartedAt)) {
trial_callbacks.forEach(cb => cb(parsed_user));
}
}
await set({extensionpay_user: user_data});
return parsed_user;
}
async function payment_page_link() {

var api_key = await get_key();
if (!api_key) {
api_key = await create_key();
}
return `${EXTENSION_URL}?api_key=${api_key}`
}
async function open_popup(url, width, height) {

if (webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.windows) {
const current_window = await
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.windows.getCurrent();
// https://stackoverflow.com/a/68456858
const left = Math.round((current_window.width - width) * 0.5 +
current_window.left);
const top = Math.round((current_window.height - height) * 0.5 +
current_window.top);
try {
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.windows.create({
url: url,
type: "popup",
focused: true,
width,
height,
left,
top
});
} catch(e) {
// firefox doesn't support 'focused'
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.windows.create({
url: url,
type: "popup",
width,
height,
left,
top
});
}
} else {
// for opening from a content script
// https://developer.mozilla.org/en-US/docs/Web/API/Window/open
window.open(url, null,
`toolbar=no,location=no,directories=no,status=no,menubar=no,width=${width},height=$
{height},left=450`);
}
}
async function open_payment_page() {

const url = await payment_page_link();
open_popup(url, 500, 800);
}
async function open_trial_page(period) {

// let user have period string like '1 week' e.g. "start your 1 week free
trial"

if (!api_key) {
}
var url = `${EXTENSION_URL}/trial?api_key=${api_key}`;
if (period) {
url += `&period=${period}`;
}
}
async function open_login_page() {
if (!api_key) {
}
const url = `${EXTENSION_URL}/reactivate?api_key=${api_key}`;
}
var polling = false;

async function poll_user_paid() {
// keep trying to fetch user in case stripe webhook is late
if (polling) return;
polling = true;
var user = await fetch_user();
for (var i=0; i < 2*60; ++i) {
if (user.paidAt) {
polling = false;
return user;
}
await timeout(1000);
user = await fetch_user();
}
polling = false;
}
return {
getUser: function() {
return fetch_user()
},
onPaid: {
addListener: function(callback) {
const content_script_template = `"content_scripts": [
{
"matches": ["${HOST}/*"],
"js": ["ExtPay.js"],
"run_at": "document_start"
}]`;
const manifest =
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.runtime.getManifest();
if (!manifest.content_scripts) {
throw ÈxtPay setup error: To use the onPaid callback handler,
please include ExtPay as a content script in your manifest.json. You can copy the
example below into your manifest.json or check the docs:
https://github.com/Glench/ExtPay#2-configure-your-manifestjson
${content_script_template}`
}
const extpay_content_script_entry =
manifest.content_scripts.find(obj => {
// removing port number because firefox ignores content scripts
with port number
return obj.matches.includes(HOST.replace(':3000', '')+'/*')
});
if (!extpay_content_script_entry) {
throw ÈxtPay setup error: To use the onPaid callback handler,
please include ExtPay as a content script in your manifest.json matching
"${HOST}/*". You can copy the example below into your manifest.json or check the
docs: https://github.com/Glench/ExtPay#2-configure-your-manifestjson
} else {
if (!extpay_content_script_entry.run_at ||
extpay_content_script_entry.run_at !== 'document_start') {
throw ÈxtPay setup error: To use the onPaid callback
handler, please make sure the ExtPay content script in your manifest.json runs at
document start. You can copy the example below into your manifest.json or check the
docs: https://github.com/Glench/ExtPay#2-configure-your-manifestjson
}
}
paid_callbacks.push(callback);
},
// removeListener: function(callback) {
// // TODO
// }
},
openPaymentPage: open_payment_page,
openTrialPage: open_trial_page,
openLoginPage: open_login_page,
onTrialStarted: {
addListener: function(callback) {
trial_callbacks.push(callback);
}
},
startBackground: function() {
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.runtime.onMessage.addListener(fu
nction(message, sender, send_response) {
console.log('service worker got message! Here it is:', message);
if (message == 'fetch-user') {
// Only called via
extensionpay.com/extension/[extension-id]/paid -> content_script when user
successfully pays.
// It's possible attackers could trigger this but that is
basically harmless. It would just query the user.
poll_user_paid();
} else if (message == 'trial-start') {
// no need to poll since the trial confirmation page has
already set trialStartedAt
fetch_user();
} else if (message == 'extpay-extinfo' &&
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management) {
// get this message from content scripts which can't access
browser.management
return
webextension_polyfill__WEBPACK_IMPORTED_MODULE_0__.management.getSelf()
}
});
}
}
}

dependent pure expression or super */ 42 == __webpack_require__.j ? (ExtPay) :
null));
/***/ }),
/***/ 49804:
/***/ ((module) => {
var hasOwn = Object.prototype.hasOwnProperty;

var toString = Object.prototype.toString;
module.exports = function forEach (obj, fn, ctx) {

if (toString.call(fn) !== '[object Function]') {
throw new TypeError('iterator must be a function');
}
var l = obj.length;
if (l === +l) {
for (var i = 0; i < l; i++) {
fn.call(ctx, obj[i], i, obj);
}
} else {
for (var k in obj) {
if (hasOwn.call(obj, k)) {
fn.call(ctx, obj[k], k, obj);
}
}
}
};
/***/ }),
/***/ 17648:
/***/ ((module) => {
"use strict";
/* eslint no-invalid-this: 1 */
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';

var slice = Array.prototype.slice;
var funcType = '[object Function]';
module.exports = function bind(that) {

var target = this;
if (typeof target !== 'function' || toStr.call(target) !== funcType) {
throw new TypeError(ERROR_MESSAGE + target);
}
var args = slice.call(arguments, 1);
var bound;
var binder = function () {
if (this instanceof bound) {
var result = target.apply(
this,
args.concat(slice.call(arguments))
);
if (Object(result) === result) {
return result;
}
return this;
} else {
return target.apply(
that,
args.concat(slice.call(arguments))
);
}
};
var boundLength = Math.max(0, target.length - args.length);

var boundArgs = [];
for (var i = 0; i < boundLength; i++) {
boundArgs.push('$' + i);
}
bound = Function('binder', 'return function (' + boundArgs.join(',') + ')

{ return binder.apply(this,arguments); }')(binder);
if (target.prototype) {
var Empty = function Empty() {};
Empty.prototype = target.prototype;
bound.prototype = new Empty();
Empty.prototype = null;
}
return bound;
};
/***/ }),
/***/ 58612:
"use strict";
var implementation = __webpack_require__(17648);
module.exports = Function.prototype.bind || implementation;
/***/ }),
/***/ 25972:
/***/ ((module) => {
"use strict";
var functionsHaveNames = function functionsHaveNames() {

return typeof function f() {}.name === 'string';
};
var gOPD = Object.getOwnPropertyDescriptor;

if (gOPD) {
try {
gOPD([], 'length');
} catch (e) {
// IE 8 has a broken gOPD
gOPD = null;
}
}
functionsHaveNames.functionsHaveConfigurableNames = function
functionsHaveConfigurableNames() {
if (!functionsHaveNames() || !gOPD) {
return false;
}
var desc = gOPD(function () {}, 'name');
return !!desc && !!desc.configurable;
};
var $bind = Function.prototype.bind;
functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {

return functionsHaveNames() && typeof $bind === 'function' && function f()
{}.bind().name !== '';
};
module.exports = functionsHaveNames;
/***/ }),
/***/ 40210:
"use strict";
var undefined;
var $SyntaxError = SyntaxError;

var $Function = Function;
var $TypeError = TypeError;
// eslint-disable-next-line consistent-return
var getEvalledConstructor = function (expressionSyntax) {
try {
return $Function('"use strict"; return (' + expressionSyntax +
').constructor;')();
} catch (e) {}
};
var $gOPD = Object.getOwnPropertyDescriptor;

if ($gOPD) {
try {
$gOPD({}, '');
} catch (e) {
$gOPD = null; // this is IE 8, which has a broken gOPD
}
}
var throwTypeError = function () {

throw new $TypeError();
};
var ThrowTypeError = $gOPD
? (function () {
try {
// eslint-disable-next-line no-unused-expressions, no-caller, no-
restricted-properties
arguments.callee; // IE 8 does not throw here
return throwTypeError;
} catch (calleeThrows) {
try {
// IE 8 throws on
Object.getOwnPropertyDescriptor(arguments, '')
return $gOPD(arguments, 'callee').get;
} catch (gOPDthrows) {
return throwTypeError;
}
}
}())
: throwTypeError;
var hasSymbols = __webpack_require__(41405)();
var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; //

eslint-disable-line no-proto
var needsEval = {};
var TypedArray = typeof Uint8Array === 'undefined' ? undefined :

getProto(Uint8Array);
var INTRINSICS = {
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined :
AggregateError,
'%Array%': Array,
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined :
ArrayBuffer,
'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) :
undefined,
'%AsyncFromSyncIteratorPrototype%': undefined,
'%AsyncFunction%': needsEval,
'%AsyncGenerator%': needsEval,
'%AsyncGeneratorFunction%': needsEval,
'%AsyncIteratorPrototype%': needsEval,
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
'%Boolean%': Boolean,
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
'%Date%': Date,
'%decodeURI%': decodeURI,
'%decodeURIComponent%': decodeURIComponent,
'%encodeURI%': encodeURI,
'%encodeURIComponent%': encodeURIComponent,
'%Error%': Error,
'%eval%': eval, // eslint-disable-line no-eval
'%EvalError%': EvalError,
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined :
Float32Array,
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined :
Float64Array,
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ?
undefined : FinalizationRegistry,
'%Function%': $Function,
'%GeneratorFunction%': needsEval,
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
'%isFinite%': isFinite,
'%isNaN%': isNaN,
'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]()))
: undefined,
'%JSON%': typeof JSON === 'object' ? JSON : undefined,
'%Map%': typeof Map === 'undefined' ? undefined : Map,
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ?
undefined : getProto(new Map()[Symbol.iterator]()),
'%Math%': Math,
'%Number%': Number,
'%Object%': Object,
'%parseFloat%': parseFloat,
'%parseInt%': parseInt,
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
'%RangeError%': RangeError,
'%ReferenceError%': ReferenceError,
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
'%RegExp%': RegExp,
'%Set%': typeof Set === 'undefined' ? undefined : Set,
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ?
undefined : getProto(new Set()[Symbol.iterator]()),
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined :
SharedArrayBuffer,
'%String%': String,
'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) :
undefined,
'%Symbol%': hasSymbols ? Symbol : undefined,
'%SyntaxError%': $SyntaxError,
'%ThrowTypeError%': ThrowTypeError,
'%TypedArray%': TypedArray,
'%TypeError%': $TypeError,
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined :
Uint8ClampedArray,
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined :
Uint16Array,
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined :
Uint32Array,
'%URIError%': URIError,
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
};
var doEval = function doEval(name) {

var value;
if (name === '%AsyncFunction%') {
value = getEvalledConstructor('async function () {}');
} else if (name === '%GeneratorFunction%') {
value = getEvalledConstructor('function* () {}');
} else if (name === '%AsyncGeneratorFunction%') {
value = getEvalledConstructor('async function* () {}');
} else if (name === '%AsyncGenerator%') {
var fn = doEval('%AsyncGeneratorFunction%');
if (fn) {
value = fn.prototype;
}
} else if (name === '%AsyncIteratorPrototype%') {
var gen = doEval('%AsyncGenerator%');
if (gen) {
value = getProto(gen.prototype);
}
}
INTRINSICS[name] = value;
return value;
};
var LEGACY_ALIASES = {
'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
'%ArrayPrototype%': ['Array', 'prototype'],
'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
'%ArrayProto_values%': ['Array', 'prototype', 'values'],
'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype',
'prototype'],
'%BooleanPrototype%': ['Boolean', 'prototype'],
'%DataViewPrototype%': ['DataView', 'prototype'],
'%DatePrototype%': ['Date', 'prototype'],
'%ErrorPrototype%': ['Error', 'prototype'],
'%EvalErrorPrototype%': ['EvalError', 'prototype'],
'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
'%FunctionPrototype%': ['Function', 'prototype'],
'%Generator%': ['GeneratorFunction', 'prototype'],
'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
'%JSONParse%': ['JSON', 'parse'],
'%JSONStringify%': ['JSON', 'stringify'],
'%MapPrototype%': ['Map', 'prototype'],
'%NumberPrototype%': ['Number', 'prototype'],
'%ObjectPrototype%': ['Object', 'prototype'],
'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
'%PromisePrototype%': ['Promise', 'prototype'],
'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
'%Promise_all%': ['Promise', 'all'],
'%Promise_reject%': ['Promise', 'reject'],
'%Promise_resolve%': ['Promise', 'resolve'],
'%RangeErrorPrototype%': ['RangeError', 'prototype'],
'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
'%RegExpPrototype%': ['RegExp', 'prototype'],
'%SetPrototype%': ['Set', 'prototype'],
'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
'%StringPrototype%': ['String', 'prototype'],
'%SymbolPrototype%': ['Symbol', 'prototype'],
'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
'%TypeErrorPrototype%': ['TypeError', 'prototype'],
'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
'%URIErrorPrototype%': ['URIError', 'prototype'],
'%WeakMapPrototype%': ['WeakMap', 'prototype'],
'%WeakSetPrototype%': ['WeakSet', 'prototype']
};

var hasOwn = __webpack_require__(17642);
var $concat = bind.call(Function.call, Array.prototype.concat);
var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
var $replace = bind.call(Function.call, String.prototype.replace);
var $strSlice = bind.call(Function.call, String.prototype.slice);
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-

L6744 */
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\
2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
var reEscapeChar = /\$\$?/g; /** Used to match backslashes in property paths. */
var stringToPath = function stringToPath(string) {
var first = $strSlice(string, 0, 1);
var last = $strSlice(string, -1);
if (first === '%' && last !== '%') {
throw new $SyntaxError('invalid intrinsic syntax, expected closing `
%`');
} else if (last === '%' && first !== '%') {
throw new $SyntaxError('invalid intrinsic syntax, expected opening `
%`');
}
var result = [];
$replace(string, rePropName, function (match, number, quote, subString) {
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1')
: number || match;
});
return result;
};
/* end adaptation */
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {

var intrinsicName = name;
var alias;
if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
alias = LEGACY_ALIASES[intrinsicName];
intrinsicName = '%' + alias[0] + '%';
}
if (hasOwn(INTRINSICS, intrinsicName)) {
var value = INTRINSICS[intrinsicName];
if (value === needsEval) {
value = doEval(intrinsicName);
}
if (typeof value === 'undefined' && !allowMissing) {
throw new $TypeError('intrinsic ' + name + ' exists, but is not
available. Please file an issue!');
}
return {
alias: alias,
name: intrinsicName,
value: value
};
}
throw new $SyntaxError('intrinsic ' + name + ' does not exist!');

};
module.exports = function GetIntrinsic(name, allowMissing) {

if (typeof name !== 'string' || name.length === 0) {
throw new $TypeError('intrinsic name must be a non-empty string');
}
if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
throw new $TypeError('"allowMissing" argument must be a boolean');
}
var parts = stringToPath(name);

var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%',

allowMissing);
var intrinsicRealName = intrinsic.name;
var value = intrinsic.value;
var skipFurtherCaching = false;
var alias = intrinsic.alias;
if (alias) {
intrinsicBaseName = alias[0];
$spliceApply(parts, $concat([0, 1], alias));
}
for (var i = 1, isOwn = true; i < parts.length; i += 1) {

var part = parts[i];
var first = $strSlice(part, 0, 1);
var last = $strSlice(part, -1);
if (
(
(first === '"' || first === "'" || first === '`')
|| (last === '"' || last === "'" || last === '`')
)
&& first !== last
) {
throw new $SyntaxError('property names with quotes must have
matching quotes');
}
if (part === 'constructor' || !isOwn) {
skipFurtherCaching = true;
}
intrinsicBaseName += '.' + part;

intrinsicRealName = '%' + intrinsicBaseName + '%';
if (hasOwn(INTRINSICS, intrinsicRealName)) {
value = INTRINSICS[intrinsicRealName];
} else if (value != null) {
if (!(part in value)) {
if (!allowMissing) {
throw new $TypeError('base intrinsic for ' + name + '
exists, but the property is not available.');
}
return void undefined;
}
if ($gOPD && (i + 1) >= parts.length) {
var desc = $gOPD(value, part);
isOwn = !!desc;
// By convention, when a data property is converted to an

accessor
// property to emulate a data property that does not suffer
from
// the override mistake, that accessor's getter is marked
with
// an òriginalValue` property. Here, when we detect this,
we
// uphold the illusion by pretending to see that original
data
// property, i.e., returning the value rather than the
getter
// itself.
if (isOwn && 'get' in desc && !('originalValue' in
desc.get)) {
value = desc.get;
} else {
value = value[part];
}
} else {
isOwn = hasOwn(value, part);
value = value[part];
}
if (isOwn && !skipFurtherCaching) {

INTRINSICS[intrinsicRealName] = value;
}
}
}
return value;
};
/***/ }),
/***/ 80932:
/***/ ((module) => {
"use strict";
var $BigInt = typeof BigInt !== 'undefined' && BigInt;
module.exports = function hasNativeBigInts() {

return typeof $BigInt === 'function'
&& typeof BigInt === 'function'
&& typeof $BigInt(42) === 'bigint' // eslint-disable-line no-magic-
numbers
&& typeof BigInt(42) === 'bigint'; // eslint-disable-line no-magic-
numbers
};
/***/ }),
/***/ 31044:
"use strict";
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
var hasPropertyDescriptors = function hasPropertyDescriptors() {

try {
$defineProperty({}, 'a', { value: 1 });
return true;
} catch (e) {
// IE 8 has a broken defineProperty
return false;
}
}
return false;
};
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug()

{
// node v0.6 has a bug where array lengths can be Set but not Defined
if (!hasPropertyDescriptors()) {
return null;
}
try {
return $defineProperty([], 'length', { value: 1 }).length !== 1;
} catch (e) {
// In Firefox 4-22, defining length on an array throws an exception.
return true;
}
};
module.exports = hasPropertyDescriptors;
/***/ }),
/***/ 41405:
"use strict";
var origSymbol = typeof Symbol !== 'undefined' && Symbol;

var hasSymbolSham = __webpack_require__(55419);
module.exports = function hasNativeSymbols() {

if (typeof origSymbol !== 'function') { return false; }
if (typeof Symbol !== 'function') { return false; }
if (typeof origSymbol('foo') !== 'symbol') { return false; }
if (typeof Symbol('bar') !== 'symbol') { return false; }
return hasSymbolSham();
};
/***/ }),
/***/ 55419:
/***/ ((module) => {
"use strict";
/* eslint complexity: [2, 18], max-statements: [2, 33] */

module.exports = function hasSymbols() {
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !==
'function') { return false; }
if (typeof Symbol.iterator === 'symbol') { return true; }
var obj = {};

var sym = Symbol('test');
var symObj = Object(sym);
if (typeof sym === 'string') { return false; }
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return
false; }
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return
false; }
// temp disabled per https://github.com/ljharb/object.assign/issues/17

// if (sym instanceof Symbol) { return false; }
// temp disabled per https://github.com/WebReflection/get-own-property-
symbols/issues/4
// if (!(symObj instanceof Symbol)) { return false; }
// if (typeof Symbol.prototype.toString !== 'function') { return false; }

// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
var symVal = 42;

obj[sym] = symVal;
for (sym in obj) { return false; } // eslint-disable-line no-restricted-
syntax, no-unreachable-loop
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0)
{ return false; }
if (typeof Object.getOwnPropertyNames === 'function' &&

Object.getOwnPropertyNames(obj).length !== 0) { return false; }
var syms = Object.getOwnPropertySymbols(obj);

if (syms.length !== 1 || syms[0] !== sym) { return false; }
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
if (typeof Object.getOwnPropertyDescriptor === 'function') {

var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
if (descriptor.value !== symVal || descriptor.enumerable !== true)
{ return false; }
}
return true;
};
/***/ }),
/***/ 96410:
"use strict";
var hasSymbols = __webpack_require__(55419);
module.exports = function hasToStringTagShams() {

return hasSymbols() && !!Symbol.toStringTag;
};
/***/ }),
/***/ 17642:
"use strict";
module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
/***/ }),
/***/ 8679:
"use strict";
var reactIs = __webpack_require__(21296);
/**
* Copyright 2015, Yahoo! Inc.
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file
for terms.
*/
var REACT_STATICS = {
childContextTypes: true,
contextType: true,
contextTypes: true,
defaultProps: true,
displayName: true,
getDefaultProps: true,
getDerivedStateFromError: true,
getDerivedStateFromProps: true,
mixins: true,
propTypes: true,
type: true
};
var KNOWN_STATICS = {
name: true,
length: true,
prototype: true,
caller: true,
callee: true,
arguments: true,
arity: true
};
var FORWARD_REF_STATICS = {
'$$typeof': true,
render: true,
defaultProps: true,
displayName: true,
propTypes: true
};
var MEMO_STATICS = {
'$$typeof': true,
compare: true,
defaultProps: true,
displayName: true,
propTypes: true,
type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
// React v16.11 and below
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
} // React v16.12 and above
return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;

}
var defineProperty = Object.defineProperty;

var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
if (typeof sourceComponent !== 'string') {
// don't hoist over string (html) components
if (objectPrototype) {
var inheritedComponent = getPrototypeOf(sourceComponent);
if (inheritedComponent && inheritedComponent !== objectPrototype) {

hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
}
}
var keys = getOwnPropertyNames(sourceComponent);
if (getOwnPropertySymbols) {
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
}
var targetStatics = getStatics(targetComponent);

var sourceStatics = getStatics(sourceComponent);
for (var i = 0; i < keys.length; ++i) {

var key = keys[i];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics

&& sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
// Avoid failures from read-only properties
defineProperty(targetComponent, key, descriptor);
} catch (e) {}
}
}
}
return targetComponent;
}
module.exports = hoistNonReactStatics;
/***/ }),
/***/ 96103:
"use strict";
/** @license React v16.13.1
* react-is.production.min.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var b="function"===typeof Symbol&&Symbol.for,c=b?

Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?
Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?
Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?
Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?
Symbol.for("react.concurrent_mode"):60111,n=b?
Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?
Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?
Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?
Symbol.for("react.scope"):60119;
function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case
c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return
a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return
a;default:return u}}case d:return u}}}function A(a){return
z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exp
orts.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;ex
ports.Lazy=t;exports.Memo=r;exports.Portal=d;
exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=func
tion(a){return A(a)||
z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return
z(a)===k};exports.isContextProvider=function(a){return
z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$
$typeof===c};exports.isForwardRef=function(a){return
z(a)===n};exports.isFragment=function(a){return
z(a)===e};exports.isLazy=function(a){return z(a)===t};
exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return
z(a)===d};exports.isProfiler=function(a){return
z(a)===g};exports.isStrictMode=function(a){return
z(a)===f};exports.isSuspense=function(a){return z(a)===p};
exports.isValidElementType=function(a){return"string"===typeof
a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||
a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$
$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$
$typeof===y||a.$$typeof===v)};exports.typeOf=z;
/***/ }),
/***/ 21296:
"use strict";
if (true) {
module.exports = __webpack_require__(96103);
} else {}
/***/ }),
/***/ 82584:
"use strict";
var hasToStringTag = __webpack_require__(96410)();

var $toString = callBound('Object.prototype.toString');
var isStandardArguments = function isArguments(value) {

if (hasToStringTag && value && typeof value === 'object' &&
Symbol.toStringTag in value) {
return false;
}
return $toString(value) === '[object Arguments]';
};
var isLegacyArguments = function isArguments(value) {

if (isStandardArguments(value)) {
return true;
}
return value !== null &&
typeof value === 'object' &&
typeof value.length === 'number' &&
value.length >= 0 &&
$toString(value) !== '[object Array]' &&
$toString(value.callee) === '[object Function]';
};
var supportsStandardArguments = (function () {

return isStandardArguments(arguments);
}());
isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
module.exports = supportsStandardArguments ? isStandardArguments :

isLegacyArguments;
/***/ }),
/***/ 63376:
"use strict";
var hasBigInts = __webpack_require__(80932)();
if (hasBigInts) {
var bigIntValueOf = BigInt.prototype.valueOf;
var tryBigInt = function tryBigIntObject(value) {
try {
bigIntValueOf.call(value);
return true;
} catch (e) {
}
return false;
};
module.exports = function isBigInt(value) {

if (
value === null
|| typeof value === 'undefined'
|| typeof value === 'boolean'
|| typeof value === 'string'
|| typeof value === 'number'
|| typeof value === 'symbol'
|| typeof value === 'function'
) {
return false;
}
if (typeof value === 'bigint') {
return true;
}
return tryBigInt(value);
};
} else {
module.exports = function isBigInt(value) {
return false && 0;
};
}
/***/ }),
/***/ 76814:
"use strict";

var $boolToStr = callBound('Boolean.prototype.toString');
var tryBooleanObject = function booleanBrandCheck(value) {

try {
$boolToStr(value);
return true;
} catch (e) {
return false;
}
};
var boolClass = '[object Boolean]';
module.exports = function isBoolean(value) {

if (typeof value === 'boolean') {
return true;
}
if (value === null || typeof value !== 'object') {
return false;
}
return hasToStringTag && Symbol.toStringTag in value ?
tryBooleanObject(value) : $toString(value) === boolClass;
};
/***/ }),
/***/ 18923:
"use strict";
var getDay = Date.prototype.getDay;

var tryDateObject = function tryDateGetDayCall(value) {
try {
getDay.call(value);
return true;
} catch (e) {
return false;
}
};

var dateClass = '[object Date]';
module.exports = function isDateObject(value) {

if (typeof value !== 'object' || value === null) {
return false;
}
return hasToStringTag ? tryDateObject(value) : toStr.call(value) ===
dateClass;
};
/***/ }),
/***/ 78379:
/***/ ((module) => {
"use strict";
var $Map = typeof Map === 'function' && Map.prototype ? Map : null;
var $Set = typeof Set === 'function' && Set.prototype ? Set : null;
var exported;
if (!$Map) {
// eslint-disable-next-line no-unused-vars
exported = function isMap(x) {
// `Map` is not present in this environment.
return false;
};
}
var $mapHas = $Map ? Map.prototype.has : null;

var $setHas = $Set ? Set.prototype.has : null;
if (!exported && !$mapHas) {
exported = function isMap(x) {
// `Map` does not have a `has` method
return false;
};
}
module.exports = exported || function isMap(x) {

if (!x || typeof x !== 'object') {
return false;
}
try {
$mapHas.call(x);
if ($setHas) {
try {
$setHas.call(x);
} catch (e) {
return true;
}
}
return x instanceof $Map; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
};
/***/ }),
/***/ 44578:
"use strict";
var numToStr = Number.prototype.toString;

var tryNumberObject = function tryNumberObject(value) {
try {
numToStr.call(value);
return true;
} catch (e) {
return false;
}
};
var numClass = '[object Number]';
module.exports = function isNumberObject(value) {

return true;
}
if (typeof value !== 'object') {
return false;
}
return hasToStringTag ? tryNumberObject(value) : toStr.call(value) ===
numClass;
};
/***/ }),
/***/ 98420:
"use strict";

var has;
var $exec;
var isRegexMarker;
var badStringifier;
if (hasToStringTag) {
has = callBound('Object.prototype.hasOwnProperty');
$exec = callBound('RegExp.prototype.exec');
isRegexMarker = {};
var throwRegexMarker = function () {

throw isRegexMarker;
};
badStringifier = {
toString: throwRegexMarker,
valueOf: throwRegexMarker
};
if (typeof Symbol.toPrimitive === 'symbol') {

badStringifier[Symbol.toPrimitive] = throwRegexMarker;
}
}

var regexClass = '[object RegExp]';
module.exports = hasToStringTag
? function isRegex(value) {
if (!value || typeof value !== 'object') {
return false;
}
var descriptor = gOPD(value, 'lastIndex');

var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
if (!hasLastIndexDataProperty) {
return false;
}
try {
$exec(value, badStringifier);
} catch (e) {
return e === isRegexMarker;
}
}
: function isRegex(value) {
// In older browsers, typeof regex incorrectly returns 'function'
if (!value || (typeof value !== 'object' && typeof value !==
'function')) {
return false;
}
return $toString(value) === regexClass;

};
/***/ }),
/***/ 19572:
/***/ ((module) => {
"use strict";
var $Map = typeof Map === 'function' && Map.prototype ? Map : null;
var $Set = typeof Set === 'function' && Set.prototype ? Set : null;
var exported;
if (!$Set) {
exported = function isSet(x) {
// `Set` is not present in this environment.
return false;
};
}
var $mapHas = $Map ? Map.prototype.has : null;

var $setHas = $Set ? Set.prototype.has : null;
if (!exported && !$setHas) {
exported = function isSet(x) {
// `Set` does not have a `has` method
return false;
};
}
module.exports = exported || function isSet(x) {

return false;
}
try {
$setHas.call(x);
if ($mapHas) {
try {
$mapHas.call(x);
} catch (e) {
return true;
}
}
return x instanceof $Set; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
};
/***/ }),
/***/ 29981:
"use strict";
var strValue = String.prototype.valueOf;

var tryStringObject = function tryStringObject(value) {
try {
strValue.call(value);
return true;
} catch (e) {
return false;
}
};
var strClass = '[object String]';
module.exports = function isString(value) {

if (typeof value === 'string') {
return true;
}
if (typeof value !== 'object') {
return false;
}
return hasToStringTag ? tryStringObject(value) : toStr.call(value) ===
strClass;
};
/***/ }),
/***/ 12636:
"use strict";

if (hasSymbols) {
var symToStr = Symbol.prototype.toString;
var symStringRegex = /^Symbol$.*$$/;
var isSymbolObject = function isRealSymbolObject(value) {
if (typeof value.valueOf() !== 'symbol') {
return false;
}
return symStringRegex.test(symToStr.call(value));
};
module.exports = function isSymbol(value) {

if (typeof value === 'symbol') {
return true;
}
if (toStr.call(value) !== '[object Symbol]') {
return false;
}
try {
return isSymbolObject(value);
} catch (e) {
return false;
}
};
} else {
module.exports = function isSymbol(value) {

// this environment does not support Symbols.
return false && 0;
};
}
/***/ }),
/***/ 85692:
"use strict";
var forEach = __webpack_require__(49804);

var availableTypedArrays = __webpack_require__(63083);

var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis;

var typedArrays = availableTypedArrays();
var $indexOf = callBound('Array.prototype.indexOf', true) || function

indexOf(array, value) {
for (var i = 0; i < array.length; i += 1) {
if (array[i] === value) {
return i;
}
}
return -1;
};
var $slice = callBound('String.prototype.slice');
var toStrTags = {};
var gOPD = __webpack_require__(20882);
var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
if (hasToStringTag && gOPD && getPrototypeOf) {
forEach(typedArrays, function (typedArray) {
var arr = new g[typedArray]();
if (Symbol.toStringTag in arr) {
var proto = getPrototypeOf(arr);
var descriptor = gOPD(proto, Symbol.toStringTag);
if (!descriptor) {
var superProto = getPrototypeOf(proto);
descriptor = gOPD(superProto, Symbol.toStringTag);
}
toStrTags[typedArray] = descriptor.get;
}
});
}
var tryTypedArrays = function tryAllTypedArrays(value) {

var anyTrue = false;
forEach(toStrTags, function (getter, typedArray) {
if (!anyTrue) {
try {
anyTrue = getter.call(value) === typedArray;
} catch (e) { /**/ }
}
});
return anyTrue;
};
module.exports = function isTypedArray(value) {

if (!value || typeof value !== 'object') { return false; }
if (!hasToStringTag || !(Symbol.toStringTag in value)) {
var tag = $slice($toString(value), 8, -1);
return $indexOf(typedArrays, tag) > -1;
}
if (!gOPD) { return false; }
return tryTypedArrays(value);
};
/***/ }),
/***/ 11718:
/***/ ((module) => {
"use strict";
var $WeakMap = typeof WeakMap === 'function' && WeakMap.prototype ? WeakMap : null;
var $WeakSet = typeof WeakSet === 'function' && WeakSet.prototype ? WeakSet : null;
var exported;
if (!$WeakMap) {
exported = function isWeakMap(x) {
// `WeakMap` is not present in this environment.
return false;
};
}
var $mapHas = $WeakMap ? $WeakMap.prototype.has : null;

var $setHas = $WeakSet ? $WeakSet.prototype.has : null;
if (!exported && !$mapHas) {
exported = function isWeakMap(x) {
// `WeakMap` does not have a `has` method
return false;
};
}
module.exports = exported || function isWeakMap(x) {

return false;
}
try {
$mapHas.call(x, $mapHas);
if ($setHas) {
try {
$setHas.call(x, $setHas);
} catch (e) {
return true;
}
}
return x instanceof $WeakMap; // core-js workaround, pre-v3
} catch (e) {}
return false;
};
/***/ }),
/***/ 25899:
/***/ ((module) => {
"use strict";
var $WeakMap = typeof WeakMap === 'function' && WeakMap.prototype ? WeakMap : null;
var $WeakSet = typeof WeakSet === 'function' && WeakSet.prototype ? WeakSet : null;
var exported;
if (!$WeakMap) {
exported = function isWeakSet(x) {
// `WeakSet` is not present in this environment.
return false;
};
}
var $mapHas = $WeakMap ? $WeakMap.prototype.has : null;

var $setHas = $WeakSet ? $WeakSet.prototype.has : null;
if (!exported && !$setHas) {
module.exports = function isWeakSet(x) {
// `WeakSet` does not have a `has` method
return false;
};
}
module.exports = exported || function isWeakSet(x) {
return false;
}
try {
$setHas.call(x, $setHas);
if ($mapHas) {
try {
$mapHas.call(x, $mapHas);
} catch (e) {
return true;
}
}
return x instanceof $WeakSet; // core-js workaround, pre-v3
} catch (e) {}
return false;
};
/***/ }),
/***/ 5826:
/***/ ((module) => {
var toString = {}.toString;
module.exports = Array.isArray || function (arr) {

return toString.call(arr) == '[object Array]';
};
/***/ }),
/***/ 27418:
/***/ ((module) => {
"use strict";
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or
undefined');
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
// Detect buggy property enumeration order in older V8 versions.
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
test1[5] = 'de';
if (Object.getOwnPropertyNames(test1)[0] === '5') {
return false;
}
var test2 = {};
for (var i = 0; i < 10; i++) {
test2['_' + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
return test2[n];
});
if (order2.join('') !== '0123456789') {
return false;
}
var test3 = {};
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join('') !==
'abcdefghijklmnopqrst') {
return false;
}
return true;
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false;
}
}
module.exports = shouldUseNative() ? Object.assign : function (target, source) {

var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {

from = Object(arguments[s]);
for (var key in from) {

if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
/***/ }),
/***/ 70631:
var hasMap = typeof Map === 'function' && Map.prototype;

var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ?
Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get ===
'function' ? mapSizeDescriptor.get : null;
var mapForEach = hasMap && Map.prototype.forEach;
var hasSet = typeof Set === 'function' && Set.prototype;
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ?
Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get ===
'function' ? setSizeDescriptor.get : null;
var setForEach = hasSet && Set.prototype.forEach;
var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
var booleanValueOf = Boolean.prototype.valueOf;
var objectToString = Object.prototype.toString;
var functionToString = Function.prototype.toString;
var $match = String.prototype.match;
var $slice = String.prototype.slice;
var $replace = String.prototype.replace;
var $toUpperCase = String.prototype.toUpperCase;
var $toLowerCase = String.prototype.toLowerCase;
var $test = RegExp.prototype.test;
var $concat = Array.prototype.concat;
var $join = Array.prototype.join;
var $arrSlice = Array.prototype.slice;
var $floor = Math.floor;
var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
var gOPS = Object.getOwnPropertySymbols;
var symToString = typeof Symbol === 'function' && typeof Symbol.iterator ===
'symbol' ? Symbol.prototype.toString : null;
var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator ===
'object';
// ie, `has-tostringtag/shams
var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof
Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')
? Symbol.toStringTag
: null;
var isEnumerable = Object.prototype.propertyIsEnumerable;
var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf :

Object.getPrototypeOf) || (
[].__proto__ === Array.prototype // eslint-disable-line no-proto
? function (O) {
return O.__proto__; // eslint-disable-line no-proto
}
: null
);
function addNumericSeparator(num, str) {

if (
num === Infinity
|| num === -Infinity
|| num !== num
|| (num && num > -1000 && num < 1000)
|| $test.call(/e/, str)
) {
return str;
}
var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
if (typeof num === 'number') {
var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
if (int !== num) {
var intStr = String(int);
var dec = $slice.call(str, intStr.length + 1);
return $replace.call(intStr, sepRegex, '$&_') + '.' +
$replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
}
}
return $replace.call(str, sepRegex, '$&_');
}
var utilInspect = __webpack_require__(24654);

var inspectCustom = utilInspect.custom;
var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
module.exports = function inspect_(obj, options, depth, seen) {

var opts = options || {};
if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle

!== 'double')) {
throw new TypeError('option "quoteStyle" must be "single" or "double"');
}
if (
has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
: opts.maxStringLength !== null
)
) {
throw new TypeError('option "maxStringLength", if provided, must be a
positive integer, Infinity, or `null`');
}
var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
throw new TypeError('option "customInspect", if provided, must be `true`,
`false`, or `\'symbol\'`');
}
if (
has(opts, 'indent')
&& opts.indent !== null
&& opts.indent !== '\t'
&& !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
) {
throw new TypeError('option "indent" must be "\\t", an integer > 0, or
`null`');
}
if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !==
'boolean') {
throw new TypeError('option "numericSeparator", if provided, must be `true`
or `false`');
}
var numericSeparator = opts.numericSeparator;
if (typeof obj === 'undefined') {

return 'undefined';
}
if (obj === null) {
return 'null';
}
if (typeof obj === 'boolean') {
return obj ? 'true' : 'false';
}
if (typeof obj === 'string') {

return inspectString(obj, opts);
}
if (typeof obj === 'number') {
if (obj === 0) {
return Infinity / obj > 0 ? '0' : '-0';
}
var str = String(obj);
return numericSeparator ? addNumericSeparator(obj, str) : str;
}
if (typeof obj === 'bigint') {
var bigIntStr = String(obj) + 'n';
return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
}
var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;

if (typeof depth === 'undefined') { depth = 0; }
if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
return isArray(obj) ? '[Array]' : '[Object]';
}
var indent = getIndent(opts, depth);
if (typeof seen === 'undefined') {

seen = [];
} else if (indexOf(seen, obj) >= 0) {
return '[Circular]';
}
function inspect(value, from, noIndent) {

if (from) {
seen = $arrSlice.call(seen);
seen.push(from);
}
if (noIndent) {
var newOpts = {
depth: opts.depth
};
if (has(opts, 'quoteStyle')) {
newOpts.quoteStyle = opts.quoteStyle;
}
return inspect_(value, newOpts, depth + 1, seen);
}
return inspect_(value, opts, depth + 1, seen);
}
if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes

are callable
var name = nameOf(obj);
var keys = arrObjKeys(obj, inspect);
return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' +
(keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
}
if (isSymbol(obj)) {
var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\
(.*\))_[^)]*$/, '$1') : symToString.call(obj);
return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString)
: symString;
}
if (isElement(obj)) {
var s = '<' + $toLowerCase.call(String(obj.nodeName));
var attrs = obj.attributes || [];
for (var i = 0; i < attrs.length; i++) {
s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value),
'double', opts);
}
s += '>';
if (obj.childNodes && obj.childNodes.length) { s += '...'; }
s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
return s;
}
if (isArray(obj)) {
if (obj.length === 0) { return '[]'; }
var xs = arrObjKeys(obj, inspect);
if (indent && !singleLineValues(xs)) {
return '[' + indentedJoin(xs, indent) + ']';
}
return '[ ' + $join.call(xs, ', ') + ' ]';
}
if (isError(obj)) {
var parts = arrObjKeys(obj, inspect);
if (!('cause' in Error.prototype) && 'cause' in obj && !
isEnumerable.call(obj, 'cause')) {
return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: '
+ inspect(obj.cause), parts), ', ') + ' }';
}
if (parts.length === 0) { return '[' + String(obj) + ']'; }
return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';
}
if (typeof obj === 'object' && customInspect) {
if (inspectSymbol && typeof obj[inspectSymbol] === 'function' &&
utilInspect) {
return utilInspect(obj, { depth: maxDepth - depth });
} else if (customInspect !== 'symbol' && typeof obj.inspect === 'function')
{
return obj.inspect();
}
}
if (isMap(obj)) {
var mapParts = [];
mapForEach.call(obj, function (value, key) {
mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
});
return collectionOf('Map', mapSize.call(obj), mapParts, indent);
}
if (isSet(obj)) {
var setParts = [];
setForEach.call(obj, function (value) {
setParts.push(inspect(value, obj));
});
return collectionOf('Set', setSize.call(obj), setParts, indent);
}
if (isWeakMap(obj)) {
return weakCollectionOf('WeakMap');
}
if (isWeakSet(obj)) {
return weakCollectionOf('WeakSet');
}
if (isWeakRef(obj)) {
return weakCollectionOf('WeakRef');
}
if (isNumber(obj)) {
return markBoxed(inspect(Number(obj)));
}
if (isBigInt(obj)) {
return markBoxed(inspect(bigIntValueOf.call(obj)));
}
if (isBoolean(obj)) {
return markBoxed(booleanValueOf.call(obj));
}
if (isString(obj)) {
return markBoxed(inspect(String(obj)));
}
if (!isDate(obj) && !isRegExp(obj)) {
var ys = arrObjKeys(obj, inspect);
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof
Object || obj.constructor === Object;
var protoTag = obj instanceof Object ? '' : 'null prototype';
var stringTag = !isPlainObject && toStringTag && Object(obj) === obj &&
toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';
var constructorTag = isPlainObject || typeof obj.constructor !== 'function'
? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
var tag = constructorTag + (stringTag || protoTag ? '[' +
$join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');
if (ys.length === 0) { return tag + '{}'; }
if (indent) {
return tag + '{' + indentedJoin(ys, indent) + '}';
}
return tag + '{ ' + $join.call(ys, ', ') + ' }';
}
return String(obj);
};
function wrapQuotes(s, defaultStyle, opts) {

var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
return quoteChar + s + quoteChar;
}
function quote(s) {
return $replace.call(String(s), /"/g, '"');
}
function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag

|| !(typeof obj === 'object' && toStringTag in obj)); }
function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !
(typeof obj === 'object' && toStringTag in obj)); }
function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag
function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag
function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag
function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag
function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag
// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to

eliminate false positives
function isSymbol(obj) {
if (hasShammedSymbols) {
return obj && typeof obj === 'object' && obj instanceof Symbol;
}
if (typeof obj === 'symbol') {
return true;
}
if (!obj || typeof obj !== 'object' || !symToString) {
return false;
}
try {
symToString.call(obj);
return true;
} catch (e) {}
return false;
}
function isBigInt(obj) {
if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
return false;
}
try {
bigIntValueOf.call(obj);
return true;
} catch (e) {}
return false;
}
var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in

this; };
function has(obj, key) {
return hasOwn.call(obj, key);
}
function toStr(obj) {
return objectToString.call(obj);
}
function nameOf(f) {
if (f.name) { return f.name; }
var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
if (m) { return m[1]; }
return null;
}
function indexOf(xs, x) {
if (xs.indexOf) { return xs.indexOf(x); }
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) { return i; }
}
return -1;
}
function isMap(x) {
if (!mapSize || !x || typeof x !== 'object') {
return false;
}
try {
mapSize.call(x);
try {
setSize.call(x);
} catch (s) {
return true;
}
return x instanceof Map; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakMap(x) {
if (!weakMapHas || !x || typeof x !== 'object') {
return false;
}
try {
weakMapHas.call(x, weakMapHas);
try {
weakSetHas.call(x, weakSetHas);
} catch (s) {
return true;
}
return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakRef(x) {
if (!weakRefDeref || !x || typeof x !== 'object') {
return false;
}
try {
weakRefDeref.call(x);
return true;
} catch (e) {}
return false;
}
function isSet(x) {
if (!setSize || !x || typeof x !== 'object') {
return false;
}
try {
setSize.call(x);
try {
mapSize.call(x);
} catch (m) {
return true;
}
return x instanceof Set; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakSet(x) {
if (!weakSetHas || !x || typeof x !== 'object') {
return false;
}
try {
weakSetHas.call(x, weakSetHas);
try {
weakMapHas.call(x, weakMapHas);
} catch (s) {
return true;
}
return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isElement(x) {
if (!x || typeof x !== 'object') { return false; }
if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
return true;
}
return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
}
function inspectString(str, opts) {

if (str.length > opts.maxStringLength) {
var remaining = str.length - opts.maxStringLength;
var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's'
: '');
return inspectString($slice.call(str, 0, opts.maxStringLength), opts) +
trailer;
}
// eslint-disable-next-line no-control-regex
var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g,
lowbyte);
return wrapQuotes(s, 'single', opts);
}
function lowbyte(c) {
var n = c.charCodeAt(0);
var x = {
8: 'b',
9: 't',
10: 'n',
12: 'f',
13: 'r'
}[n];
if (x) { return '\\' + x; }
return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));
}
function markBoxed(str) {
return 'Object(' + str + ')';
}
function weakCollectionOf(type) {
return type + ' { ? }';
}
function collectionOf(type, size, entries, indent) {

var joinedEntries = indent ? indentedJoin(entries, indent) :
$join.call(entries, ', ');
return type + ' (' + size + ') {' + joinedEntries + '}';
}
function singleLineValues(xs) {
for (var i = 0; i < xs.length; i++) {
if (indexOf(xs[i], '\n') >= 0) {
return false;
}
}
return true;
}
function getIndent(opts, depth) {

var baseIndent;
if (opts.indent === '\t') {
baseIndent = '\t';
} else if (typeof opts.indent === 'number' && opts.indent > 0) {
baseIndent = $join.call(Array(opts.indent + 1), ' ');
} else {
return null;
}
return {
base: baseIndent,
prev: $join.call(Array(depth + 1), baseIndent)
};
}
function indentedJoin(xs, indent) {

if (xs.length === 0) { return ''; }
var lineJoiner = '\n' + indent.prev + indent.base;
return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
}
function arrObjKeys(obj, inspect) {
var isArr = isArray(obj);
var xs = [];
if (isArr) {
xs.length = obj.length;
for (var i = 0; i < obj.length; i++) {
xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
}
}
var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
var symMap;
if (hasShammedSymbols) {
symMap = {};
for (var k = 0; k < syms.length; k++) {
symMap['$' + syms[k]] = syms[k];
}
}
for (var key in obj) { // eslint-disable-line no-restricted-syntax

if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-
syntax, no-continue
if (isArr && String(Number(key)) === key && key < obj.length) { continue; }
// eslint-disable-line no-restricted-syntax, no-continue
if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
// this is to prevent shammed Symbols, which are stored as strings,
from being included in the string key section
continue; // eslint-disable-line no-restricted-syntax, no-continue
} else if ($test.call(/[^\w$]/, key)) {
xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
} else {
xs.push(key + ': ' + inspect(obj[key], obj));
}
}
if (typeof gOPS === 'function') {
for (var j = 0; j < syms.length; j++) {
if (isEnumerable.call(obj, syms[j])) {
xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]],
obj));
}
}
}
return xs;
}
/***/ }),
/***/ 24244:
/***/ ((module) => {
"use strict";
var numberIsNaN = function (value) {

return value !== value;
};
module.exports = function is(a, b) {

if (a === 0 && b === 0) {
return 1 / a === 1 / b;
}
if (a === b) {
return true;
}
if (numberIsNaN(a) && numberIsNaN(b)) {
return true;
}
return false;
};
/***/ }),
/***/ 20609:
"use strict";
var define = __webpack_require__(4289);


var getPolyfill = __webpack_require__(75624);
var shim = __webpack_require__(52281);
var polyfill = callBind(getPolyfill(), Object);
define(polyfill, {
getPolyfill: getPolyfill,
implementation: implementation,
shim: shim
});
module.exports = polyfill;
/***/ }),
/***/ 75624:
"use strict";
module.exports = function getPolyfill() {

return typeof Object.is === 'function' ? Object.is : implementation;
};
/***/ }),
/***/ 52281:
"use strict";

module.exports = function shimObjectIs() {

var polyfill = getPolyfill();
define(Object, { is: polyfill }, {
is: function testObjectIs() {
return Object.is !== polyfill;
}
});
return polyfill;
};
/***/ }),
/***/ 18987:
"use strict";
var keysShim;
if (!Object.keys) {
// modified from https://github.com/es-shims/es5-shim
var has = Object.prototype.hasOwnProperty;
var isArgs = __webpack_require__(21414); // eslint-disable-line global-
require
var isEnumerable = Object.prototype.propertyIsEnumerable;
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
var dontEnums = [
'toString',
'toLocaleString',
'valueOf',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'constructor'
];
var equalsConstructorPrototype = function (o) {
var ctor = o.constructor;
return ctor && ctor.prototype === o;
};
var excludedKeys = {
$applicationCache: true,
$console: true,
$external: true,
$frame: true,
$frameElement: true,
$frames: true,
$innerHeight: true,
$innerWidth: true,
$onmozfullscreenchange: true,
$onmozfullscreenerror: true,
$outerHeight: true,
$outerWidth: true,
$pageXOffset: true,
$pageYOffset: true,
$parent: true,
$scrollLeft: true,
$scrollTop: true,
$scrollX: true,
$scrollY: true,
$self: true,
$webkitIndexedDB: true,
$webkitStorageInfo: true,
$window: true
};
var hasAutomationEqualityBug = (function () {
/* global window */
if (typeof window === 'undefined') { return false; }
for (var k in window) {
try {
if (!excludedKeys['$' + k] && has.call(window, k) &&
window[k] !== null && typeof window[k] === 'object') {
try {
equalsConstructorPrototype(window[k]);
} catch (e) {
return true;
}
}
} catch (e) {
return true;
}
}
return false;
}());
var equalsConstructorPrototypeIfNotBuggy = function (o) {
/* global window */
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
return equalsConstructorPrototype(o);
}
try {
return equalsConstructorPrototype(o);
} catch (e) {
return false;
}
};
keysShim = function keys(object) {

var isObject = object !== null && typeof object === 'object';
var isFunction = toStr.call(object) === '[object Function]';
var isArguments = isArgs(object);
var isString = isObject && toStr.call(object) === '[object String]';
var theKeys = [];
if (!isObject && !isFunction && !isArguments) {

throw new TypeError('Object.keys called on a non-object');
}
var skipProto = hasProtoEnumBug && isFunction;

if (isString && object.length > 0 && !has.call(object, 0)) {
for (var i = 0; i < object.length; ++i) {
theKeys.push(String(i));
}
}
if (isArguments && object.length > 0) {

for (var j = 0; j < object.length; ++j) {
theKeys.push(String(j));
}
} else {
for (var name in object) {
if (!(skipProto && name === 'prototype') &&
has.call(object, name)) {
theKeys.push(String(name));
}
}
}
if (hasDontEnumBug) {
var skipConstructor =
equalsConstructorPrototypeIfNotBuggy(object);
for (var k = 0; k < dontEnums.length; ++k) {

if (!(skipConstructor && dontEnums[k] === 'constructor') &&
has.call(object, dontEnums[k])) {
theKeys.push(dontEnums[k]);
}
}
}
return theKeys;
};
}
module.exports = keysShim;
/***/ }),
/***/ 82215:
"use strict";
var slice = Array.prototype.slice;

var isArgs = __webpack_require__(21414);
var origKeys = Object.keys;

var keysShim = origKeys ? function keys(o) { return origKeys(o); } :
var originalKeys = Object.keys;
keysShim.shim = function shimObjectKeys() {

if (Object.keys) {
var keysWorksWithArguments = (function () {
// Safari 5.0 bug
var args = Object.keys(arguments);
return args && args.length === arguments.length;
}(1, 2));
if (!keysWorksWithArguments) {
Object.keys = function keys(object) { // eslint-disable-line
func-name-matching
if (isArgs(object)) {
return originalKeys(slice.call(object));
}
return originalKeys(object);
};
}
} else {
Object.keys = keysShim;
}
return Object.keys || keysShim;
};
module.exports = keysShim;
/***/ }),
/***/ 21414:
/***/ ((module) => {
"use strict";
module.exports = function isArguments(value) {

var str = toStr.call(value);
var isArgs = str === '[object Arguments]';
if (!isArgs) {
isArgs = str !== '[object Array]' &&
value !== null &&
typeof value === 'object' &&
typeof value.length === 'number' &&
value.length >= 0 &&
toStr.call(value.callee) === '[object Function]';
}
return isArgs;
};
/***/ }),
/***/ 92837:
"use strict";
// modified from https://github.com/es-shims/es6-shim

var keys = __webpack_require__(82215);
var canBeObject = function (obj) {
return typeof obj !== 'undefined' && obj !== null;
};
var toObject = Object;
var $push = callBound('Array.prototype.push');
var $propIsEnumerable = callBound('Object.prototype.propertyIsEnumerable');
var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;
module.exports = function assign(target, source1) {
if (!canBeObject(target)) { throw new TypeError('target must be an
object'); }
var objTarget = toObject(target);
var s, source, i, props, syms, value, key;
for (s = 1; s < arguments.length; ++s) {
source = toObject(arguments[s]);
props = keys(source);
var getSymbols = hasSymbols && (Object.getOwnPropertySymbols ||
originalGetSymbols);
if (getSymbols) {
syms = getSymbols(source);
for (i = 0; i < syms.length; ++i) {
key = syms[i];
if ($propIsEnumerable(source, key)) {
$push(props, key);
}
}
}
for (i = 0; i < props.length; ++i) {
key = props[i];
value = source[key];
if ($propIsEnumerable(source, key)) {
objTarget[key] = value;
}
}
}
return objTarget;
};
/***/ }),
/***/ 33533:
"use strict";
var defineProperties = __webpack_require__(4289);


var polyfill = callBind.apply(getPolyfill());

var bound = function assign(target, source1) {
return polyfill(Object, arguments);
};
defineProperties(bound, {
shim: shim
});
module.exports = bound;
/***/ }),
/***/ 28162:
"use strict";
var lacksProperEnumerationOrder = function () {

return false;
}
/*
* v8, specifically in node 4.x, has a bug with incorrect property
enumeration order
* note: this does not detect the bug unless there's 20 characters
*/
var str = 'abcdefghijklmnopqrst';
var letters = str.split('');
var map = {};
for (var i = 0; i < letters.length; ++i) {
map[letters[i]] = letters[i];
}
var obj = Object.assign({}, map);
var actual = '';
for (var k in obj) {
actual += k;
}
return str !== actual;
};
var assignHasPendingExceptions = function () {

if (!Object.assign || !Object.preventExtensions) {
return false;
}
/*
* Firefox 37 still has "pending exception" logic in its Object.assign
implementation,
* which is 72% slower than our shim, and Firefox 40's native implementation.
*/
var thrower = Object.preventExtensions({ 1: 2 });
try {
Object.assign(thrower, 'xy');
} catch (e) {
return thrower[1] === 'y';
}
return false;
};

return implementation;
}
if (lacksProperEnumerationOrder()) {
}
if (assignHasPendingExceptions()) {
}
return Object.assign;
};
/***/ }),
/***/ 84489:
"use strict";

module.exports = function shimAssign() {

define(
Object,
{ assign: polyfill },
{ assign: function () { return Object.assign !== polyfill; } }
);
return polyfill;
};
/***/ }),
/***/ 64448:
"use strict";
* react-dom.production.min.js
*
*
*/
/*
Modernizr 3.0.0pre (Custom Build) | MIT
*/
var
aa=__webpack_require__(67294),m=__webpack_require__(27418),r=__webpack_require__(63
840);function y(a){for(var b="https://reactjs.org/docs/error-decoder.html?
invariant="+a,c=1;c<arguments.length;c+
+)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error
#"+a+"; visit "+b+" for the full message or use the non-minified dev environment
for full errors and additional helpful warnings."}if(!aa)throw Error(y(227));var
ba=new Set,ca={};function da(a,b){ea(a,b);ea(a+"Capture",b)}
function ea(a,b){ca[a]=b;for(a=0;a<b.length;a++)ba.add(b[a])}
var fa=!("undefined"===typeof window||"undefined"===typeof
window.document||"undefined"===typeof window.document.createElement),ha=/^[:A-Z_a-
z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\
u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\
u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\
u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\
u203F-\u2040]*$/,ia=Object.prototype.hasOwnProperty,
ja={},ka={};function la(a){if(ia.call(ka,a))return!0;if(ia.call(ja,a))return!
1;if(ha.test(a))return ka[a]=!0;ja[a]=!0;return!1}function ma(a,b,c,d){if(null!
==c&&0===c.type)return!1;switch(typeof b){case "function":case "symbol":return!
0;case "boolean":if(d)return!1;if(null!==c)return!
c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return"data-"!==a&&"aria-"!
==a;default:return!1}}
function na(a,b,c,d){if(null===b||"undefined"===typeof b||ma(a,b,c,d))return!
0;if(d)return!1;if(null!==c)switch(c.type){case 3:return!b;case 4:return!1===b;case
5:return isNaN(b);case 6:return isNaN(b)||1>b}return!1}function B(a,b,c,d,e,f,g)
{this.acceptsBooleans=2===b||3===b||
4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.pr
opertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var D={};
"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML
suppressContentEditableWarning suppressHydrationWarning style".split("
").forEach(function(a){D[a]=new B(a,0,!1,a,null,!1,!1)});[["acceptCharset","accept-
charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-
equiv"]].forEach(function(a){var b=a[0];D[b]=new B(b,1,!1,a[1],null,!1,!1)});
["contentEditable","draggable","spellCheck","value"].forEach(function(a){D[a]=new
B(a,2,!1,a.toLowerCase(),null,!1,!1)});
["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(fun
ction(a){D[a]=new B(a,2,!1,a,null,!1,!1)});"allowFullScreen async autoFocus
autoPlay controls default defer disabled disablePictureInPicture
disableRemotePlayback formNoValidate hidden loop noModule noValidate open
playsInline readOnly required reversed scoped seamless itemScope".split("
").forEach(function(a){D[a]=new B(a,3,!1,a.toLowerCase(),null,!1,!1)});
["checked","multiple","muted","selected"].forEach(function(a){D[a]=new B(a,3,!
0,a,null,!1,!1)});["capture","download"].forEach(function(a){D[a]=new B(a,4,!
1,a,null,!1,!1)});["cols","rows","size","span"].forEach(function(a){D[a]=new
B(a,6,!1,a,null,!1,!1)});["rowSpan","start"].forEach(function(a){D[a]=new B(a,5,!
1,a.toLowerCase(),null,!1,!1)});var oa=/[\-:]([a-z])/g;function pa(a){return
a[1].toUpperCase()}
"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path
clip-rule color-interpolation color-interpolation-filters color-profile color-
rendering dominant-baseline enable-background fill-opacity fill-rule flood-color
flood-opacity font-family font-size font-size-adjust font-stretch font-style font-
variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-
vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color
marker-end marker-mid marker-start overline-position overline-thickness paint-order
panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity
strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset
stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-
anchor text-decoration text-rendering underline-position underline-thickness
unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-
mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing
writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var
b=a.replace(oa,
pa);D[b]=new B(b,1,!1,a,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role
xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var
b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1)});
["xml:base","xml:lang","xml:space"].forEach(function(a){var
b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!
1)});["tabIndex","crossOrigin"].forEach(function(a){D[a]=new B(a,1,!
1,a.toLowerCase(),null,!1,!1)});
D.xlinkHref=new B("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!
1);["src","href","action","formAction"].forEach(function(a){D[a]=new B(a,1,!
1,a.toLowerCase(),null,!0,!0)});
function qa(a,b,c,d){var e=D.hasOwnProperty(b)?D[b]:null;var f=null!==e?
0===e.type:d?!1:!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1]?!1:!
0;f||(na(b,c,e,d)&&(c=null),d||null===e?la(b)&&(null===c?
a.removeAttribute(b):a.setAttribute(b,""+c)):e.mustUseProperty?
a[e.propertyName]=null===c?3===e.type?!1:"":c:
(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):
(e=e.type,c=3===e||4===e&&!0===c?"":""+c,d?
a.setAttributeNS(d,b,c):a.setAttribute(b,c))))}
var
ra=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,sa=60103,ta=60106,ua=60107
,wa=60108,xa=60114,ya=60109,za=60110,Aa=60112,Ba=60113,Ca=60120,Da=60115,Ea=60116,F
a=60121,Ga=60128,Ha=60129,Ia=60130,Ja=60131;
if("function"===typeof Symbol&&Symbol.for){var
E=Symbol.for;sa=E("react.element");ta=E("react.portal");ua=E("react.fragment");wa=E
("react.strict_mode");xa=E("react.profiler");ya=E("react.provider");za=E("react.con
text");Aa=E("react.forward_ref");Ba=E("react.suspense");Ca=E("react.suspense_list")
;Da=E("react.memo");Ea=E("react.lazy");Fa=E("react.block");E("react.scope");Ga=E("r
eact.opaque.id");Ha=E("react.debug_trace_mode");Ia=E("react.offscreen");Ja=E("react
.legacy_hidden")}
var Ka="function"===typeof Symbol&&Symbol.iterator;function La(a)
{if(null===a||"object"!==typeof a)return null;a=Ka&&a[Ka]||
a["@@iterator"];return"function"===typeof a?a:null}var Ma;function Na(a){if(void
0===Ma)try{throw Error();}catch(c){var b=c.stack.trim().match(/\
n( *(at )?)/);Ma=b&&b[1]||""}return"\n"+Ma+a}var Oa=!1;
function Pa(a,b){if(!a||Oa)return"";Oa=!0;var
c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function()
{throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw
Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,
[])}catch(k){var d=k}Reflect.construct(a,[],b)}else{try{b.call()}catch(k)
{d=k}a.call(b.prototype)}else{try{throw Error();}catch(k){d=k}a()}}catch(k)
{if(k&&d&&"string"===typeof k.stack){for(var e=k.stack.split("\n"),
f=d.stack.split("\n"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!
==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do
if(g--,h--,0>h||e[g]!==f[h])return"\n"+e[g].replace(" at new "," at
");while(1<=g&&0<=h)}break}}}finally{Oa=!1,Error.prepareStackTrace=c}return(a=a?
a.displayName||a.name:"")?Na(a):""}
function Qa(a){switch(a.tag){case 5:return Na(a.type);case 16:return
Na("Lazy");case 13:return Na("Suspense");case 19:return Na("SuspenseList");case
0:case 2:case 15:return a=Pa(a.type,!1),a;case 11:return a=Pa(a.type.render,!
1),a;case 22:return a=Pa(a.type._render,!1),a;case 1:return a=Pa(a.type,!
0),a;default:return""}}
function Ra(a){if(null==a)return null;if("function"===typeof a)return
a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case
ua:return"Fragment";case ta:return"Portal";case xa:return"Profiler";case
wa:return"StrictMode";case Ba:return"Suspense";case
Ca:return"SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case
za:return(a.displayName||"Context")+".Consumer";case
ya:return(a._context.displayName||"Context")+".Provider";case Aa:var
b=a.render;b=b.displayName||b.name||"";
return a.displayName||(""!==b?"ForwardRef("+b+")":"ForwardRef");case Da:return
Ra(a.type);case Fa:return Ra(a._render);case Ea:b=a._payload;a=a._init;try{return
Ra(a(b))}catch(c){}}return null}function Sa(a){switch(typeof a){case "boolean":case
"number":case "object":case "string":case "undefined":return
a;default:return""}}function Ta(a){var
b=a.type;return(a=a.nodeName)&&"input"===a.toLowerCase()&&("checkbox"===b||"radio"=
==b)}
function Ua(a){var
b=Ta(a)?"checked":"value",c=Object.getOwnPropertyDescriptor(a.constructor.prototype
,b),d=""+a[b];if(!a.hasOwnProperty(b)&&"undefined"!==typeof c&&"function"===typeof
c.get&&"function"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,
{configurable:!0,get:function(){return e.call(this)},set:function(a)
{d=""+a;f.call(this,a)}});Object.defineProperty(a,b,
{enumerable:c.enumerable});return{getValue:function(){return
d},setValue:function(a){d=""+a},stopTracking:function(){a._valueTracker=
null;delete a[b]}}}}function Va(a){a._valueTracker||
(a._valueTracker=Ua(a))}function Wa(a){if(!a)return!1;var b=a._valueTracker;if(!
b)return!0;var c=b.getValue();var d="";a&&(d=Ta(a)?
a.checked?"true":"false":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function
Xa(a){a=a||("undefined"!==typeof document?document:void 0);if("undefined"===typeof
a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}
function Ya(a,b){var c=b.checked;return m({},b,{defaultChecked:void
0,defaultValue:void 0,value:void 0,checked:null!=c?
c:a._wrapperState.initialChecked})}function Za(a,b){var
c=null==b.defaultValue?"":b.defaultValue,d=null!=b.checked?
b.checked:b.defaultChecked;c=Sa(null!=b.value?
b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:"checkbox"==
=b.type||"radio"===b.type?null!=b.checked:null!=b.value}}function $a(a,b)
{b=b.checked;null!=b&&qa(a,"checked",b,!1)}
function ab(a,b){$a(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if("number"===d)
{if(0===c&&""===a.value||a.value!=c)a.value=""+c}else a.value!
==""+c&&(a.value=""+c);else if("submit"===d||"reset"===d)
{a.removeAttribute("value");return}b.hasOwnProperty("value")?
bb(a,b.type,c):b.hasOwnProperty("defaultValue")&&bb(a,b.type,Sa(b.defaultValue));nu
ll==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked)}
function cb(a,b,c){if(b.hasOwnProperty("value")||b.hasOwnProperty("defaultValue"))
{var d=b.type;if(!("submit"!==d&&"reset"!==d||void 0!==b.value&&null!
==b.value))return;b=""+a._wrapperState.initialValue;c||b===a.value||
(a.value=b);a.defaultValue=b}c=a.name;""!==c&&(a.name="");a.defaultChecked=!!
a._wrapperState.initialChecked;""!==c&&(a.name=c)}
function bb(a,b,c){if("number"!==b||Xa(a.ownerDocument)!==a)null==c?
a.defaultValue=""+a._wrapperState.initialValue:a.defaultValue!
==""+c&&(a.defaultValue=""+c)}function db(a){var
b="";aa.Children.forEach(a,function(a){null!=a&&(b+=a)});return b}function eb(a,b)
{a=m({children:void 0},b);if(b=db(b.children))a.children=b;return a}
function fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e+
+)b["$"+c[e]]=!0;for(c=0;c<a.length;c+
+)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!
==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!
0)}else{c=""+Sa(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c)
{a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||
(b=a[e])}null!==b&&(b.selected=!0)}}
function gb(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(y(91));return
m({},b,{value:void 0,defaultValue:void
0,children:""+a._wrapperState.initialValue})}function hb(a,b){var
c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw
Error(y(92));if(Array.isArray(c)){if(!(1>=c.length))throw
Error(y(93));c=c[0]}b=c}null==b&&(b="");c=b}a._wrapperState={initialValue:Sa(c)}}
function ib(a,b){var c=Sa(b.value),d=Sa(b.defaultValue);null!=c&&(c=""+c,c!
==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!
==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=""+d)}function jb(a){var
b=a.textContent;b===a._wrapperState.initialValue&&""!==b&&null!==b&&(a.value=b)}var
kb={html:"http://www.w3.org/1999/xhtml",mathml:"http://www.w3.org/1998/Math/
MathML",svg:"http://www.w3.org/2000/svg"};
function lb(a){switch(a){case "svg":return"http://www.w3.org/2000/svg";case
"math":return"http://www.w3.org/1998/Math/MathML";default:return"http://
www.w3.org/1999/xhtml"}}function mb(a,b){return
null==a||"http://www.w3.org/1999/xhtml"===a?lb(b):"http://www.w3.org/2000/
svg"===a&&"foreignObject"===b?"http://www.w3.org/1999/xhtml":a}
var nb,ob=function(a){return"undefined"!==typeof
MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e)
{MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)})}:a}(function(a,b)
{if(a.namespaceURI!==kb.svg||"innerHTML"in a)a.innerHTML=b;else{nb=nb||
document.createElement("div");nb.innerHTML="<svg>"+b.valueOf().toString()+"</
svg>";for(b=nb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChi
ld;)a.appendChild(b.firstChild)}});
function pb(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType)
{c.nodeValue=b;return}}a.textContent=b}
var qb={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!
0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!
0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!
0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!
0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!
0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!
0,zIndex:!0,zoom:!0,fillOpacity:!0,
floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!
0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!
0},rb=["Webkit","ms","Moz","O"];Object.keys(qb).forEach(function(a)
{rb.forEach(function(b){b=b+a.charAt(0).toUpperCase()
+a.substring(1);qb[b]=qb[a]})});function sb(a,b,c){return
null==b||"boolean"===typeof b||""===b?"":c||"number"!==typeof b||0===b||
qb.hasOwnProperty(a)&&qb[a]?(""+b).trim():b+"px"}
function tb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var
d=0===c.indexOf("--"),e=sb(c,b[c],d);"float"===c&&(c="cssFloat");d?
a.setProperty(c,e):a[c]=e}}var ub=m({menuitem:!0},{area:!0,base:!0,br:!0,col:!
0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!
0,track:!0,wbr:!0});
function vb(a,b){if(b){if(ub[a]&&(null!=b.children||null!
=b.dangerouslySetInnerHTML))throw Error(y(137,a));if(null!
=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(y(60));if(!
("object"===typeof b.dangerouslySetInnerHTML&&"__html"in
b.dangerouslySetInnerHTML))throw Error(y(61));}if(null!=b.style&&"object"!==typeof
b.style)throw Error(y(62));}}
function wb(a,b){if(-1===a.indexOf("-"))return"string"===typeof b.is;switch(a){case
"annotation-xml":case "color-profile":case "font-face":case "font-face-src":case
"font-face-uri":case "font-face-format":case "font-face-name":case "missing-
glyph":return!1;default:return!0}}function xb(a){a=a.target||a.srcElement||
window;a.correspondingUseElement&&(a=a.correspondingUseElement);return
3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null;
function Bb(a){if(a=Cb(a)){if("function"!==typeof yb)throw Error(y(280));var
b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b))}}function Eb(a){zb?Ab?
Ab.push(a):Ab=[a]:zb=a}function Fb(){if(zb){var
a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a<b.length;a++)Bb(b[a])}}function Gb(a,b)
{return a(b)}function Hb(a,b,c,d,e){return a(b,c,d,e)}function Ib(){}var Jb=Gb,Kb=!
1,Lb=!1;function Mb(){if(null!==zb||null!==Ab)Ib(),Fb()}
function Nb(a,b,c){if(Lb)return a(b,c);Lb=!0;try{return Jb(a,b,c)}finally{Lb=!
1,Mb()}}
function Ob(a,b){var c=a.stateNode;if(null===c)return null;var
d=Db(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case
"onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case
"onMouseDown":case "onMouseDownCapture":case "onMouseMove":case
"onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":
(d=!d.disabled)||(a=a.type,d=!
("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!
1}if(a)return null;if(c&&"function"!==
typeof c)throw Error(y(231,b,typeof c));return c}var Pb=!1;if(fa)try{var
Qb={};Object.defineProperty(Qb,"passive",{get:function(){Pb=!
0}});window.addEventListener("test",Qb,Qb);window.removeEventListener("test",Qb,Qb)
}catch(a){Pb=!1}function Rb(a,b,c,d,e,f,g,h,k){var
l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l)}catch(n)
{this.onError(n)}}var Sb=!1,Tb=null,Ub=!1,Vb=null,Wb={onError:function(a){Sb=!
0;Tb=a}};function Xb(a,b,c,d,e,f,g,h,k){Sb=!1;Tb=null;Rb.apply(Wb,arguments)}
function Yb(a,b,c,d,e,f,g,h,k){Xb.apply(this,arguments);if(Sb){if(Sb){var l=Tb;Sb=!
1;Tb=null}else throw Error(y(198));Ub||(Ub=!0,Vb=l)}}function Zb(a){var
b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!
==(b.flags&1026)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function
$b(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!
==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function
ac(a){if(Zb(a)!==a)throw Error(y(188));}
function bc(a){var b=a.alternate;if(!b){b=Zb(a);if(null===b)throw
Error(y(188));return b!==a?null:a}for(var c=a,d=b;;){var
e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d)
{c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return
ac(e),a;if(f===d)return ac(e),b;f=f.sibling}throw Error(y(188));}if(c.return!
==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!
0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;)
{if(h===
c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw
Error(y(189));}}if(c.alternate!==d)throw Error(y(190));}if(3!==c.tag)throw
Error(y(188));return c.stateNode.current===c?a:b}function cc(a){a=bc(a);if(!
a)return null;for(var b=a;;){if(5===b.tag||6===b.tag)return
b;if(b.child)b.child.return=b,b=b.child;else{if(b===a)break;for(;!b.sibling;){if(!
b.return||b.return===a)return
null;b=b.return}b.sibling.return=b.return;b=b.sibling}}return null}
function dc(a,b){for(var c=a.alternate;null!==b;){if(b===a||b===c)return!
0;b=b.return}return!1}var ec,fc,gc,hc,ic=!1,jc=[],kc=null,lc=null,mc=null,nc=new
Map,oc=new Map,pc=[],qc="mousedown mouseup touchcancel touchend touchstart auxclick
dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend
compositionstart keydown keypress keyup input textInput copy cut paste click change
contextmenu reset submit".split(" ");
function rc(a,b,c,d,e){return{blockedOn:a,domEventName:b,eventSystemFlags:c|
16,nativeEvent:e,targetContainers:[d]}}function sc(a,b){switch(a){case
"focusin":case "focusout":kc=null;break;case "dragenter":case
"dragleave":lc=null;break;case "mouseover":case "mouseout":mc=null;break;case
"pointerover":case "pointerout":nc.delete(b.pointerId);break;case
"gotpointercapture":case "lostpointercapture":oc.delete(b.pointerId)}}
function tc(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return
a=rc(b,c,d,e,f),null!==b&&(b=Cb(b),null!==b&&fc(b)),a;a.eventSystemFlags|
=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}
function uc(a,b,c,d,e){switch(b){case "focusin":return kc=tc(kc,a,b,c,d,e),!0;case
"dragenter":return lc=tc(lc,a,b,c,d,e),!0;case "mouseover":return
mc=tc(mc,a,b,c,d,e),!0;case "pointerover":var f=e.pointerId;nc.set(f,tc(nc.get(f)||
null,a,b,c,d,e));return!0;case "gotpointercapture":return
f=e.pointerId,oc.set(f,tc(oc.get(f)||null,a,b,c,d,e)),!0}return!1}
function vc(a){var b=wc(a.target);if(null!==b){var c=Zb(b);if(null!
==c)if(b=c.tag,13===b){if(b=$b(c),null!==b)
{a.blockedOn=b;hc(a.lanePriority,function()
{r.unstable_runWithPriority(a.priority,function(){gc(c)})});return}}else
if(3===b&&c.stateNode.hydrate){a.blockedOn=3===c.tag?
c.stateNode.containerInfo:null;return}}a.blockedOn=null}
function xc(a){if(null!==a.blockedOn)return!1;for(var
b=a.targetContainers;0<b.length;){var
c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c)return
b=Cb(c),null!==b&&fc(b),a.blockedOn=c,!1;b.shift()}return!0}function zc(a,b,c)
{xc(a)&&c.delete(b)}
function Ac(){for(ic=!1;0<jc.length;){var a=jc[0];if(null!==a.blockedOn)
{a=Cb(a.blockedOn);null!==a&&ec(a);break}for(var b=a.targetContainers;0<b.length;)
{var c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c)
{a.blockedOn=c;break}b.shift()}null===a.blockedOn&&jc.shift()}null!
==kc&&xc(kc)&&(kc=null);null!==lc&&xc(lc)&&(lc=null);null!
==mc&&xc(mc)&&(mc=null);nc.forEach(zc);oc.forEach(zc)}
function Bc(a,b){a.blockedOn===b&&(a.blockedOn=null,ic||(ic=!
0,r.unstable_scheduleCallback(r.unstable_NormalPriority,Ac)))}
function Cc(a){function b(b){return Bc(b,a)}if(0<jc.length){Bc(jc[0],a);for(var
c=1;c<jc.length;c++){var d=jc[c];d.blockedOn===a&&(d.blockedOn=null)}}null!
==kc&&Bc(kc,a);null!==lc&&Bc(lc,a);null!
==mc&&Bc(mc,a);nc.forEach(b);oc.forEach(b);for(c=0;c<pc.length;c+
+)d=pc[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<pc.length&&(c=pc[0],null===c.b
lockedOn);)vc(c),null===c.blockedOn&&pc.shift()}
function Dc(a,b){var
c={};c[a.toLowerCase()]=b.toLowerCase();c["Webkit"+a]="webkit"+b;c["Moz"+a]="moz"+b
;return c}var
Ec={animationend:Dc("Animation","AnimationEnd"),animationiteration:Dc("Animation","
AnimationIteration"),animationstart:Dc("Animation","AnimationStart"),transitionend:
Dc("Transition","TransitionEnd")},Fc={},Gc={};
fa&&(Gc=document.createElement("div").style,"AnimationEvent"in window||(delete
Ec.animationend.animation,delete Ec.animationiteration.animation,delete
Ec.animationstart.animation),"TransitionEvent"in window||delete
Ec.transitionend.transition);function Hc(a){if(Fc[a])return Fc[a];if(!Ec[a])return
a;var b=Ec[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Gc)return Fc[a]=b[c];return
a}
var
Ic=Hc("animationend"),Jc=Hc("animationiteration"),Kc=Hc("animationstart"),Lc=Hc("tr
ansitionend"),Mc=new Map,Nc=new
Map,Oc=["abort","abort",Ic,"animationEnd",Jc,"animationIteration",Kc,"animationStar
t","canplay","canPlay","canplaythrough","canPlayThrough","durationchange","duration
Change","emptied","emptied","encrypted","encrypted","ended","ended","error","error"
,"gotpointercapture","gotPointerCapture","load","load","loadeddata","loadedData","l
oadedmetadata","loadedMetadata","loadstart","loadStart",
"lostpointercapture","lostPointerCapture","playing","playing","progress","progress"
,"seeking","seeking","stalled","stalled","suspend","suspend","timeupdate","timeUpda
te",Lc,"transitionEnd","waiting","waiting"];function Pc(a,b){for(var
c=0;c<a.length;c+=2){var d=a[c],e=a[c+1];e="on"+(e[0].toUpperCase()
+e.slice(1));Nc.set(d,b);Mc.set(d,e);da(e,[d])}}var Qc=r.unstable_now;Qc();var F=8;
function Rc(a){if(0!==(1&a))return F=15,1;if(0!==(2&a))return F=14,2;if(0!
==(4&a))return F=13,4;var b=24&a;if(0!==b)return F=12,b;if(0!==(a&32))return
F=11,32;b=192&a;if(0!==b)return F=10,b;if(0!==(a&256))return F=9,256;b=3584&a;if(0!
==b)return F=8,b;if(0!==(a&4096))return F=7,4096;b=4186112&a;if(0!==b)return
F=6,b;b=62914560&a;if(0!==b)return F=5,b;if(a&67108864)return F=4,67108864;if(0!
==(a&134217728))return F=3,134217728;b=805306368&a;if(0!==b)return F=2,b;if(0!
==(1073741824&a))return F=1,1073741824;
F=8;return a}function Sc(a){switch(a){case 99:return 15;case 98:return 10;case
97:case 96:return 8;case 95:return 2;default:return 0}}function Tc(a){switch(a)
{case 15:case 14:return 99;case 13:case 12:case 11:case 10:return 98;case 9:case
8:case 7:case 6:case 4:case 5:return 97;case 3:case 2:case 1:return 95;case
0:return 90;default:throw Error(y(358,a));}}
function Uc(a,b){var c=a.pendingLanes;if(0===c)return F=0;var
d=0,e=0,f=a.expiredLanes,g=a.suspendedLanes,h=a.pingedLanes;if(0!
==f)d=f,e=F=15;else if(f=c&134217727,0!==f){var k=f&~g;0!==k?(d=Rc(k),e=F):(h&=f,0!
==h&&(d=Rc(h),e=F))}else f=c&~g,0!==f?(d=Rc(f),e=F):0!
==h&&(d=Rc(h),e=F);if(0===d)return 0;d=31-Vc(d);d=c&((0>d?0:1<<d)<<1)-1;if(0!
==b&&b!==d&&0===(b&g)){Rc(b);if(e<=F)return b;F=e}b=a.entangledLanes;if(0!
==b)for(a=a.entanglements,b&=d;0<b;)c=31-Vc(b),e=1<<c,d|=a[c],b&=~e;return d}
function Wc(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?
1073741824:0}function Xc(a,b){switch(a){case 15:return 1;case 14:return 2;case
12:return a=Yc(24&~b),0===a?Xc(10,b):a;case 10:return a=Yc(192&~b),0===a?
Xc(8,b):a;case 8:return
a=Yc(3584&~b),0===a&&(a=Yc(4186112&~b),0===a&&(a=512)),a;case 2:return
b=Yc(805306368&~b),0===b&&(b=268435456),b}throw Error(y(358,a));}function Yc(a)
{return a&-a}function Zc(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}
function $c(a,b,c){a.pendingLanes|=b;var d=b-
1;a.suspendedLanes&=d;a.pingedLanes&=d;a=a.eventTimes;b=31-Vc(b);a[b]=c}var
Vc=Math.clz32?Math.clz32:ad,bd=Math.log,cd=Math.LN2;function ad(a){return 0===a?
32:31-(bd(a)/cd|0)|0}var
dd=r.unstable_UserBlockingPriority,ed=r.unstable_runWithPriority,fd=!0;function
gd(a,b,c,d){Kb||Ib();var e=hd,f=Kb;Kb=!0;try{Hb(e,a,b,c,d)}finally{(Kb=f)||
Mb()}}function id(a,b,c,d){ed(dd,hd.bind(null,a,b,c,d))}
function hd(a,b,c,d){if(fd){var e;if((e=0===(b&4))&&0<jc.length&&-
1<qc.indexOf(a))a=rc(null,a,b,c,d),jc.push(a);else{var
f=yc(a,b,c,d);if(null===f)e&&sc(a,d);else{if(e){if(-1<qc.indexOf(a))
{a=rc(f,a,b,c,d);jc.push(a);return}if(uc(f,a,b,c,d))return;sc(a,d)}jd(a,b,d,null,c)
}}}}
function yc(a,b,c,d){var e=xb(d);e=wc(e);if(null!==e){var
f=Zb(e);if(null===f)e=null;else{var g=f.tag;if(13===g){e=$b(f);if(null!==e)return
e;e=null}else if(3===g){if(f.stateNode.hydrate)return 3===f.tag?
f.stateNode.containerInfo:null;e=null}else f!==e&&(e=null)}}jd(a,b,d,e,c);return
null}var kd=null,ld=null,md=null;
function nd(){if(md)return md;var a,b=ld,c=b.length,d,e="value"in kd?
kd.value:kd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-
a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return md=e.slice(a,1<d?1-d:void 0)}function
od(a){var b=a.keyCode;"charCode"in a?
(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?
a:0}function pd(){return!0}function qd(){return!1}
function rd(a){function b(b,d,e,f,g)
{this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;
this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?
b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!
1===f.returnValue)?pd:qd;this.isPropagationStopped=qd;return this}m(b.prototype,
{preventDefault:function(){this.defaultPrevented=!0;var
a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():"unknown"!==typeof
a.returnValue&&
(a.returnValue=!1),this.isDefaultPrevented=pd)},stopPropagation:function(){var
a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():"unknown"!==typeof
a.cancelBubble&&(a.cancelBubble=!
0),this.isPropagationStopped=pd)},persist:function(){},isPersistent:pd});return b}
var sd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return
a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},td=rd(sd),ud=m({},sd,
{view:0,detail:0}),vd=rd(ud),wd,xd,yd,Ad=m({},ud,
{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKe
y:0,metaKey:0,getModifierState:zd,button:0,buttons:0,relatedTarget:function(a)
{return void 0===a.relatedTarget?a.fromElement===a.srcElement?
a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
a)return a.movementX;a!==yd&&(yd&&"mousemove"===a.type?(wd=a.screenX-
yd.screenX,xd=a.screenY-yd.screenY):xd=wd=0,yd=a);return wd},movementY:function(a)
{return"movementY"in a?a.movementY:xd}}),Bd=rd(Ad),Cd=m({},Ad,
{dataTransfer:0}),Dd=rd(Cd),Ed=m({},ud,{relatedTarget:0}),Fd=rd(Ed),Gd=m({},sd,
{animationName:0,elapsedTime:0,pseudoElement:0}),Hd=rd(Gd),Id=m({},sd,
{clipboardData:function(a){return"clipboardData"in a?
a.clipboardData:window.clipboardData}}),Jd=rd(Id),Kd=m({},sd,
{data:0}),Ld=rd(Kd),Md={Esc:"Escape",
Spacebar:"
",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Wi
n:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"U
nidentified"},Nd={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Contro
l",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:"
",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"Arro
wRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",
116:"F5",117:"F6",118:"F7",
119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:
"Meta"},Od={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};functio
n Pd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):
(a=Od[a])?!!b[a]:!1}function zd(){return Pd}
var Qd=m({},ud,{key:function(a){if(a.key){var b=Md[a.key]||a.key;if("Unidentified"!
==b)return b}return"keypress"===a.type?
(a=od(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.typ
e?
Nd[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,m
etaKey:0,repeat:0,locale:0,getModifierState:zd,charCode:function(a)
{return"keypress"===a.type?od(a):0},keyCode:function(a)
{return"keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a)
{return"keypress"===
a.type?od(a):"keydown"===a.type||"keyup"===a.type?
a.keyCode:0}}),Rd=rd(Qd),Sd=m({},Ad,
{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist
:0,pointerType:0,isPrimary:0}),Td=rd(Sd),Ud=m({},ud,
{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0
,getModifierState:zd}),Vd=rd(Ud),Wd=m({},sd,
{propertyName:0,elapsedTime:0,pseudoElement:0}),Xd=rd(Wd),Yd=m({},Ad,
{deltaX:function(a){return"deltaX"in a?a.deltaX:"wheelDeltaX"in a?-
a.wheelDeltaX:0},
deltaY:function(a){return"deltaY"in a?a.deltaY:"wheelDeltaY"in a?-
a.wheelDeltaY:"wheelDelta"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Zd=rd(Yd),
$d=[9,13,27,32],ae=fa&&"CompositionEvent"in window,be=null;fa&&"documentMode"in
document&&(be=document.documentMode);var ce=fa&&"TextEvent"in window&&!be,de=fa&&(!
ae||be&&8<be&&11>=be),ee=String.fromCharCode(32),fe=!1;
function ge(a,b){switch(a){case "keyup":return-1!==$d.indexOf(b.keyCode);case
"keydown":return 229!==b.keyCode;case "keypress":case "mousedown":case
"focusout":return!0;default:return!1}}function he(a)
{a=a.detail;return"object"===typeof a&&"data"in a?a.data:null}var ie=!1;function
je(a,b){switch(a){case "compositionend":return he(b);case "keypress":if(32!
==b.which)return null;fe=!0;return ee;case "textInput":return a=b.data,a===ee&&fe?
null:a;default:return null}}
function ke(a,b){if(ie)return"compositionend"===a||!ae&&ge(a,b)?
(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case "paste":return null;case
"keypress":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey)
{if(b.char&&1<b.char.length)return b.char;if(b.which)return
String.fromCharCode(b.which)}return null;case "compositionend":return de&&"ko"!
==b.locale?null:b.data;default:return null}}
var le={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!
0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function
me(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return"input"===b?!!
le[a.type]:"textarea"===b?!0:!1}function ne(a,b,c,d)
{Eb(d);b=oe(b,"onChange");0<b.length&&(c=new
td("onChange","change",null,c,d),a.push({event:c,listeners:b}))}var
pe=null,qe=null;function re(a){se(a,0)}function te(a){var b=ue(a);if(Wa(b))return
a}
function ve(a,b){if("change"===a)return b}var we=!1;if(fa){var xe;if(fa){var
ye="oninput"in document;if(!ye){var
ze=document.createElement("div");ze.setAttribute("oninput","return;");ye="function"
===typeof ze.oninput}xe=ye}else xe=!1;we=xe&&(!document.documentMode||
9<document.documentMode)}function Ae()
{pe&&(pe.detachEvent("onpropertychange",Be),qe=pe=null)}function Be(a)
{if("value"===a.propertyName&&te(qe)){var
b=[];ne(b,qe,a,xb(a));a=re;if(Kb)a(b);else{Kb=!0;try{Gb(a,b)}finally{Kb=!1,Mb()}}}}
function Ce(a,b,c){"focusin"===a?
(Ae(),pe=b,qe=c,pe.attachEvent("onpropertychange",Be)):"focusout"===a&&Ae()}functio
n De(a){if("selectionchange"===a||"keyup"===a||"keydown"===a)return te(qe)}function
Ee(a,b){if("click"===a)return te(b)}function Fe(a,b)
{if("input"===a||"change"===a)return te(b)}function Ge(a,b){return a===b&&(0!==a||
1/a===1/b)||a!==a&&b!==b}var He="function"===typeof Object.is?
Object.is:Ge,Ie=Object.prototype.hasOwnProperty;
function Je(a,b){if(He(a,b))return!0;if("object"!==typeof a||null===a||"object"!
==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!
==d.length)return!1;for(d=0;d<c.length;d++)if(!Ie.call(b,c[d])||!
He(a[c[d]],b[c[d]]))return!1;return!0}function Ke(a)
{for(;a&&a.firstChild;)a=a.firstChild;return a}
function Le(a,b){var c=Ke(a);a=0;for(var d;c;){if(3===c.nodeType)
{d=a+c.textContent.length;if(a<=b&&d>=b)return{node:c,offset:b-a};a=d}a:{for(;c;)
{if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode}c=void
0}c=Ke(c)}}function Me(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!
1:b&&3===b.nodeType?Me(a,b.parentNode):"contains"in a?
a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}
function Ne(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var
c="string"===typeof b.contentWindow.location.href}catch(d){c=!
1}if(c)a=b.contentWindow;else break;b=Xa(a.document)}return b}function Oe(a){var
b=a&&a.nodeName&&a.nodeName.toLowerCase();return
b&&("input"===b&&("text"===a.type||"search"===a.type||"tel"===a.type||"url"===a.typ
e||"password"===a.type)||"textarea"===b||"true"===a.contentEditable)}
var Pe=fa&&"documentMode"in
document&&11>=document.documentMode,Qe=null,Re=null,Se=null,Te=!1;
function Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?
c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,"selectionStart"in d&&Oe(d)?
d={start:d.selectionStart,end:d.selectionEnd}:
(d=(d.ownerDocument&&d.ownerDocument.defaultView||
window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focus
Node:d.focusNode,focusOffset:d.focusOffset}),Se&&Je(Se,d)||
(Se=d,d=oe(Re,"onSelect"),0<d.length&&(b=new
td("onSelect","select",null,b,c),a.push({event:b,listeners:d}),b.target=Qe)))}
Pc("cancel cancel click click close close contextmenu contextMenu copy copy cut cut
auxclick auxClick dblclick doubleClick dragend dragEnd dragstart dragStart drop
drop focusin focus focusout blur input input invalid invalid keydown keyDown
keypress keyPress keyup keyUp mousedown mouseDown mouseup mouseUp paste paste pause
pause play play pointercancel pointerCancel pointerdown pointerDown pointerup
pointerUp ratechange rateChange reset reset seeked seeked submit submit touchcancel
touchCancel touchend touchEnd touchstart touchStart volumechange
volumeChange".split(" "),
0);Pc("drag drag dragenter dragEnter dragexit dragExit dragleave dragLeave dragover
dragOver mousemove mouseMove mouseout mouseOut mouseover mouseOver pointermove
pointerMove pointerout pointerOut pointerover pointerOver scroll scroll toggle
toggle touchmove touchMove wheel wheel".split(" "),1);Pc(Oc,2);for(var Ve="change
selectionchange textInput compositionstart compositionend
compositionupdate".split(" "),We=0;We<Ve.length;We+
+)Nc.set(Ve[We],0);ea("onMouseEnter",["mouseout","mouseover"]);
ea("onMouseLeave",["mouseout","mouseover"]);ea("onPointerEnter",
["pointerout","pointerover"]);ea("onPointerLeave",
["pointerout","pointerover"]);da("onChange","change click focusin focusout input
keydown keyup selectionchange".split(" "));da("onSelect","focusout contextmenu
dragend focusin keydown keyup mousedown mouseup selectionchange".split("
"));da("onBeforeInput",
["compositionend","keypress","textInput","paste"]);da("onCompositionEnd","compositi
onend focusout keydown keypress keyup mousedown".split(" "));
da("onCompositionStart","compositionstart focusout keydown keypress keyup
mousedown".split(" "));da("onCompositionUpdate","compositionupdate focusout keydown
keypress keyup mousedown".split(" "));var Xe="abort canplay canplaythrough
durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart
pause play playing progress ratechange seeked seeking stalled suspend timeupdate
volumechange waiting".split(" "),Ye=new Set("cancel close invalid load scroll
toggle".split(" ").concat(Xe));
function Ze(a,b,c){var d=a.type||"unknown-event";a.currentTarget=c;Yb(d,b,void
0,a);a.currentTarget=null}
function se(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var
d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--)
{var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!
==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k}else for(g=0;g<d.length;g++)
{h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!
==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k}}}if(Ub)throw a=Vb,Ub=!
1,Vb=null,a;}
function G(a,b){var c=$e(b),d=a+"__bubble";c.has(d)||(af(b,a,2,!1),c.add(d))}var
bf="_reactListening"+Math.random().toString(36).slice(2);function cf(a){a[bf]||
(a[bf]=!0,ba.forEach(function(b){Ye.has(b)||df(b,!1,a,null);df(b,!0,a,null)}))}
function df(a,b,c,d){var e=4<arguments.length&&void 0!==arguments[4]?
arguments[4]:0,f=c;"selectionchange"===a&&9!
==c.nodeType&&(f=c.ownerDocument);if(null!==d&&!b&&Ye.has(a)){if("scroll"!
==a)return;e|=2;f=d}var g=$e(f),h=a+"__"+(b?"capture":"bubble");g.has(h)||(b&&(e|
=4),af(f,a,e,b),g.add(h))}
function af(a,b,c,d){var e=Nc.get(b);switch(void 0===e?2:e){case 0:e=gd;break;case
1:e=id;break;default:e=hd}c=e.bind(null,b,c,a);e=void 0;!Pb||"touchstart"!
==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,
{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?
a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}
function jd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;)
{if(null===d)return;var g=d.tag;if(3===g||4===g){var
h=d.stateNode.containerInfo;if(h===e||
8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var
k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||
8===k.nodeType&&k.parentNode===e)return;g=g.return}for(;null!==h;)
{g=wc(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue
a}h=h.parentNode}}d=d.return}Nb(function(){var d=f,e=xb(c),g=[];
a:{var h=Mc.get(a);if(void 0!==h){var k=td,x=a;switch(a){case
"keypress":if(0===od(c))break a;case "keydown":case "keyup":k=Rd;break;case
"focusin":x="focus";k=Fd;break;case "focusout":x="blur";k=Fd;break;case
"beforeblur":case "afterblur":k=Fd;break;case "click":if(2===c.button)break a;case
"auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case
"mouseout":case "mouseover":case "contextmenu":k=Bd;break;case "drag":case
"dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case
"dragstart":case "drop":k=
Dd;break;case "touchcancel":case "touchend":case "touchmove":case
"touchstart":k=Vd;break;case Ic:case Jc:case Kc:k=Hd;break;case Lc:k=Xd;break;case
"scroll":k=vd;break;case "wheel":k=Zd;break;case "copy":case "cut":case
"paste":k=Jd;break;case "gotpointercapture":case "lostpointercapture":case
"pointercancel":case "pointerdown":case "pointermove":case "pointerout":case
"pointerover":case "pointerup":k=Td}var w=0!==(b&4),z=!w&&"scroll"===a,u=w?null!
==h?h+"Capture":null:h;w=[];for(var t=d,q;null!==
t;){q=t;var v=q.stateNode;5===q.tag&&null!==v&&(q=v,null!==u&&(v=Ob(t,u),null!
=v&&w.push(ef(t,v,q))));if(z)break;t=t.return}0<w.length&&(h=new
k(h,x,null,c,e),g.push({event:h,listeners:w}))}}if(0===(b&7)){a:
{h="mouseover"===a||"pointerover"===a;k="mouseout"===a||"pointerout"===a;if(h&&0===
(b&16)&&(x=c.relatedTarget||c.fromElement)&&(wc(x)||x[ff]))break a;if(k||h)
{h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k)
{if(x=c.relatedTarget||c.toElement,k=d,x=x?wc(x):null,null!==
x&&(z=Zb(x),x!==z||5!==x.tag&&6!==x.tag))x=null}else k=null,x=d;if(k!==x)
{w=Bd;v="onMouseLeave";u="onMouseEnter";t="mouse";if("pointerout"===a||"pointerover
"===a)w=Td,v="onPointerLeave",u="onPointerEnter",t="pointer";z=null==k?
h:ue(k);q=null==x?h:ue(x);h=new
w(v,t+"leave",k,c,e);h.target=z;h.relatedTarget=q;v=null;wc(e)===d&&(w=new
w(u,t+"enter",x,c,e),w.target=q,w.relatedTarget=z,v=w);z=v;if(k&&x)b:
{w=k;u=x;t=0;for(q=w;q;q=gf(q))t++;q=0;for(v=u;v;v=gf(v))q++;for(;0<t-
q;)w=gf(w),t--;for(;0<q-t;)u=
gf(u),q--;for(;t--;){if(w===u||null!==u&&w===u.alternate)break
b;w=gf(w);u=gf(u)}w=null}else w=null;null!==k&&hf(g,h,k,w,!1);null!==x&&null!
==z&&hf(g,z,x,w,!0)}}}a:{h=d?
ue(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if("select"===k||"input"===k&&"
file"===h.type)var J=ve;else if(me(h))if(we)J=Fe;else{J=De;var
K=Ce}else(k=h.nodeName)&&"input"===k.toLowerCase()&&("checkbox"===h.type||"radio"==
=h.type)&&(J=Ee);if(J&&(J=J(a,d))){ne(g,J,c,e);break
a}K&&K(a,h,d);"focusout"===a&&(K=h._wrapperState)&&
K.controlled&&"number"===h.type&&bb(h,"number",h.value)}K=d?ue(d):window;switch(a)
{case "focusin":if(me(K)||"true"===K.contentEditable)Qe=K,Re=d,Se=null;break;case
"focusout":Se=Re=Qe=null;break;case "mousedown":Te=!0;break;case "contextmenu":case
"mouseup":case "dragend":Te=!1;Ue(g,c,e);break;case
"selectionchange":if(Pe)break;case "keydown":case "keyup":Ue(g,c,e)}var Q;if(ae)b:
{switch(a){case "compositionstart":var L="onCompositionStart";break b;case
"compositionend":L="onCompositionEnd";break b;
case "compositionupdate":L="onCompositionUpdate";break b}L=void 0}else ie?
ge(a,c)&&(L="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(L="onCompositionSt
art");L&&(de&&"ko"!==c.locale&&(ie||"onCompositionStart"!
==L?"onCompositionEnd"===L&&ie&&(Q=nd()):(kd=e,ld="value"in kd?
kd.value:kd.textContent,ie=!0)),K=oe(d,L),0<K.length&&(L=new
Ld(L,a,null,c,e),g.push({event:L,listeners:K}),Q?L.data=Q:(Q=he(c),null!
==Q&&(L.data=Q))));if(Q=ce?
je(a,c):ke(a,c))d=oe(d,"onBeforeInput"),0<d.length&&(e=new Ld("onBeforeInput",
"beforeinput",null,c,e),g.push({event:e,listeners:d}),e.data=Q)}se(g,b)})}function
ef(a,b,c){return{instance:a,listener:b,currentTarget:c}}function oe(a,b){for(var
c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!
==f&&(e=f,f=Ob(a,c),null!=f&&d.unshift(ef(a,f,e)),f=Ob(a,b),null!
=f&&d.push(ef(a,f,e)));a=a.return}return d}function gf(a){if(null===a)return
null;do a=a.return;while(a&&5!==a.tag);return a?a:null}
function hf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var
h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!
==l&&(h=l,e?(k=Ob(c,f),null!=k&&g.unshift(ef(c,k,h))):e||(k=Ob(c,f),null!
=k&&g.push(ef(c,k,h))));c=c.return}0!
==g.length&&a.push({event:b,listeners:g})}function jf(){}var
kf=null,lf=null;function mf(a,b){switch(a){case "button":case "input":case
"select":case "textarea":return!!b.autoFocus}return!1}
function nf(a,b)
{return"textarea"===a||"option"===a||"noscript"===a||"string"===typeof
b.children||"number"===typeof b.children||"object"===typeof
b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!
=b.dangerouslySetInnerHTML.__html}var of="function"===typeof setTimeout?
setTimeout:void 0,pf="function"===typeof clearTimeout?clearTimeout:void 0;function
qf(a){1===a.nodeType?a.textContent="":9===a.nodeType&&(a=a.body,null!
=a&&(a.textContent=""))}
function rf(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||
3===b)break}return a}function sf(a){a=a.previousSibling;for(var b=0;a;)
{if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return
a;b--}else"/$"===c&&b++}a=a.previousSibling}return null}var tf=0;function uf(a)
{return{$$typeof:Ga,toString:a,valueOf:a}}var
vf=Math.random().toString(36).slice(2),wf="__reactFiber$"+vf,xf="__reactProps$"+vf,
ff="__reactContainer$"+vf,yf="__reactEvents$"+vf;
function wc(a){var b=a[wf];if(b)return b;for(var c=a.parentNode;c;){if(b=c[ff]||
c[wf]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=sf(a);null!
==a;){if(c=a[wf])return c;a=sf(a)}return b}a=c;c=a.parentNode}return null}function
Cb(a){a=a[wf]||a[ff];return!a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?
null:a}function ue(a){if(5===a.tag||6===a.tag)return a.stateNode;throw
Error(y(33));}function Db(a){return a[xf]||null}
function $e(a){var b=a[yf];void 0===b&&(b=a[yf]=new Set);return b}var zf=[],Af=-
1;function Bf(a){return{current:a}}function H(a){0>Af||
(a.current=zf[Af],zf[Af]=null,Af--)}function I(a,b){Af+
+;zf[Af]=a.current;a.current=b}var Cf={},M=Bf(Cf),N=Bf(!1),Df=Cf;
function Ef(a,b){var c=a.type.contextTypes;if(!c)return Cf;var
d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return
d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in
c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__r
eactInternalMemoizedMaskedChildContext=e);return e}function Ff(a)
{a=a.childContextTypes;return null!==a&&void 0!==a}function Gf(){H(N);H(M)}function
Hf(a,b,c){if(M.current!==Cf)throw Error(y(168));I(M,b);I(N,c)}
function If(a,b,c){var d=a.stateNode;a=b.childContextTypes;if("function"!==typeof
d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in a))throw
Error(y(108,Ra(b)||"Unknown",e));return m({},c,d)}function Jf(a)
{a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||
Cf;Df=M.current;I(M,a);I(N,N.current);return!0}function Kf(a,b,c){var
d=a.stateNode;if(!d)throw Error(y(169));c?
(a=If(a,b,Df),d.__reactInternalMemoizedMergedChildContext=a,H(N),H(M),I(M,a)):H(N);
I(N,c)}
var
Lf=null,Mf=null,Nf=r.unstable_runWithPriority,Of=r.unstable_scheduleCallback,Pf=r.u
nstable_cancelCallback,Qf=r.unstable_shouldYield,Rf=r.unstable_requestPaint,Sf=r.un
stable_now,Tf=r.unstable_getCurrentPriorityLevel,Uf=r.unstable_ImmediatePriority,Vf
=r.unstable_UserBlockingPriority,Wf=r.unstable_NormalPriority,Xf=r.unstable_LowPrio
rity,Yf=r.unstable_IdlePriority,Zf={},$f=void 0!==Rf?Rf:function()
{},ag=null,bg=null,cg=!1,dg=Sf(),O=1E4>dg?Sf:function(){return Sf()-dg};
function eg(){switch(Tf()){case Uf:return 99;case Vf:return 98;case Wf:return
97;case Xf:return 96;case Yf:return 95;default:throw Error(y(332));}}function fg(a)
{switch(a){case 99:return Uf;case 98:return Vf;case 97:return Wf;case 96:return
Xf;case 95:return Yf;default:throw Error(y(332));}}function gg(a,b){a=fg(a);return
Nf(a,b)}function hg(a,b,c){a=fg(a);return Of(a,b,c)}function ig(){if(null!==bg){var
a=bg;bg=null;Pf(a)}jg()}
function jg(){if(!cg&&null!==ag){cg=!0;var a=0;try{var b=ag;gg(99,function()
{for(;a<b.length;a++){var c=b[a];do c=c(!0);while(null!==c)}});ag=null}catch(c)
{throw null!==ag&&(ag=ag.slice(a+1)),Of(Uf,ig),c;}finally{cg=!1}}}var
kg=ra.ReactCurrentBatchConfig;function lg(a,b){if(a&&a.defaultProps)
{b=m({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return
b}return b}var mg=Bf(null),ng=null,og=null,pg=null;function qg(){pg=og=ng=null}
function rg(a){var b=mg.current;H(mg);a.type._context._currentValue=b}function
sg(a,b){for(;null!==a;){var c=a.alternate;if((a.childLanes&b)===b)if(null===c||
(c.childLanes&b)===b)break;else c.childLanes|=b;else a.childLanes|=b,null!
==c&&(c.childLanes|=b);a=a.return}}function tg(a,b)
{ng=a;pg=og=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!
==(a.lanes&b)&&(ug=!0),a.firstContext=null)}
function vg(a,b){if(pg!==a&&!1!==b&&0!==b){if("number"!==typeof b||
1073741823===b)pg=a,b=1073741823;b={context:a,observedBits:b,next:null};if(null===o
g){if(null===ng)throw
Error(y(308));og=b;ng.dependencies={lanes:0,firstContext:b,responders:null}}else
og=og.next=b}return a._currentValue}var wg=!1;function xg(a)
{a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,
shared:{pending:null},effects:null}}
function yg(a,b)
{a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBase
Update:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.
effects})}function zg(a,b)
{return{eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}function
Ag(a,b){a=a.updateQueue;if(null!==a){a=a.shared;var c=a.pending;null===c?b.next=b:
(b.next=c.next,c.next=b);a.pending=b}}
function Bg(a,b){var c=a.updateQueue,d=a.alternate;if(null!
==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c)
{do{var
g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callbac
k,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?
e=f=b:f=f.next=b}else
e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,e
ffects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?
c.firstBaseUpdate=b:a.next=
b;c.lastBaseUpdate=b}
function Cg(a,b,c,d){var e=a.updateQueue;wg=!1;var
f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h)
{e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var
n=a.alternate;if(null!==n){n=n.updateQueue;var A=n.lastBaseUpdate;A!==g&&(null===A?
n.firstBaseUpdate=l:A.next=l,n.lastBaseUpdate=k)}}if(null!==f)
{A=e.baseState;g=0;n=l=k=null;do{h=f.lane;var p=f.eventTime;if((d&h)===h){null!
==n&&(n=n.next={eventTime:p,lane:0,tag:f.tag,payload:f.payload,callback:f.callback,
next:null});a:{var C=a,x=f;h=b;p=c;switch(x.tag){case
1:C=x.payload;if("function"===typeof C){A=C.call(p,A,h);break a}A=C;break a;case
3:C.flags=C.flags&-4097|64;case 0:C=x.payload;h="function"===typeof C?
C.call(p,A,h):C;if(null===h||void 0===h)break a;A=m({},A,h);break a;case 2:wg=!
0}}null!==f.callback&&(a.flags|=32,h=e.effects,null===h?
e.effects=[f]:h.push(f))}else
p={eventTime:p,lane:h,tag:f.tag,payload:f.payload,callback:f.callback,next:null},nu
ll===n?(l=n=p,k=A):n=n.next=p,g|=h;f=f.next;if(null===
f)if(h=e.shared.pending,null===h)break;else
f=h.next,h.next=null,e.lastBaseUpdate=h,e.shared.pending=null}while(1);null===n&&(k
=A);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=n;Dg|
=g;a.lanes=g;a.memoizedState=A}}function Eg(a,b,c)
{a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var
d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if("function"!==typeof e)throw
Error(y(191,e));e.call(d)}}}var Fg=(new aa.Component).refs;
function Gg(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?
b:m({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}
var Kg={isMounted:function(a){return(a=a._reactInternals)?Zb(a)===a:!
1},enqueueSetState:function(a,b,c){a=a._reactInternals;var
d=Hg(),e=Ig(a),f=zg(d,e);f.payload=b;void 0!==c&&null!
==c&&(f.callback=c);Ag(a,f);Jg(a,e,d)},enqueueReplaceState:function(a,b,c)
{a=a._reactInternals;var d=Hg(),e=Ig(a),f=zg(d,e);f.tag=1;f.payload=b;void 0!
==c&&null!==c&&(f.callback=c);Ag(a,f);Jg(a,e,d)},enqueueForceUpdate:function(a,b)
{a=a._reactInternals;var c=Hg(),d=Ig(a),e=zg(c,d);e.tag=2;void 0!==b&&null!
==b&&(e.callback=
b);Ag(a,e);Jg(a,d,c)}};function Lg(a,b,c,d,e,f,g)
{a=a.stateNode;return"function"===typeof a.shouldComponentUpdate?
a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!
Je(c,d)||!Je(e,f):!0}
function Mg(a,b,c){var d=!1,e=Cf;var f=b.contextType;"object"===typeof f&&null!==f?
f=vg(f):(e=Ff(b)?Df:M.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?
Ef(a,e):Cf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?
b.state:null;b.updater=Kg;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__r
eactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildCont
ext=f);return b}
function Ng(a,b,c,d){a=b.state;"function"===typeof
b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);"function"===typeof
b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state
!==a&&Kg.enqueueReplaceState(b,b.state,null)}
function Og(a,b,c,d){var
e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs=Fg;xg(a);var
f=b.contextType;"object"===typeof f&&null!==f?e.context=vg(f):(f=Ff(b)?
Df:M.current,e.context=Ef(a,f));Cg(a,c,e,d);e.state=a.memoizedState;f=b.getDerivedS
tateFromProps;"function"===typeof
f&&(Gg(a,b,f,c),e.state=a.memoizedState);"function"===typeof
b.getDerivedStateFromProps||"function"===typeof
e.getSnapshotBeforeUpdate||"function"!==typeof
e.UNSAFE_componentWillMount&&"function"!==typeof e.componentWillMount||
(b=e.state,"function"===typeof
e.componentWillMount&&e.componentWillMount(),"function"===typeof
e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!
==e.state&&Kg.enqueueReplaceState(e,e.state,null),Cg(a,c,e,d),e.state=a.memoizedSta
te);"function"===typeof e.componentDidMount&&(a.flags|=4)}var Pg=Array.isArray;
function Qg(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a)
{if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(y(309));var
d=c.stateNode}if(!d)throw Error(y(147,a));var e=""+a;if(null!==b&&null!
==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===e)return b.ref;b=function(a)
{var b=d.refs;b===Fg&&(b=d.refs={});null===a?delete
b[e]:b[e]=a};b._stringRef=e;return b}if("string"!==typeof a)throw
Error(y(284));if(!c._owner)throw Error(y(290,a));}return a}
function Rg(a,b){if("textarea"!==a.type)throw Error(y(31,"[object
Object]"===Object.prototype.toString.call(b)?"object with keys
{"+Object.keys(b).join(", ")+"}":b));}
function Sg(a){function b(b,c){if(a){var d=b.lastEffect;null!==d?
(d.nextEffect=c,b.lastEffect=c):b.firstEffect=b.lastEffect=c;c.nextEffect=null;c.fl
ags=8}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return
null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?
a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b)
{a=Tg(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!
a)return c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags=2,
c):d;b.flags=2;return c}function g(b){a&&null===b.alternate&&(b.flags=2);return
b}function h(a,b,c,d){if(null===b||6!==b.tag)return
b=Ug(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d)
{if(null!==b&&b.elementType===c.type)return
d=e(b,c.props),d.ref=Qg(a,b,c),d.return=a,d;d=Vg(c.type,c.key,c.props,null,a.mode,d
);d.ref=Qg(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||
b.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!
==c.implementation)return b=
Wg(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function
n(a,b,c,d,f){if(null===b||7!==b.tag)return
b=Xg(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function A(a,b,c)
{if("string"===typeof b||"number"===typeof b)return
b=Ug(""+b,a.mode,c),b.return=a,b;if("object"===typeof b&&null!==b){switch(b.$
$typeof){case sa:return
c=Vg(b.type,b.key,b.props,null,a.mode,c),c.ref=Qg(a,null,b),c.return=a,c;case
ta:return b=Wg(b,a.mode,c),b.return=a,b}if(Pg(b)||La(b))return b=Xg(b,
a.mode,c,null),b.return=a,b;Rg(a,b)}return null}function p(a,b,c,d){var e=null!==b?
b.key:null;if("string"===typeof c||"number"===typeof c)return null!==e?
null:h(a,b,""+c,d);if("object"===typeof c&&null!==c){switch(c.$$typeof){case
sa:return c.key===e?c.type===ua?n(a,b,c.props.children,d,e):k(a,b,c,d):null;case
ta:return c.key===e?l(a,b,c,d):null}if(Pg(c)||La(c))return null!==e?
null:n(a,b,c,d,null);Rg(a,c)}return null}function C(a,b,c,d,e){if("string"===typeof
d||"number"===typeof d)return a=a.get(c)||
null,h(b,a,""+d,e);if("object"===typeof d&&null!==d){switch(d.$$typeof){case
sa:return a=a.get(null===d.key?c:d.key)||null,d.type===ua?
n(b,a,d.props.children,e,d.key):k(b,a,d,e);case ta:return a=a.get(null===d.key?
c:d.key)||null,l(b,a,d,e)}if(Pg(d)||La(d))return a=a.get(c)||
null,n(b,a,d,e,null);Rg(b,d)}return null}function x(e,g,h,k){for(var
l=null,t=null,u=g,z=g=0,q=null;null!==u&&z<h.length;z++){u.index>z?
(q=u,u=null):q=u.sibling;var n=p(e,u,h[z],k);if(null===n)
{null===u&&(u=q);break}a&&u&&null===
n.alternate&&b(e,u);g=f(n,g,z);null===t?
l=n:t.sibling=n;t=n;u=q}if(z===h.length)return c(e,u),l;if(null===u)
{for(;z<h.length;z++)u=A(e,h[z],k),null!==u&&(g=f(u,g,z),null===t?
l=u:t.sibling=u,t=u);return l}for(u=d(e,u);z<h.length;z++)q=C(u,e,z,h[z],k),null!
==q&&(a&&null!==q.alternate&&u.delete(null===q.key?z:q.key),g=f(q,g,z),null===t?
l=q:t.sibling=q,t=q);a&&u.forEach(function(a){return b(e,a)});return l}function
w(e,g,h,k){var l=La(h);if("function"!==typeof l)throw
Error(y(150));h=l.call(h);if(null==
h)throw Error(y(151));for(var t=l=null,u=g,z=g=0,q=null,n=h.next();null!==u&&!
n.done;z++,n=h.next()){u.index>z?(q=u,u=null):q=u.sibling;var
w=p(e,u,n.value,k);if(null===w)
{null===u&&(u=q);break}a&&u&&null===w.alternate&&b(e,u);g=f(w,g,z);null===t?
l=w:t.sibling=w;t=w;u=q}if(n.done)return c(e,u),l;if(null===u){for(;!n.done;z+
+,n=h.next())n=A(e,n.value,k),null!==n&&(g=f(n,g,z),null===t?
l=n:t.sibling=n,t=n);return l}for(u=d(e,u);!n.done;z+
+,n=h.next())n=C(u,e,z,n.value,k),null!==n&&(a&&null!==n.alternate&&
u.delete(null===n.key?z:n.key),g=f(n,g,z),null===t?
l=n:t.sibling=n,t=n);a&&u.forEach(function(a){return b(e,a)});return l}return
function(a,d,f,h){var k="object"===typeof f&&null!
==f&&f.type===ua&&null===f.key;k&&(f=f.props.children);var l="object"===typeof
f&&null!==f;if(l)switch(f.$$typeof){case sa:a:{l=f.key;for(k=d;null!==k;)
{if(k.key===l){switch(k.tag){case 7:if(f.type===ua)
{c(a,k.sibling);d=e(k,f.props.children);d.return=a;a=d;break
a}break;default:if(k.elementType===f.type){c(a,k.sibling);
d=e(k,f.props);d.ref=Qg(a,k,f);d.return=a;a=d;break a}}c(a,k);break}else
b(a,k);k=k.sibling}f.type===ua?
(d=Xg(f.props.children,a.mode,h,f.key),d.return=a,a=d):
(h=Vg(f.type,f.key,f.props,null,a.mode,h),h.ref=Qg(a,d,f),h.return=a,a=h)}return
g(a);case ta:a:{for(k=f.key;null!==d;)
{if(d.key===k)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNod
e.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||
[]);d.return=a;a=d;break a}else{c(a,d);break}else b(a,d);d=d.sibling}d=
Wg(f,a.mode,h);d.return=a;a=d}return g(a)}if("string"===typeof f||"number"===typeof
f)return f=""+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):
(c(a,d),d=Ug(f,a.mode,h),d.return=a,a=d),g(a);if(Pg(f))return
x(a,d,f,h);if(La(f))return w(a,d,f,h);l&&Rg(a,f);if("undefined"===typeof f&&!
k)switch(a.tag){case 1:case 22:case 0:case 11:case 15:throw
Error(y(152,Ra(a.type)||"Component"));}return c(a,d)}}var Yg=Sg(!0),Zg=Sg(!1),
$g={},ah=Bf($g),bh=Bf($g),ch=Bf($g);
function dh(a){if(a===$g)throw Error(y(174));return a}function eh(a,b)
{I(ch,b);I(bh,a);I(ah,$g);a=b.nodeType;switch(a){case 9:case
11:b=(b=b.documentElement)?b.namespaceURI:mb(null,"");break;default:a=8===a?
b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=mb(b,a)}H(ah);I(ah,b)}function
fh(){H(ah);H(bh);H(ch)}function gh(a){dh(ch.current);var b=dh(ah.current);var
c=mb(b,a.type);b!==c&&(I(bh,a),I(ah,c))}function hh(a)
{bh.current===a&&(H(ah),H(bh))}var P=Bf(0);
function ih(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!
==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else
if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&64))return
b}else if(null!==b.child)
{b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;)
{if(null===b.return||b.return===a)return
null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var
jh=null,kh=null,lh=!1;
function mh(a,b){var
c=nh(5,null,null,0);c.elementType="DELETED";c.type="DELETED";c.stateNode=b;c.return
=a;c.flags=8;null!==a.lastEffect?
(a.lastEffect.nextEffect=c,a.lastEffect=c):a.firstEffect=a.lastEffect=c}function
oh(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!
==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,!0):!1;case
6:return b=""===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,!0):!
1;case 13:return!1;default:return!1}}
function ph(a){if(lh){var b=kh;if(b){var c=b;if(!oh(a,b)){b=rf(c.nextSibling);if(!
b||!oh(a,b)){a.flags=a.flags&-1025|2;lh=!
1;jh=a;return}mh(jh,c)}jh=a;kh=rf(b.firstChild)}else a.flags=a.flags&-1025|2,lh=!
1,jh=a}}function qh(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!
==a.tag;)a=a.return;jh=a}
function rh(a){if(a!==jh)return!1;if(!lh)return qh(a),lh=!0,!1;var b=a.type;if(5!
==a.tag||"head"!==b&&"body"!==b&&!
nf(b,a.memoizedProps))for(b=kh;b;)mh(a,b),b=rf(b.nextSibling);qh(a);if(13===a.tag)
{a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(y(317));a:
{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if("/$"===c){if(0===b)
{kh=rf(a.nextSibling);break a}b--}else"$"!==c&&"$!"!==c&&"$?"!==c||b+
+}a=a.nextSibling}kh=null}}else kh=jh?rf(a.stateNode.nextSibling):null;return!0}
function sh(){kh=jh=null;lh=!1}var th=[];function uh(){for(var a=0;a<th.length;a+
+)th[a]._workInProgressVersionPrimary=null;th.length=0}var
vh=ra.ReactCurrentDispatcher,wh=ra.ReactCurrentBatchConfig,xh=0,R=null,S=null,T=nul
l,yh=!1,zh=!1;function Ah(){throw Error(y(321));}function Bh(a,b)
{if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!
He(a[c],b[c]))return!1;return!0}
function Ch(a,b,c,d,e,f)
{xh=f;R=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;vh.current=null===a||
null===a.memoizedState?Dh:Eh;a=c(d,e);if(zh){f=0;do{zh=!1;if(!(25>f))throw
Error(y(301));f+=1;T=S=null;b.updateQueue=null;vh.current=Fh;a=c(d,e)}while(zh)}vh.
current=Gh;b=null!==S&&null!==S.next;xh=0;T=S=R=null;yh=!1;if(b)throw
Error(y(300));return a}function Hh(){var
a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===T?
R.memoizedState=T=a:T=T.next=a;return T}
function Ih(){if(null===S){var a=R.alternate;a=null!==a?a.memoizedState:null}else
a=S.next;var b=null===T?R.memoizedState:T.next;if(null!
==b)T=b,S=a;else{if(null===a)throw
Error(y(310));S=a;a={memoizedState:S.memoizedState,baseState:S.baseState,baseQueue:
S.baseQueue,queue:S.queue,next:null};null===T?R.memoizedState=T=a:T=T.next=a}return
T}function Jh(a,b){return"function"===typeof b?b(a):b}
function Kh(a){var b=Ih(),c=b.queue;if(null===c)throw
Error(y(311));c.lastRenderedReducer=a;var d=S,e=d.baseQueue,f=c.pending;if(null!
==f){if(null!==e){var
g=e.next;e.next=f.next;f.next=g}d.baseQueue=e=f;c.pending=null}if(null!==e)
{e=e.next;d=d.baseState;var h=g=f=null,k=e;do{var l=k.lane;if((xh&l)===l)null!
==h&&(h=h.next={lane:0,action:k.action,eagerReducer:k.eagerReducer,eagerState:k.eag
erState,next:null}),d=k.eagerReducer===a?k.eagerState:a(d,k.action);else{var
n={lane:l,action:k.action,eagerReducer:k.eagerReducer,
eagerState:k.eagerState,next:null};null===h?(g=h=n,f=d):h=h.next=n;R.lanes|=l;Dg|
=l}k=k.next}while(null!==k&&k!==e);null===h?f=d:h.next=g;He(d,b.memoizedState)||
(ug=!
0);b.memoizedState=d;b.baseState=f;b.baseQueue=h;c.lastRenderedState=d}return[b.mem
oizedState,c.dispatch]}
function Lh(a){var b=Ih(),c=b.queue;if(null===c)throw
Error(y(311));c.lastRenderedReducer=a;var
d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var
g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);He(f,b.memoizedState)||(ug=!
0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}retu
rn[f,d]}
function Mh(a,b,c){var d=b._getVersion;d=d(b._source);var
e=b._workInProgressVersionPrimary;if(null!==e)a=e===d;else
if(a=a.mutableReadLanes,a=(xh&a)===a)b._workInProgressVersionPrimary=d,th.push(b);i
f(a)return c(b._source);th.push(b);throw Error(y(350));}
function Nh(a,b,c,d){var e=U;if(null===e)throw Error(y(349));var
f=b._getVersion,g=f(b._source),h=vh.current,k=h.useState(function(){return
Mh(e,b,c)}),l=k[1],n=k[0];k=T;var
A=a.memoizedState,p=A.refs,C=p.getSnapshot,x=A.source;A=A.subscribe;var
w=R;a.memoizedState={refs:p,source:b,subscribe:d};h.useEffect(function()
{p.getSnapshot=c;p.setSnapshot=l;var a=f(b._source);if(!He(g,a))
{a=c(b._source);He(n,a)||(l(a),a=Ig(w),e.mutableReadLanes|
=a&e.pendingLanes);a=e.mutableReadLanes;e.entangledLanes|=a;for(var d=
e.entanglements,h=a;0<h;){var k=31-Vc(h),v=1<<k;d[k]|=a;h&=~v}}},
[c,b,d]);h.useEffect(function(){return d(b._source,function(){var
a=p.getSnapshot,c=p.setSnapshot;try{c(a(b._source));var d=Ig(w);e.mutableReadLanes|
=d&e.pendingLanes}catch(q){c(function(){throw q;})}})},
[b,d]);He(C,c)&&He(x,b)&&He(A,d)||
(a={pending:null,dispatch:null,lastRenderedReducer:Jh,lastRenderedState:n},a.dispat
ch=l=Oh.bind(null,R,a),k.queue=a,k.baseQueue=null,n=Mh(e,b,c),k.memoizedState=k.bas
eState=n);return n}
function Ph(a,b,c){var d=Ih();return Nh(d,a,b,c)}function Qh(a){var
b=Hh();"function"===typeof
a&&(a=a());b.memoizedState=b.baseState=a;a=b.queue={pending:null,dispatch:null,last
RenderedReducer:Jh,lastRenderedState:a};a=a.dispatch=Oh.bind(null,R,a);return[b.mem
oizedState,a]}
function Rh(a,b,c,d)
{a={tag:a,create:b,destroy:c,deps:d,next:null};b=R.updateQueue;null===b?
(b={lastEffect:null},R.updateQueue=b,b.lastEffect=a.next=a):
(c=b.lastEffect,null===c?b.lastEffect=a.next=a:
(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function Sh(a){var
b=Hh();a={current:a};return b.memoizedState=a}function Th(){return
Ih().memoizedState}function Uh(a,b,c,d){var e=Hh();R.flags|=a;e.memoizedState=Rh(1|
b,c,void 0,void 0===d?null:d)}
function Vh(a,b,c,d){var e=Ih();d=void 0===d?null:d;var f=void 0;if(null!==S){var
g=S.memoizedState;f=g.destroy;if(null!==d&&Bh(d,g.deps))
{Rh(b,c,f,d);return}}R.flags|=a;e.memoizedState=Rh(1|b,c,f,d)}function Wh(a,b)
{return Uh(516,4,a,b)}function Xh(a,b){return Vh(516,4,a,b)}function Yh(a,b){return
Vh(4,2,a,b)}function Zh(a,b){if("function"===typeof b)return a=a(),b(a),function()
{b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function()
{b.current=null}}
function $h(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return
Vh(4,2,Zh.bind(null,b,a),c)}function ai(){}function bi(a,b){var c=Ih();b=void
0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return
d[0];c.memoizedState=[a,b];return a}function ci(a,b){var c=Ih();b=void 0===b?
null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return
d[0];a=a();c.memoizedState=[a,b];return a}
function di(a,b){var c=eg();gg(98>c?98:c,function(){a(!0)});gg(97<c?97:c,function()
{var c=wh.transition;wh.transition=1;try{a(!1),b()}finally{wh.transition=c}})}
function Oh(a,b,c){var
d=Hg(),e=Ig(a),f={lane:e,action:c,eagerReducer:null,eagerState:null,next:null},g=b.
pending;null===g?f.next=f:
(f.next=g.next,g.next=f);b.pending=f;g=a.alternate;if(a===R||null!
==g&&g===R)zh=yh=!0;else{if(0===a.lanes&&(null===g||
0===g.lanes)&&(g=b.lastRenderedReducer,null!==g))try{var
h=b.lastRenderedState,k=g(h,c);f.eagerReducer=g;f.eagerState=k;if(He(k,h))return}ca
tch(l){}finally{}Jg(a,e,d)}}
var
Gh={readContext:vg,useCallback:Ah,useContext:Ah,useEffect:Ah,useImperativeHandle:Ah
,useLayoutEffect:Ah,useMemo:Ah,useReducer:Ah,useRef:Ah,useState:Ah,useDebugValue:Ah
,useDeferredValue:Ah,useTransition:Ah,useMutableSource:Ah,useOpaqueIdentifier:Ah,un
stable_isNewReconciler:!1},Dh={readContext:vg,useCallback:function(a,b)
{Hh().memoizedState=[a,void 0===b?null:b];return
a},useContext:vg,useEffect:Wh,useImperativeHandle:function(a,b,c){c=null!==c&&void
0!==c?c.concat([a]):null;return Uh(4,2,Zh.bind(null,
b,a),c)},useLayoutEffect:function(a,b){return Uh(4,2,a,b)},useMemo:function(a,b)
{var c=Hh();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return
a},useReducer:function(a,b,c){var d=Hh();b=void 0!==c?
c(b):b;d.memoizedState=d.baseState=b;a=d.queue={pending:null,dispatch:null,lastRend
eredReducer:a,lastRenderedState:b};a=a.dispatch=Oh.bind(null,R,a);return[d.memoized
State,a]},useRef:Sh,useState:Qh,useDebugValue:ai,useDeferredValue:function(a){var
b=Qh(a),c=b[0],d=b[1];Wh(function(){var b=wh.transition;
wh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return
c},useTransition:function(){var a=Qh(!
1),b=a[0];a=di.bind(null,a[1]);Sh(a);return[a,b]},useMutableSource:function(a,b,c)
{var d=Hh();d.memoizedState={refs:
{getSnapshot:b,setSnapshot:null},source:a,subscribe:c};return
Nh(d,a,b,c)},useOpaqueIdentifier:function(){if(lh){var a=!1,b=uf(function(){a||(a=!
0,c("r:"+(tf++).toString(36)));throw Error(y(355));}),c=Qh(b)
[1];0===(R.mode&2)&&(R.flags|=516,Rh(5,function(){c("r:"+(tf++).toString(36))},
void 0,null));return b}b="r:"+(tf++).toString(36);Qh(b);return
b},unstable_isNewReconciler:!
1},Eh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle
:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Kh,useRef:Th,useState:function()
{return Kh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var
b=Kh(Jh),c=b[0],d=b[1];Xh(function(){var
b=wh.transition;wh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return
c},useTransition:function(){var a=Kh(Jh)[0];return[Th().current,
a]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Kh(Jh)
[0]},unstable_isNewReconciler:!
1},Fh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle
:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Lh,useRef:Th,useState:function()
{return Lh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var
b=Lh(Jh),c=b[0],d=b[1];Xh(function(){var
b=wh.transition;wh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return
c},useTransition:function(){var a=Lh(Jh)[0];return[Th().current,
a]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Lh(Jh)
[0]},unstable_isNewReconciler:!1},ei=ra.ReactCurrentOwner,ug=!1;function
fi(a,b,c,d){b.child=null===a?Zg(b,null,c,d):Yg(b,a.child,c,d)}function
gi(a,b,c,d,e){c=c.render;var f=b.ref;tg(b,e);d=Ch(a,b,c,d,f,e);if(null!==a&&!
ug)return b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|
=1;fi(a,b,d,e);return b.child}
function ii(a,b,c,d,e,f){if(null===a){var g=c.type;if("function"===typeof g&&!
ji(g)&&void 0===g.defaultProps&&null===c.compare&&void 0===c.defaultProps)return
b.tag=15,b.type=g,ki(a,b,g,d,e,f);a=Vg(c.type,null,d,b,b.mode,f);a.ref=b.ref;a.retu
rn=b;return
b.child=a}g=a.child;if(0===(e&f)&&(e=g.memoizedProps,c=c.compare,c=null!==c?
c:Je,c(e,d)&&a.ref===b.ref))return hi(a,b,f);b.flags|
=1;a=Tg(g,d);a.ref=b.ref;a.return=b;return b.child=a}
function ki(a,b,c,d,e,f){if(null!==a&&Je(a.memoizedProps,d)&&a.ref===b.ref)if(ug=!
1,0!==(f&e))0!==(a.flags&16384)&&(ug=!0);else return
b.lanes=a.lanes,hi(a,b,f);return li(a,b,c,d,f)}
function mi(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?
a.memoizedState:null;if("hidden"===d.mode||"unstable-defer-without-
hiding"===d.mode)if(0===(b.mode&4))b.memoizedState={baseLanes:0},ni(b,c);else if(0!
==(c&1073741824))b.memoizedState={baseLanes:0},ni(b,null!==f?f.baseLanes:c);else
return a=null!==f?f.baseLanes|
c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a},ni(b,a),null;else
null!==f?(d=f.baseLanes|c,b.memoizedState=null):d=c,ni(b,d);fi(a,b,e,c);return
b.child}
function oi(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|
=128}function li(a,b,c,d,e){var f=Ff(c)?
Df:M.current;f=Ef(b,f);tg(b,e);c=Ch(a,b,c,d,f,e);if(null!==a&&!ug)return
b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|
=1;fi(a,b,c,e);return b.child}
function pi(a,b,c,d,e){if(Ff(c)){var f=!0;Jf(b)}else f=!
1;tg(b,e);if(null===b.stateNode)null!
==a&&(a.alternate=null,b.alternate=null,b.flags|=2),Mg(b,c,d),Og(b,c,d,e),d=!0;else
if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var
k=g.context,l=c.contextType;"object"===typeof l&&null!==l?l=vg(l):(l=Ff(c)?
Df:M.current,l=Ef(b,l));var n=c.getDerivedStateFromProps,A="function"===typeof
n||"function"===typeof g.getSnapshotBeforeUpdate;A||"function"!==typeof
g.UNSAFE_componentWillReceiveProps&&
"function"!==typeof g.componentWillReceiveProps||(h!==d||k!==l)&&Ng(b,g,d,l);wg=!
1;var p=b.memoizedState;g.state=p;Cg(b,d,g,e);k=b.memoizedState;h!==d||p!==k||
N.current||wg?("function"===typeof n&&(Gg(b,c,n,d),k=b.memoizedState),(h=wg||
Lg(b,c,h,d,p,k,l))?(A||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!
==typeof g.componentWillMount||("function"===typeof
g.componentWillMount&&g.componentWillMount(),"function"===typeof
g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===
typeof g.componentDidMount&&(b.flags|=4)):("function"===typeof
g.componentDidMount&&(b.flags|
=4),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):
("function"===typeof g.componentDidMount&&(b.flags|=4),d=!
1)}else{g=b.stateNode;yg(a,b);h=b.memoizedProps;l=b.type===b.elementType?
h:lg(b.type,h);g.props=l;A=b.pendingProps;p=g.context;k=c.contextType;"object"===ty
peof k&&null!==k?k=vg(k):(k=Ff(c)?Df:M.current,k=Ef(b,k));var
C=c.getDerivedStateFromProps;(n="function"===typeof C||
"function"===typeof g.getSnapshotBeforeUpdate)||"function"!==typeof
g.UNSAFE_componentWillReceiveProps&&"function"!==typeof
g.componentWillReceiveProps||(h!==A||p!==k)&&Ng(b,g,d,k);wg=!
1;p=b.memoizedState;g.state=p;Cg(b,d,g,e);var x=b.memoizedState;h!==A||p!==x||
N.current||wg?("function"===typeof C&&(Gg(b,c,C,d),x=b.memoizedState),(l=wg||
Lg(b,c,l,d,p,x,k))?(n||"function"!==typeof
g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||
("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,
x,k),"function"===typeof
g.UNSAFE_componentWillUpdate&&g.UNSAFE_componentWillUpdate(d,x,k)),"function"===typ
eof g.componentDidUpdate&&(b.flags|=4),"function"===typeof
g.getSnapshotBeforeUpdate&&(b.flags|=256)):("function"!==typeof
g.componentDidUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|
=4),"function"!==typeof g.getSnapshotBeforeUpdate||
h===a.memoizedProps&&p===a.memoizedState||(b.flags|
=256),b.memoizedProps=d,b.memoizedState=x),g.props=d,g.state=x,g.context=k,d=l):
("function"!==typeof g.componentDidUpdate||
h===a.memoizedProps&&p===a.memoizedState||(b.flags|=4),"function"!==typeof
g.getSnapshotBeforeUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|
=256),d=!1)}return qi(a,b,c,d,f,e)}
function qi(a,b,c,d,e,f){oi(a,b);var g=0!==(b.flags&64);if(!d&&!g)return
e&&Kf(b,c,!1),hi(a,b,f);d=b.stateNode;ei.current=b;var h=g&&"function"!==typeof
c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?
(b.child=Yg(b,a.child,null,f),b.child=Yg(b,null,h,f)):fi(a,b,h,f);b.memoizedState=d
.state;e&&Kf(b,c,!0);return b.child}function ri(a){var
b=a.stateNode;b.pendingContext?Hf(a,b.pendingContext,b.pendingContext!
==b.context):b.context&&Hf(a,b.context,!1);eh(a,b.containerInfo)}
var si={dehydrated:null,retryLane:0};
function ti(a,b,c){var d=b.pendingProps,e=P.current,f=!1,g;(g=0!==(b.flags&64))||
(g=null!==a&&null===a.memoizedState?!1:0!==(e&2));g?(f=!0,b.flags&=-65):null!
==a&&null===a.memoizedState||void 0===d.fallback||!
0===d.unstable_avoidThisFallback||(e|=1);I(P,e&1);if(null===a){void 0!
==d.fallback&&ph(b);a=d.children;e=d.fallback;if(f)return
a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},b.memoizedState=si,a;if("number"=
==typeof d.unstable_expectedLoadTime)return
a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},
b.memoizedState=si,b.lanes=33554432,a;c=vi({mode:"visible",children:a},b.mode,c,nul
l);c.return=b;return b.child=c}if(null!==a.memoizedState){if(f)return
d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState
=null===e?{baseLanes:c}:{baseLanes:e.baseLanes|
c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoi
zedState=null;return c}if(f)return
d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState
=null===e?{baseLanes:c}:
{baseLanes:e.baseLanes|
c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoi
zedState=null;return c}function ui(a,b,c,d){var
e=a.mode,f=a.child;b={mode:"hidden",children:b};0===(e&2)&&null!==f?
(f.childLanes=0,f.pendingProps=b):f=vi(b,e,0,null);c=Xg(c,e,d,null);f.return=a;c.re
turn=a;f.sibling=c;a.child=f;return c}
function xi(a,b,c,d){var e=a.child;a=e.sibling;c=Tg(e,
{mode:"visible",children:c});0===(b.mode&2)&&(c.lanes=d);c.return=b;c.sibling=null;
null!==a&&(a.nextEffect=null,a.flags=8,b.firstEffect=b.lastEffect=a);return
b.child=c}
function wi(a,b,c,d,e){var f=b.mode,g=a.child;a=g.sibling;var
h={mode:"hidden",children:c};0===(f&2)&&b.child!==g?
(c=b.child,c.childLanes=0,c.pendingProps=h,g=c.lastEffect,null!==g?
(b.firstEffect=c.firstEffect,b.lastEffect=g,g.nextEffect=null):b.firstEffect=b.last
Effect=null):c=Tg(g,h);null!==a?d=Tg(a,d):(d=Xg(d,f,e,null),d.flags|
=2);d.return=b;c.return=b;c.sibling=d;b.child=c;return d}function yi(a,b){a.lanes|
=b;var c=a.alternate;null!==c&&(c.lanes|=b);sg(a.return,b)}
function zi(a,b,c,d,e,f){var g=a.memoizedState;null===g?
a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,ta
ilMode:e,lastEffect:f}:
(g.isBackwards=b,g.rendering=null,g.renderingStartTime=0,g.last=d,g.tail=c,g.tailMo
de=e,g.lastEffect=f)}
function Ai(a,b,c){var
d=b.pendingProps,e=d.revealOrder,f=d.tail;fi(a,b,d.children,c);d=P.current;if(0!
==(d&2))d=d&1|2,b.flags|=64;else{if(null!==a&&0!
==(a.flags&64))a:for(a=b.child;null!==a;){if(13===a.tag)null!
==a.memoizedState&&yi(a,c);else if(19===a.tag)yi(a,c);else if(null!==a.child)
{a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;)
{if(null===a.return||a.return===b)break
a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}I(P,d);if(0===(b.mode&2))b.
memoizedState=
null;else switch(e){case "forwards":c=b.child;for(e=null;null!
==c;)a=c.alternate,null!==a&&null===ih(a)&&(e=c),c=c.sibling;c=e;null===c?
(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);zi(b,!
1,e,c,f,b.lastEffect);break;case
"backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!
==a&&null===ih(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}zi(b,!
0,c,null,f,b.lastEffect);break;case "together":zi(b,!1,null,null,void
0,b.lastEffect);break;default:b.memoizedState=null}return b.child}
function hi(a,b,c){null!==a&&(b.dependencies=a.dependencies);Dg|=b.lanes;if(0!
==(c&b.childLanes)){if(null!==a&&b.child!==a.child)throw Error(y(153));if(null!
==b.child){a=b.child;c=Tg(a,a.pendingProps);b.child=c;for(c.return=b;null!
==a.sibling;)a=a.sibling,c=c.sibling=Tg(a,a.pendingProps),c.return=b;c.sibling=null
}return b.child}return null}var Bi,Ci,Di,Ei;
Bi=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||
6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child)
{c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;)
{if(null===c.return||
c.return===b)return;c=c.return}c.sibling.return=c.return;c=c.sibling}};Ci=function(
){};
Di=function(a,b,c,d){var e=a.memoizedProps;if(e!==d)
{a=b.stateNode;dh(ah.current);var f=null;switch(c){case
"input":e=Ya(a,e);d=Ya(a,d);f=[];break;case
"option":e=eb(a,e);d=eb(a,d);f=[];break;case "select":e=m({},e,{value:void
0});d=m({},d,{value:void 0});f=[];break;case
"textarea":e=gb(a,e);d=gb(a,d);f=[];break;default:"function"!==typeof
e.onClick&&"function"===typeof d.onClick&&(a.onclick=jf)}vb(c,d);var g;c=null;for(l
in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if("style"===
l){var h=e[l];for(g in h)h.hasOwnProperty(g)&&(c||
(c={}),c[g]="")}else"dangerouslySetInnerHTML"!==l&&"children"!
==l&&"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!
==l&&"autoFocus"!==l&&(ca.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l
in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||
null!=h))if("style"===l)if(h){for(g in h)!h.hasOwnProperty(g)||
k&&k.hasOwnProperty(g)||(c||(c={}),c[g]="");for(g in k)k.hasOwnProperty(g)&&h[g]!
==k[g]&&(c||
(c={}),c[g]=k[g])}else c||(f||
(f=[]),f.push(l,c)),c=k;else"dangerouslySetInnerHTML"===l?(k=k?k.__html:void 0,h=h?
h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):"children"===l?"string"!
==typeof k&&"number"!==typeof k||(f=f||
[]).push(l,""+k):"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!
==l&&(ca.hasOwnProperty(l)?(null!=k&&"onScroll"===l&&G("scroll",a),f||h===k||
(f=[])):"object"===typeof k&&null!==k&&k.$$typeof===Ga?k.toString():(f=f||
[]).push(l,k))}c&&(f=f||[]).push("style",
c);var l=f;if(b.updateQueue=l)b.flags|=4}};Ei=function(a,b,c,d){c!==d&&(b.flags|
=4)};function Fi(a,b){if(!lh)switch(a.tailMode){case "hidden":b=a.tail;for(var
c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?
a.tail=null:c.sibling=null;break;case "collapsed":c=a.tail;for(var d=null;null!
==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?
a.tail=null:a.tail.sibling=null:d.sibling=null}}
function Gi(a,b,c){var d=b.pendingProps;switch(b.tag){case 2:case 16:case 15:case
0:case 11:case 7:case 8:case 12:case 9:case 14:return null;case 1:return
Ff(b.type)&&Gf(),null;case
3:fh();H(N);H(M);uh();d=b.stateNode;d.pendingContext&&(d.context=d.pendingContext,d
.pendingContext=null);if(null===a||null===a.child)rh(b)?b.flags|=4:d.hydrate||
(b.flags|=256);Ci(b);return null;case 5:hh(b);var
e=dh(ch.current);c=b.type;if(null!==a&&null!=b.stateNode)Di(a,b,c,d,e),a.ref!
==b.ref&&(b.flags|=128);else{if(!d){if(null===
b.stateNode)throw Error(y(166));return null}a=dh(ah.current);if(rh(b))
{d=b.stateNode;c=b.type;var f=b.memoizedProps;d[wf]=b;d[xf]=f;switch(c){case
"dialog":G("cancel",d);G("close",d);break;case "iframe":case "object":case
"embed":G("load",d);break;case "video":case "audio":for(a=0;a<Xe.length;a+
+)G(Xe[a],d);break;case "source":G("error",d);break;case "img":case "image":case
"link":G("error",d);G("load",d);break;case "details":G("toggle",d);break;case
"input":Za(d,f);G("invalid",d);break;case "select":d._wrapperState=
{wasMultiple:!!f.multiple};G("invalid",d);break;case
"textarea":hb(d,f),G("invalid",d)}vb(c,f);a=null;for(var g in
f)f.hasOwnProperty(g)&&(e=f[g],"children"===g?"string"===typeof e?d.textContent!
==e&&(a=["children",e]):"number"===typeof e&&d.textContent!
==""+e&&(a=["children",""+e]):ca.hasOwnProperty(g)&&null!
=e&&"onScroll"===g&&G("scroll",d));switch(c){case "input":Va(d);cb(d,f,!
0);break;case "textarea":Va(d);jb(d);break;case "select":case
"option":break;default:"function"===typeof f.onClick&&(d.onclick=
jf)}d=a;b.updateQueue=d;null!==d&&(b.flags|=4)}else{g=9===e.nodeType?
e:e.ownerDocument;a===kb.html&&(a=lb(c));a===kb.html?"script"===c?
(a=g.createElement("div"),a.innerHTML="<script>\x3c/
script>",a=a.removeChild(a.firstChild)):"string"===typeof d.is?a=g.createElement(c,
{is:d.is}):(a=g.createElement(c),"select"===c&&(g=a,d.multiple?g.multiple=!
0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[wf]=b;a[xf]=d;Bi(a,b,!1,!
1);b.stateNode=a;g=wb(c,d);switch(c){case "dialog":G("cancel",a);G("close",a);
e=d;break;case "iframe":case "object":case "embed":G("load",a);e=d;break;case
"video":case "audio":for(e=0;e<Xe.length;e++)G(Xe[e],a);e=d;break;case
"source":G("error",a);e=d;break;case "img":case "image":case
"link":G("error",a);G("load",a);e=d;break;case
"details":G("toggle",a);e=d;break;case
"input":Za(a,d);e=Ya(a,d);G("invalid",a);break;case "option":e=eb(a,d);break;case
"select":a._wrapperState={wasMultiple:!!d.multiple};e=m({},d,{value:void
0});G("invalid",a);break;case "textarea":hb(a,d);e=
gb(a,d);G("invalid",a);break;default:e=d}vb(c,e);var h=e;for(f in
h)if(h.hasOwnProperty(f)){var k=h[f];"style"===f?
tb(a,k):"dangerouslySetInnerHTML"===f?(k=k?k.__html:void 0,null!
=k&&ob(a,k)):"children"===f?"string"===typeof k?("textarea"!==c||""!
==k)&&pb(a,k):"number"===typeof k&&pb(a,""+k):"suppressContentEditableWarning"!
==f&&"suppressHydrationWarning"!==f&&"autoFocus"!==f&&(ca.hasOwnProperty(f)?null!
=k&&"onScroll"===f&&G("scroll",a):null!=k&&qa(a,f,k,g))}switch(c){case
"input":Va(a);cb(a,d,!1);
break;case "textarea":Va(a);jb(a);break;case "option":null!
=d.value&&a.setAttribute("value",""+Sa(d.value));break;case "select":a.multiple=!!
d.multiple;f=d.value;null!=f?fb(a,!!d.multiple,f,!1):null!=d.defaultValue&&fb(a,!!
d.multiple,d.defaultValue,!0);break;default:"function"===typeof
e.onClick&&(a.onclick=jf)}mf(c,d)&&(b.flags|=4)}null!==b.ref&&(b.flags|=128)}return
null;case 6:if(a&&null!=b.stateNode)Ei(a,b,a.memoizedProps,d);else{if("string"!
==typeof d&&null===b.stateNode)throw Error(y(166));
c=dh(ch.current);dh(ah.current);rh(b)?
(d=b.stateNode,c=b.memoizedProps,d[wf]=b,d.nodeValue!==c&&(b.flags|=4)):
(d=(9===c.nodeType?
c:c.ownerDocument).createTextNode(d),d[wf]=b,b.stateNode=d)}return null;case
13:H(P);d=b.memoizedState;if(0!==(b.flags&64))return b.lanes=c,b;d=null!==d;c=!
1;null===a?void 0!==b.memoizedProps.fallback&&rh(b):c=null!
==a.memoizedState;if(d&&!c&&0!==(b.mode&2))if(null===a&&!0!
==b.memoizedProps.unstable_avoidThisFallback||0!
==(P.current&1))0===V&&(V=3);else{if(0===V||3===V)V=
4;null===U||0===(Dg&134217727)&&0===(Hi&134217727)||Ii(U,W)}if(d||c)b.flags|
=4;return null;case 4:return
fh(),Ci(b),null===a&&cf(b.stateNode.containerInfo),null;case 10:return
rg(b),null;case 17:return Ff(b.type)&&Gf(),null;case
19:H(P);d=b.memoizedState;if(null===d)return null;f=0!
==(b.flags&64);g=d.rendering;if(null===g)if(f)Fi(d,!1);else{if(0!==V||null!==a&&0!
==(a.flags&64))for(a=b.child;null!==a;){g=ih(a);if(null!==g){b.flags|=64;Fi(d,!
1);f=g.updateQueue;null!==f&&(b.updateQueue=f,b.flags|=4);
null===d.lastEffect&&(b.firstEffect=null);b.lastEffect=d.lastEffect;d=c;for(c=b.chi
ld;null!
==c;)f=c,a=d,f.flags&=2,f.nextEffect=null,f.firstEffect=null,f.lastEffect=null,g=f.
alternate,null===g?
(f.childLanes=0,f.lanes=a,f.child=null,f.memoizedProps=null,f.memoizedState=null,f.
updateQueue=null,f.dependencies=null,f.stateNode=null):
(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.memoizedProps=g.memoiz
edProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a
=g.dependencies,
f.dependencies=null===a?null:
{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;I(P,P.current&1|2);return
b.child}a=a.sibling}null!==d.tail&&O()>Ji&&(b.flags|=64,f=!0,Fi(d,!
1),b.lanes=33554432)}else{if(!f)if(a=ih(g),null!==a){if(b.flags|=64,f=!
0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Fi(d,!
0),null===d.tail&&"hidden"===d.tailMode&&!g.alternate&&!lh)return
b=b.lastEffect=d.lastEffect,null!==b&&(b.nextEffect=null),null}else 2*O()-
d.renderingStartTime>Ji&&1073741824!==c&&(b.flags|=
64,f=!0,Fi(d,!1),b.lanes=33554432);d.isBackwards?(g.sibling=b.child,b.child=g):
(c=d.last,null!==c?c.sibling=g:b.child=g,d.last=g)}return null!==d.tail?
(c=d.tail,d.rendering=c,d.tail=c.sibling,d.lastEffect=b.lastEffect,d.renderingStart
Time=O(),c.sibling=null,b=P.current,I(P,f?b&1|2:b&1),c):null;case 23:case 24:return
Ki(),null!==a&&null!==a.memoizedState!==(null!==b.memoizedState)&&"unstable-defer-
without-hiding"!==d.mode&&(b.flags|=4),null}throw Error(y(156,b.tag));}
function Li(a){switch(a.tag){case 1:Ff(a.type)&&Gf();var b=a.flags;return b&4096?
(a.flags=b&-4097|64,a):null;case 3:fh();H(N);H(M);uh();b=a.flags;if(0!
==(b&64))throw Error(y(285));a.flags=b&-4097|64;return a;case 5:return
hh(a),null;case 13:return H(P),b=a.flags,b&4096?(a.flags=b&-4097|64,a):null;case
19:return H(P),null;case 4:return fh(),null;case 10:return rg(a),null;case 23:case
24:return Ki(),null;default:return null}}
function Mi(a,b){try{var c="",d=b;do c+=Qa(d),d=d.return;while(d);var e=c}catch(f)
{e="\nError generating stack: "+f.message+"\
n"+f.stack}return{value:a,source:b,stack:e}}function Ni(a,b)
{try{console.error(b.value)}catch(c){setTimeout(function(){throw c;})}}var
Oi="function"===typeof WeakMap?WeakMap:Map;function Pi(a,b,c){c=zg(-
1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Qi||(Qi=!
0,Ri=d);Ni(a,b)};return c}
function Si(a,b,c){c=zg(-1,c);c.tag=3;var
d=a.type.getDerivedStateFromError;if("function"===typeof d){var
e=b.value;c.payload=function(){Ni(a,b);return d(e)}}var f=a.stateNode;null!
==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){"function"!
==typeof d&&(null===Ti?Ti=new Set([this]):Ti.add(this),Ni(a,b));var
c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:""})});return
c}var Ui="function"===typeof WeakSet?WeakSet:Set;
function Vi(a){var b=a.ref;if(null!==b)if("function"===typeof
b)try{b(null)}catch(c){Wi(a,c)}else b.current=null}function Xi(a,b){switch(b.tag)
{case 0:case 11:case 15:case 22:return;case 1:if(b.flags&256&&null!==a){var
c=a.memoizedProps,d=a.memoizedState;a=b.stateNode;b=a.getSnapshotBeforeUpdate(b.ele
mentType===b.type?
c:lg(b.type,c),d);a.__reactInternalSnapshotBeforeUpdate=b}return;case
3:b.flags&256&&qf(b.stateNode.containerInfo);return;case 5:case 6:case 4:case
17:return}throw Error(y(163));}
function Yi(a,b,c){switch(c.tag){case 0:case 11:case 15:case
22:b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b)
{a=b=b.next;do{if(3===(a.tag&3)){var d=a.create;a.destroy=d()}a=a.next}while(a!
==b)}b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){a=b=b.next;do{var
e=a;d=e.next;e=e.tag;0!==(e&4)&&0!==(e&1)&&(Zi(c,a),$i(c,a));a=d}while(a!
==b)}return;case 1:a=c.stateNode;c.flags&4&&(null===b?a.componentDidMount():
(d=c.elementType===c.type?
b.memoizedProps:lg(c.type,b.memoizedProps),a.componentDidUpdate(d,
b.memoizedState,a.__reactInternalSnapshotBeforeUpdate)));b=c.updateQueue;null!
==b&&Eg(c,b,a);return;case 3:b=c.updateQueue;if(null!==b){a=null;if(null!
==c.child)switch(c.child.tag){case 5:a=c.child.stateNode;break;case
1:a=c.child.stateNode}Eg(c,b,a)}return;case
5:a=c.stateNode;null===b&&c.flags&4&&mf(c.type,c.memoizedProps)&&a.focus();return;c
ase 6:return;case 4:return;case 12:return;case
13:null===c.memoizedState&&(c=c.alternate,null!==c&&(c=c.memoizedState,null!
==c&&(c=c.dehydrated,null!==c&&Cc(c))));
return;case 19:case 17:case 20:case 21:case 23:case 24:return}throw Error(y(163));}
function aj(a,b){for(var c=a;;){if(5===c.tag){var
d=c.stateNode;if(b)d=d.style,"function"===typeof d.setProperty?
d.setProperty("display","none","important"):d.display="none";else{d=c.stateNode;var
e=c.memoizedProps.style;e=void 0!==e&&null!==e&&e.hasOwnProperty("display")?
e.display:null;d.style.display=sb("display",e)}}else
if(6===c.tag)c.stateNode.nodeValue=b?"":c.memoizedProps;else if((23!==c.tag&&24!
==c.tag||null===c.memoizedState||c===a)&&null!==c.child)
{c.child.return=c;c=c.child;continue}if(c===
a)break;for(;null===c.sibling;){if(null===c.return||
c.return===a)return;c=c.return}c.sibling.return=c.return;c=c.sibling}}
function bj(a,b){if(Mf&&"function"===typeof
Mf.onCommitFiberUnmount)try{Mf.onCommitFiberUnmount(Lf,b)}catch(f){}switch(b.tag)
{case 0:case 11:case 14:case 15:case 22:a=b.updateQueue;if(null!
==a&&(a=a.lastEffect,null!==a)){var c=a=a.next;do{var
d=c,e=d.destroy;d=d.tag;if(void 0!==e)if(0!
==(d&4))Zi(b,c);else{d=b;try{e()}catch(f){Wi(d,f)}}c=c.next}while(c!==a)}break;case
1:Vi(b);a=b.stateNode;if("function"===typeof
a.componentWillUnmount)try{a.props=b.memoizedProps,a.state=b.memoizedState,a.compon
entWillUnmount()}catch(f){Wi(b,
f)}break;case 5:Vi(b);break;case 4:cj(a,b)}}function dj(a)
{a.alternate=null;a.child=null;a.dependencies=null;a.firstEffect=null;a.lastEffect=
null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.return=null;a.
updateQueue=null}function ej(a){return 5===a.tag||3===a.tag||4===a.tag}
function fj(a){a:{for(var b=a.return;null!==b;){if(ej(b))break a;b=b.return}throw
Error(y(160));}var c=b;b=c.stateNode;switch(c.tag){case 5:var d=!1;break;case
3:b=b.containerInfo;d=!0;break;case 4:b=b.containerInfo;d=!0;break;default:throw
Error(y(161));}c.flags&16&&(pb(b,""),c.flags&=-17);a:b:for(c=a;;)
{for(;null===c.sibling;){if(null===c.return||ej(c.return)){c=null;break
a}c=c.return}c.sibling.return=c.return;for(c=c.sibling;5!==c.tag&&6!==c.tag&&18!
==c.tag;){if(c.flags&2)continue b;if(null===
c.child||4===c.tag)continue b;else c.child.return=c,c=c.child}if(!(c.flags&2))
{c=c.stateNode;break a}}d?gj(a,c,b):hj(a,c,b)}
function gj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?
a.stateNode:a.stateNode.instance,b?8===c.nodeType?
c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?
(b=c.parentNode,b.insertBefore(a,c)):
(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!
==b.onclick||(b.onclick=jf));else if(4!==d&&(a=a.child,null!
==a))for(gj(a,b,c),a=a.sibling;null!==a;)gj(a,b,c),a=a.sibling}
function hj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?
a.stateNode:a.stateNode.instance,b?c.insertBefore(a,b):c.appendChild(a);else if(4!
==d&&(a=a.child,null!==a))for(hj(a,b,c),a=a.sibling;null!
==a;)hj(a,b,c),a=a.sibling}
function cj(a,b){for(var c=b,d=!1,e,f;;){if(!d){d=c.return;a:for(;;)
{if(null===d)throw Error(y(160));e=d.stateNode;switch(d.tag){case 5:f=!1;break
a;case 3:e=e.containerInfo;f=!0;break a;case 4:e=e.containerInfo;f=!0;break
a}d=d.return}d=!0}if(5===c.tag||6===c.tag){a:for(var g=a,h=c,k=h;;)if(bj(g,k),null!
==k.child&&4!==k.tag)k.child.return=k,k=k.child;else{if(k===h)break
a;for(;null===k.sibling;){if(null===k.return||k.return===h)break
a;k=k.return}k.sibling.return=k.return;k=k.sibling}f?(g=e,h=c.stateNode,
8===g.nodeType?
g.parentNode.removeChild(h):g.removeChild(h)):e.removeChild(c.stateNode)}else
if(4===c.tag){if(null!==c.child){e=c.stateNode.containerInfo;f=!
0;c.child.return=c;c=c.child;continue}}else if(bj(a,c),null!==c.child)
{c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;)
{if(null===c.return||c.return===b)return;c=c.return;4===c.tag&&(d=!
1)}c.sibling.return=c.return;c=c.sibling}}
function ij(a,b){switch(b.tag){case 0:case 11:case 14:case 15:case 22:var
c=b.updateQueue;c=null!==c?c.lastEffect:null;if(null!==c){var d=c=c.next;do
3===(d.tag&3)&&(a=d.destroy,d.destroy=void 0,void 0!==a&&a()),d=d.next;while(d!
==c)}return;case 1:return;case 5:c=b.stateNode;if(null!=c){d=b.memoizedProps;var
e=null!==a?a.memoizedProps:d;a=b.type;var
f=b.updateQueue;b.updateQueue=null;if(null!==f)
{c[xf]=d;"input"===a&&"radio"===d.type&&null!
=d.name&&$a(c,d);wb(a,e);b=wb(a,d);for(e=0;e<f.length;e+=
2){var g=f[e],h=f[e+1];"style"===g?tb(c,h):"dangerouslySetInnerHTML"===g?
ob(c,h):"children"===g?pb(c,h):qa(c,g,h,b)}switch(a){case
"input":ab(c,d);break;case "textarea":ib(c,d);break;case
"select":a=c._wrapperState.wasMultiple,c._wrapperState.wasMultiple=!!
d.multiple,f=d.value,null!=f?fb(c,!!d.multiple,f,!1):a!==!!d.multiple&&(null!
=d.defaultValue?fb(c,!!d.multiple,d.defaultValue,!0):fb(c,!!d.multiple,d.multiple?
[]:"",!1))}}}return;case 6:if(null===b.stateNode)throw
Error(y(162));b.stateNode.nodeValue=
b.memoizedProps;return;case 3:c=b.stateNode;c.hydrate&&(c.hydrate=!
1,Cc(c.containerInfo));return;case 12:return;case 13:null!
==b.memoizedState&&(jj=O(),aj(b.child,!0));kj(b);return;case 19:kj(b);return;case
17:return;case 23:case 24:aj(b,null!==b.memoizedState);return}throw
Error(y(163));}function kj(a){var b=a.updateQueue;if(null!==b)
{a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new
Ui);b.forEach(function(b){var d=lj.bind(null,a,b);c.has(b)||
(c.add(b),b.then(d,d))})}}
function mj(a,b){return null!==a&&(a=a.memoizedState,null===a||null!
==a.dehydrated)?(b=b.memoizedState,null!==b&&null===b.dehydrated):!1}var
nj=Math.ceil,oj=ra.ReactCurrentDispatcher,pj=ra.ReactCurrentOwner,X=0,U=null,Y=null
,W=0,qj=0,rj=Bf(0),V=0,sj=null,tj=0,Dg=0,Hi=0,uj=0,vj=null,jj=0,Ji=Infinity;functio
n wj(){Ji=O()+500}var Z=null,Qi=!1,Ri=null,Ti=null,xj=!
1,yj=null,zj=90,Aj=[],Bj=[],Cj=null,Dj=0,Ej=null,Fj=-1,Gj=0,Hj=0,Ij=null,Jj=!
1;function Hg(){return 0!==(X&48)?O():-1!==Fj?Fj:Fj=O()}
function Ig(a){a=a.mode;if(0===(a&2))return 1;if(0===(a&4))return 99===eg()?
1:2;0===Gj&&(Gj=tj);if(0!==kg.transition){0!==Hj&&(Hj=null!==vj?
vj.pendingLanes:0);a=Gj;var b=4186112&~Hj;b&=-b;0===b&&(a=4186112&~a,b=a&-
a,0===b&&(b=8192));return b}a=eg();0!==(X&4)&&98===a?a=Xc(12,Gj):
(a=Sc(a),a=Xc(a,Gj));return a}
function Jg(a,b,c){if(50<Dj)throw
Dj=0,Ej=null,Error(y(185));a=Kj(a,b);if(null===a)return null;$c(a,b,c);a===U&&(Hi|
=b,4===V&&Ii(a,W));var d=eg();1===b?0!==(X&8)&&0===(X&48)?Lj(a):
(Mj(a,c),0===X&&(wj(),ig())):(0===(X&4)||98!==d&&99!==d||(null===Cj?Cj=new
Set([a]):Cj.add(a)),Mj(a,c));vj=a}function Kj(a,b){a.lanes|=b;var
c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|
=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?
c.stateNode:null}
function Mj(a,b){for(var
c=a.callbackNode,d=a.suspendedLanes,e=a.pingedLanes,f=a.expirationTimes,g=a.pending
Lanes;0<g;){var h=31-Vc(g),k=1<<h,l=f[h];if(-1===l){if(0===(k&d)||0!==(k&e))
{l=b;Rc(k);var n=F;f[h]=10<=n?l+250:6<=n?l+5E3:-1}}else l<=b&&(a.expiredLanes|
=k);g&=~k}d=Uc(a,a===U?W:0);b=F;if(0===d)null!==c&&(c!
==Zf&&Pf(c),a.callbackNode=null,a.callbackPriority=0);else{if(null!==c)
{if(a.callbackPriority===b)return;c!==Zf&&Pf(c)}15===b?
(c=Lj.bind(null,a),null===ag?(ag=[c],bg=Of(Uf,jg)):ag.push(c),
c=Zf):14===b?c=hg(99,Lj.bind(null,a)):
(c=Tc(b),c=hg(c,Nj.bind(null,a)));a.callbackPriority=b;a.callbackNode=c}}
function Nj(a){Fj=-1;Hj=Gj=0;if(0!==(X&48))throw Error(y(327));var
b=a.callbackNode;if(Oj()&&a.callbackNode!==b)return null;var c=Uc(a,a===U?
W:0);if(0===c)return null;var d=c;var e=X;X|=16;var f=Pj();if(U!==a||W!
==d)wj(),Qj(a,d);do try{Rj();break}catch(h)
{Sj(a,h)}while(1);qg();oj.current=f;X=e;null!==Y?d=0:(U=null,W=0,d=V);if(0!
==(tj&Hi))Qj(a,0);else if(0!==d){2===d&&(X|=64,a.hydrate&&(a.hydrate=!
1,qf(a.containerInfo)),c=Wc(a),0!==c&&(d=Tj(a,c)));if(1===d)throw
b=sj,Qj(a,0),Ii(a,c),Mj(a,O()),b;a.finishedWork=
a.current.alternate;a.finishedLanes=c;switch(d){case 0:case 1:throw
Error(y(345));case 2:Uj(a);break;case 3:Ii(a,c);if((c&62914560)===c&&(d=jj+500-
O(),10<d)){if(0!==Uc(a,0))break;e=a.suspendedLanes;if((e&c)!==c)
{Hg();a.pingedLanes|
=a.suspendedLanes&e;break}a.timeoutHandle=of(Uj.bind(null,a),d);break}Uj(a);break;c
ase 4:Ii(a,c);if((c&4186112)===c)break;d=a.eventTimes;for(e=-1;0<c;){var g=31-
Vc(c);f=1<<g;g=d[g];g>e&&(e=g);c&=~f}c=e;c=O()-c;c=(120>c?120:480>c?480:1080>c?
1080:1920>c?1920:3E3>c?3E3:4320>
c?4320:1960*nj(c/1960))-c;if(10<c)
{a.timeoutHandle=of(Uj.bind(null,a),c);break}Uj(a);break;case
5:Uj(a);break;default:throw Error(y(329));}}Mj(a,O());return a.callbackNode===b?
Nj.bind(null,a):null}function Ii(a,b){b&=~uj;b&=~Hi;a.suspendedLanes|
=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-Vc(b),d=1<<c;a[c]=-
1;b&=~d}}
function Lj(a){if(0!==(X&48))throw Error(y(327));Oj();if(a===U&&0!
==(a.expiredLanes&W)){var b=W;var c=Tj(a,b);0!==(tj&Hi)&&(b=Uc(a,b),c=Tj(a,b))}else
b=Uc(a,0),c=Tj(a,b);0!==a.tag&&2===c&&(X|=64,a.hydrate&&(a.hydrate=!
1,qf(a.containerInfo)),b=Wc(a),0!==b&&(c=Tj(a,b)));if(1===c)throw
c=sj,Qj(a,0),Ii(a,b),Mj(a,O()),c;a.finishedWork=a.current.alternate;a.finishedLanes
=b;Uj(a);Mj(a,O());return null}
function Vj(){if(null!==Cj){var a=Cj;Cj=null;a.forEach(function(a){a.expiredLanes|
=24&a.pendingLanes;Mj(a,O())})}ig()}function Wj(a,b){var c=X;X|=1;try{return
a(b)}finally{X=c,0===X&&(wj(),ig())}}function Xj(a,b){var c=X;X&=-2;X|=8;try{return
a(b)}finally{X=c,0===X&&(wj(),ig())}}function ni(a,b){I(rj,qj);qj|=b;tj|=b}function
Ki(){qj=rj.current;H(rj)}
function Qj(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!
==c&&(a.timeoutHandle=-1,pf(c));if(null!==Y)for(c=Y.return;null!==c;){var
d=c;switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!
==d&&Gf();break;case 3:fh();H(N);H(M);uh();break;case 5:hh(d);break;case
4:fh();break;case 13:H(P);break;case 19:H(P);break;case 10:rg(d);break;case 23:case
24:Ki()}c=c.return}U=a;Y=Tg(a.current,null);W=qj=tj=b;V=0;sj=null;uj=Hi=Dg=0}
function Sj(a,b){do{var c=Y;try{qg();vh.current=Gh;if(yh){for(var
d=R.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next}yh=!
1}xh=0;T=S=R=null;zh=!1;pj.current=null;if(null===c||null===c.return)
{V=1;sj=b;Y=null;break}a:{var f=a,g=c.return,h=c,k=b;b=W;h.flags|
=2048;h.firstEffect=h.lastEffect=null;if(null!==k&&"object"===typeof
k&&"function"===typeof k.then){var l=k;if(0===(h.mode&2)){var n=h.alternate;n?
(h.updateQueue=n.updateQueue,h.memoizedState=n.memoizedState,h.lanes=n.lanes):
(h.updateQueue=null,h.memoizedState=null)}var A=0!==(P.current&1),p=g;do{var
C;if(C=13===p.tag){var x=p.memoizedState;if(null!==x)C=null!==x.dehydrated?!0:!
1;else{var w=p.memoizedProps;C=void 0===w.fallback?!1:!0!
==w.unstable_avoidThisFallback?!0:A?!1:!0}}if(C){var z=p.updateQueue;if(null===z)
{var u=new Set;u.add(l);p.updateQueue=u}else z.add(l);if(0===(p.mode&2)){p.flags|
=64;h.flags|=16384;h.flags&=-
2981;if(1===h.tag)if(null===h.alternate)h.tag=17;else{var t=zg(-
1,1);t.tag=2;Ag(h,t)}h.lanes|=1;break a}k=
void 0;h=b;var q=f.pingCache;null===q?(q=f.pingCache=new Oi,k=new Set,q.set(l,k)):
(k=q.get(l),void 0===k&&(k=new Set,q.set(l,k)));if(!k.has(h)){k.add(h);var
v=Yj.bind(null,f,l,h);l.then(v,v)}p.flags|=4096;p.lanes=b;break
a}p=p.return}while(null!==p);k=Error((Ra(h.type)||"A React component")+" suspended
while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...>
component higher in the tree to provide a loading indicator or placeholder to
display.")}5!==V&&(V=2);k=Mi(k,h);p=
g;do{switch(p.tag){case 3:f=k;p.flags|=4096;b&=-b;p.lanes|=b;var
J=Pi(p,f,b);Bg(p,J);break a;case 1:f=k;var
K=p.type,Q=p.stateNode;if(0===(p.flags&64)&&("function"===typeof
K.getDerivedStateFromError||null!==Q&&"function"===typeof
Q.componentDidCatch&&(null===Ti||!Ti.has(Q)))){p.flags|=4096;b&=-b;p.lanes|=b;var
L=Si(p,f,b);Bg(p,L);break a}}p=p.return}while(null!==p)}Zj(c)}catch(va)
{b=va;Y===c&&null!==c&&(Y=c=c.return);continue}break}while(1)}
function Pj(){var a=oj.current;oj.current=Gh;return null===a?Gh:a}function Tj(a,b)
{var c=X;X|=16;var d=Pj();U===a&&W===b||Qj(a,b);do try{ak();break}catch(e)
{Sj(a,e)}while(1);qg();X=c;oj.current=d;if(null!==Y)throw
Error(y(261));U=null;W=0;return V}function ak(){for(;null!==Y;)bk(Y)}function Rj()
{for(;null!==Y&&!Qf();)bk(Y)}function bk(a){var
b=ck(a.alternate,a,qj);a.memoizedProps=a.pendingProps;null===b?
Zj(a):Y=b;pj.current=null}
function Zj(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&2048))
{c=Gi(c,b,qj);if(null!==c){Y=c;return}c=b;if(24!==c.tag&&23!==c.tag||
null===c.memoizedState||0!==(qj&1073741824)||0===(c.mode&4)){for(var
d=0,e=c.child;null!==e;)d|=e.lanes|e.childLanes,e=e.sibling;c.childLanes=d}null!
==a&&0===(a.flags&2048)&&(null===a.firstEffect&&(a.firstEffect=b.firstEffect),null!
==b.lastEffect&&(null!
==a.lastEffect&&(a.lastEffect.nextEffect=b.firstEffect),a.lastEffect=b.lastEffect),
1<b.flags&&(null!==
a.lastEffect?
a.lastEffect.nextEffect=b:a.firstEffect=b,a.lastEffect=b))}else{c=Li(b);if(null!
==c){c.flags&=2047;Y=c;return}null!==a&&(a.firstEffect=a.lastEffect=null,a.flags|
=2048)}b=b.sibling;if(null!==b){Y=b;return}Y=b=a}while(null!
==b);0===V&&(V=5)}function Uj(a){var b=eg();gg(99,dk.bind(null,a,b));return null}
function dk(a,b){do Oj();while(null!==yj);if(0!==(X&48))throw Error(y(327));var
c=a.finishedWork;if(null===c)return
null;a.finishedWork=null;a.finishedLanes=0;if(c===a.current)throw
Error(y(177));a.callbackNode=null;var d=c.lanes|
c.childLanes,e=d,f=a.pendingLanes&~e;a.pendingLanes=e;a.suspendedLanes=0;a.pingedLa
nes=0;a.expiredLanes&=e;a.mutableReadLanes&=e;a.entangledLanes&=e;e=a.entanglements
;for(var g=a.eventTimes,h=a.expirationTimes;0<f;){var k=31-
Vc(f),l=1<<k;e[k]=0;g[k]=-1;h[k]=-1;f&=~l}null!==
Cj&&0===(d&24)&&Cj.has(a)&&Cj.delete(a);a===U&&(Y=U=null,W=0);1<c.flags?null!
==c.lastEffect?
(c.lastEffect.nextEffect=c,d=c.firstEffect):d=c:d=c.firstEffect;if(null!==d){e=X;X|
=32;pj.current=null;kf=fd;g=Ne();if(Oe(g)){if("selectionStart"in
g)h={start:g.selectionStart,end:g.selectionEnd};else
a:if(h=(h=g.ownerDocument)&&h.defaultView||window,
(l=h.getSelection&&h.getSelection())&&0!==l.rangeCount)
{h=l.anchorNode;f=l.anchorOffset;k=l.focusNode;l=l.focusOffset;try{h.nodeType,k.nod
eType}catch(va){h=null;
break a}var n=0,A=-1,p=-1,C=0,x=0,w=g,z=null;b:for(;;){for(var u;;){w!==h||0!
==f&&3!==w.nodeType||(A=n+f);w!==k||0!==l&&3!==w.nodeType||
(p=n+l);3===w.nodeType&&(n+=w.nodeValue.length);if(null===(u=w.firstChild))break;z=
w;w=u}for(;;){if(w===g)break b;z===h&&++C===f&&(A=n);z===k&&++x===l&&(p=n);if(null!
==(u=w.nextSibling))break;w=z;z=w.parentNode}w=u}h=-1===A||-1===p?null:
{start:A,end:p}}else h=null;h=h||{start:0,end:0}}else
h=null;lf={focusedElem:g,selectionRange:h};fd=!1;Ij=null;Jj=!1;Z=d;do
try{ek()}catch(va){if(null===
Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!==Z);Ij=null;Z=d;do
try{for(g=a;null!==Z;){var t=Z.flags;t&16&&pb(Z.stateNode,"");if(t&128){var
q=Z.alternate;if(null!==q){var v=q.ref;null!==v&&("function"===typeof v?
v(null):v.current=null)}}switch(t&1038){case 2:fj(Z);Z.flags&=-3;break;case
6:fj(Z);Z.flags&=-3;ij(Z.alternate,Z);break;case 1024:Z.flags&=-1025;break;case
1028:Z.flags&=-1025;ij(Z.alternate,Z);break;case 4:ij(Z.alternate,Z);break;case
8:h=Z;cj(g,h);var J=h.alternate;dj(h);null!==
J&&dj(J)}Z=Z.nextEffect}}catch(va){if(null===Z)throw
Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!
==Z);v=lf;q=Ne();t=v.focusedElem;g=v.selectionRange;if(q!
==t&&t&&t.ownerDocument&&Me(t.ownerDocument.documentElement,t)){null!
==g&&Oe(t)&&(q=g.start,v=g.end,void 0===v&&(v=q),"selectionStart"in t?
(t.selectionStart=q,t.selectionEnd=Math.min(v,t.value.length)):
(v=(q=t.ownerDocument||document)&&q.defaultView||
window,v.getSelection&&(v=v.getSelection(),h=t.textContent.length,J=Math.min(g.star
t,h),g=void 0===
g.end?J:Math.min(g.end,h),!
v.extend&&J>g&&(h=g,g=J,J=h),h=Le(t,J),f=Le(t,g),h&&f&&(1!==v.rangeCount||
v.anchorNode!==h.node||v.anchorOffset!==h.offset||v.focusNode!==f.node||
v.focusOffset!
==f.offset)&&(q=q.createRange(),q.setStart(h.node,h.offset),v.removeAllRanges(),J>g
?(v.addRange(q),v.extend(f.node,f.offset)):
(q.setEnd(f.node,f.offset),v.addRange(q))))));q=[];for(v=t;v=v.parentNode;)1===v.no
deType&&q.push({element:v,left:v.scrollLeft,top:v.scrollTop});"function"===typeof
t.focus&&t.focus();for(t=
0;t<q.length;t++)v=q[t],v.element.scrollLeft=v.left,v.element.scrollTop=v.top}fd=!!
kf;lf=kf=null;a.current=c;Z=d;do try{for(t=a;null!==Z;){var
K=Z.flags;K&36&&Yi(t,Z.alternate,Z);if(K&128){q=void 0;var Q=Z.ref;if(null!==Q){var
L=Z.stateNode;switch(Z.tag){case 5:q=L;break;default:q=L}"function"===typeof Q?
Q(q):Q.current=q}}Z=Z.nextEffect}}catch(va){if(null===Z)throw
Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!==Z);Z=null;$f();X=e}else
a.current=c;if(xj)xj=!1,yj=a,zj=b;else for(Z=d;null!==Z;)b=
Z.nextEffect,Z.nextEffect=null,Z.flags&8&&(K=Z,K.sibling=null,K.stateNode=null),Z=b
;d=a.pendingLanes;0===d&&(Ti=null);1===d?a===Ej?Dj++:
(Dj=0,Ej=a):Dj=0;c=c.stateNode;if(Mf&&"function"===typeof
Mf.onCommitFiberRoot)try{Mf.onCommitFiberRoot(Lf,c,void
0,64===(c.current.flags&64))}catch(va){}Mj(a,O());if(Qi)throw Qi=!
1,a=Ri,Ri=null,a;if(0!==(X&8))return null;ig();return null}
function ek(){for(;null!==Z;){var a=Z.alternate;Jj||null===Ij||(0!==(Z.flags&8)?
dc(Z,Ij)&&(Jj=!0):13===Z.tag&&mj(a,Z)&&dc(Z,Ij)&&(Jj=!0));var b=Z.flags;0!
==(b&256)&&Xi(a,Z);0===(b&512)||xj||(xj=!0,hg(97,function(){Oj();return
null}));Z=Z.nextEffect}}function Oj(){if(90!==zj){var a=97<zj?97:zj;zj=90;return
gg(a,fk)}return!1}function $i(a,b){Aj.push(b,a);xj||(xj=!0,hg(97,function()
{Oj();return null}))}function Zi(a,b){Bj.push(b,a);xj||(xj=!0,hg(97,function()
{Oj();return null}))}
function fk(){if(null===yj)return!1;var a=yj;yj=null;if(0!==(X&48))throw
Error(y(331));var b=X;X|=32;var c=Bj;Bj=[];for(var d=0;d<c.length;d+=2){var
e=c[d],f=c[d+1],g=e.destroy;e.destroy=void 0;if("function"===typeof
g)try{g()}catch(k){if(null===f)throw
Error(y(330));Wi(f,k)}}c=Aj;Aj=[];for(d=0;d<c.length;d+=2){e=c[d];f=c[d+1];try{var
h=e.create;e.destroy=h()}catch(k){if(null===f)throw
Error(y(330));Wi(f,k)}}for(h=a.current.firstEffect;null!
==h;)a=h.nextEffect,h.nextEffect=null,h.flags&8&&(h.sibling=
null,h.stateNode=null),h=a;X=b;ig();return!0}function gk(a,b,c)
{b=Mi(c,b);b=Pi(a,b,1);Ag(a,b);b=Hg();a=Kj(a,1);null!==a&&($c(a,1,b),Mj(a,b))}
function Wi(a,b){if(3===a.tag)gk(a,a,b);else for(var c=a.return;null!==c;)
{if(3===c.tag){gk(c,a,b);break}else if(1===c.tag){var
d=c.stateNode;if("function"===typeof
c.type.getDerivedStateFromError||"function"===typeof
d.componentDidCatch&&(null===Ti||!Ti.has(d))){a=Mi(b,a);var
e=Si(c,a,1);Ag(c,e);e=Hg();c=Kj(c,1);if(null!==c)$c(c,1,e),Mj(c,e);else
if("function"===typeof d.componentDidCatch&&(null===Ti||!
Ti.has(d)))try{d.componentDidCatch(b,a)}catch(f){}break}}c=c.return}}
function Yj(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=Hg();a.pingedLanes|
=a.suspendedLanes&c;U===a&&(W&c)===c&&(4===V||3===V&&(W&62914560)===W&&500>O()-jj?
Qj(a,0):uj|=c);Mj(a,b)}function lj(a,b){var c=a.stateNode;null!
==c&&c.delete(b);b=0;0===b&&(b=a.mode,0===(b&2)?b=1:0===(b&4)?b=99===eg()?1:2:
(0===Gj&&(Gj=tj),b=Yc(62914560&~Gj),0===b&&(b=4194304)));c=Hg();a=Kj(a,b);null!
==a&&($c(a,b,c),Mj(a,c))}var ck;
ck=function(a,b,c){var d=b.lanes;if(null!==a)if(a.memoizedProps!==b.pendingProps||
N.current)ug=!0;else if(0!==(c&d))ug=0!==(a.flags&16384)?!0:!1;else{ug=!
1;switch(b.tag){case 3:ri(b);sh();break;case 5:gh(b);break;case
1:Ff(b.type)&&Jf(b);break;case 4:eh(b,b.stateNode.containerInfo);break;case
10:d=b.memoizedProps.value;var
e=b.type._context;I(mg,e._currentValue);e._currentValue=d;break;case 13:if(null!
==b.memoizedState){if(0!==(c&b.child.childLanes))return
ti(a,b,c);I(P,P.current&1);b=hi(a,b,c);return null!==
b?b.sibling:null}I(P,P.current&1);break;case 19:d=0!==(c&b.childLanes);if(0!
==(a.flags&64)){if(d)return Ai(a,b,c);b.flags|=64}e=b.memoizedState;null!
==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);I(P,P.current);if(d)break;els
e return null;case 23:case 24:return b.lanes=0,mi(a,b,c)}return hi(a,b,c)}else ug=!
1;b.lanes=0;switch(b.tag){case 2:d=b.type;null!
==a&&(a.alternate=null,b.alternate=null,b.flags|
=2);a=b.pendingProps;e=Ef(b,M.current);tg(b,c);e=Ch(null,b,d,a,e,c);b.flags|
=1;if("object"===
typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof)
{b.tag=1;b.memoizedState=null;b.updateQueue=null;if(Ff(d)){var f=!0;Jf(b)}else f=!
1;b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null;xg(b);var
g=d.getDerivedStateFromProps;"function"===typeof
g&&Gg(b,d,g,a);e.updater=Kg;b.stateNode=e;e._reactInternals=b;Og(b,d,a,c);b=qi(null
,b,d,!0,f,c)}else b.tag=0,fi(null,b,e,c),b=b.child;return b;case
16:e=b.elementType;a:{null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);
a=b.pendingProps;f=e._init;e=f(e._payload);b.type=e;f=b.tag=hk(e);a=lg(e,a);switch(
f){case 0:b=li(null,b,e,a,c);break a;case 1:b=pi(null,b,e,a,c);break a;case
11:b=gi(null,b,e,a,c);break a;case 14:b=ii(null,b,e,lg(e.type,a),d,c);break a}throw
Error(y(306,e,""));}return b;case 0:return
d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),li(a,b,d,e,c);case 1:return
d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),pi(a,b,d,e,c);case
3:ri(b);d=b.updateQueue;if(null===a||null===d)throw Error(y(282));
d=b.pendingProps;e=b.memoizedState;e=null!==e?
e.element:null;yg(a,b);Cg(b,d,null,c);d=b.memoizedState.element;if(d===e)sh(),b=hi(
a,b,c);else{e=b.stateNode;if(f=e.hydrate)kh=rf(b.stateNode.containerInfo.firstChild
),jh=b,f=lh=!0;if(f){a=e.mutableSourceEagerHydrationData;if(null!
=a)for(e=0;e<a.length;e+=2)f=a[e],f._workInProgressVersionPrimary=a[e+1],th.push(f)
;c=Zg(b,null,d,c);for(b.child=c;c;)c.flags=c.flags&-3|1024,c=c.sibling}else
fi(a,b,d,c),sh();b=b.child}return b;case 5:return gh(b),null===a&&
ph(b),d=b.type,e=b.pendingProps,f=null!==a?
a.memoizedProps:null,g=e.children,nf(d,e)?g=null:null!==f&&nf(d,f)&&(b.flags|
=16),oi(a,b),fi(a,b,g,c),b.child;case 6:return null===a&&ph(b),null;case 13:return
ti(a,b,c);case 4:return eh(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?
b.child=Yg(b,null,d,c):fi(a,b,d,c),b.child;case 11:return
d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),gi(a,b,d,e,c);case 7:return
fi(a,b,b.pendingProps,c),b.child;case 8:return fi(a,b,b.pendingProps.children,
c),b.child;case 12:return fi(a,b,b.pendingProps.children,c),b.child;case 10:a:
{d=b.type._context;e=b.pendingProps;g=b.memoizedProps;f=e.value;var
h=b.type._context;I(mg,h._currentValue);h._currentValue=f;if(null!
==g)if(h=g.value,f=He(h,f)?0:("function"===typeof d._calculateChangedBits?
d._calculateChangedBits(h,f):1073741823)|0,0===f){if(g.children===e.children&&!
N.current){b=hi(a,b,c);break a}}else for(h=b.child,null!==h&&(h.return=b);null!
==h;){var k=h.dependencies;if(null!==k){g=h.child;for(var l=
k.firstContext;null!==l;){if(l.context===d&&0!==(l.observedBits&f))
{1===h.tag&&(l=zg(-1,c&-c),l.tag=2,Ag(h,l));h.lanes|=c;l=h.alternate;null!
==l&&(l.lanes|=c);sg(h.return,c);k.lanes|=c;break}l=l.next}}else g=10===h.tag?
h.type===b.type?null:h.child:h.child;if(null!==g)g.return=h;else for(g=h;null!==g;)
{if(g===b){g=null;break}h=g.sibling;if(null!==h)
{h.return=g.return;g=h;break}g=g.return}h=g}fi(a,b,e.children,c);b=b.child}return
b;case 9:return e=b.type,f=b.pendingProps,d=f.children,tg(b,c),e=vg(e,
f.unstable_observedBits),d=d(e),b.flags|=1,fi(a,b,d,c),b.child;case 14:return
e=b.type,f=lg(e,b.pendingProps),f=lg(e.type,f),ii(a,b,e,f,d,c);case 15:return
ki(a,b,b.type,b.pendingProps,d,c);case 17:return
d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),null!
==a&&(a.alternate=null,b.alternate=null,b.flags|=2),b.tag=1,Ff(d)?(a=!0,Jf(b)):a=!
1,tg(b,c),Mg(b,d,e),Og(b,d,e,c),qi(null,b,d,!0,a,c);case 19:return Ai(a,b,c);case
23:return mi(a,b,c);case 24:return mi(a,b,c)}throw Error(y(156,b.tag));
};function ik(a,b,c,d)
{this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type
=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependen
cies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.f
lags=0;this.lastEffect=this.firstEffect=this.nextEffect=null;this.childLanes=this.l
anes=0;this.alternate=null}function nh(a,b,c,d){return new ik(a,b,c,d)}function
ji(a){a=a.prototype;return!(!a||!a.isReactComponent)}
function hk(a){if("function"===typeof a)return ji(a)?1:0;if(void 0!==a&&null!==a)
{a=a.$$typeof;if(a===Aa)return 11;if(a===Da)return 14}return 2}
function Tg(a,b){var c=a.alternate;null===c?
(c=nh(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a
.stateNode,c.alternate=a,a.alternate=c):
(c.pendingProps=b,c.type=a.type,c.flags=0,c.nextEffect=null,c.firstEffect=null,c.la
stEffect=null);c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoized
Props=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b
=a.dependencies;c.dependencies=null===b?null:
{lanes:b.lanes,firstContext:b.firstContext};
c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}
function Vg(a,b,c,d,e,f){var g=2;d=a;if("function"===typeof a)ji(a)&&(g=1);else
if("string"===typeof a)g=5;else a:switch(a){case ua:return
Xg(c.children,e,f,b);case Ha:g=8;e|=16;break;case wa:g=8;e|=1;break;case xa:return
a=nh(12,c,b,e|8),a.elementType=xa,a.type=xa,a.lanes=f,a;case Ba:return
a=nh(13,c,b,e),a.type=Ba,a.elementType=Ba,a.lanes=f,a;case Ca:return
a=nh(19,c,b,e),a.elementType=Ca,a.lanes=f,a;case Ia:return vi(c,e,f,b);case
Ja:return a=nh(24,c,b,e),a.elementType=Ja,a.lanes=f,a;default:if("object"===
typeof a&&null!==a)switch(a.$$typeof){case ya:g=10;break a;case za:g=9;break a;case
Aa:g=11;break a;case Da:g=14;break a;case Ea:g=16;d=null;break a;case Fa:g=22;break
a}throw Error(y(130,null==a?a:typeof
a,""));}b=nh(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function
Xg(a,b,c,d){a=nh(7,a,d,b);a.lanes=c;return a}function vi(a,b,c,d)
{a=nh(23,a,d,b);a.elementType=Ia;a.lanes=c;return a}function Ug(a,b,c)
{a=nh(6,a,null,b);a.lanes=c;return a}
function Wg(a,b,c){b=nh(4,null!==a.children?a.children:
[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:nu
ll,implementation:a.implementation};return b}
function jk(a,b,c)
{this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this
.pendingChildren=null;this.timeoutHandle=-
1;this.pendingContext=this.context=null;this.hydrate=c;this.callbackNode=null;this.
callbackPriority=0;this.eventTimes=Zc(0);this.expirationTimes=Zc(-
1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=t
his.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=Zc(0);th
is.mutableSourceEagerHydrationData=null}
function kk(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?
arguments[3]:null;return{$$typeof:ta,key:null==d?
null:""+d,children:a,containerInfo:b,implementation:c}}
function lk(a,b,c,d){var e=b.current,f=Hg(),g=Ig(e);a:if(c){c=c._reactInternals;b:
{if(Zb(c)!==c||1!==c.tag)throw Error(y(170));var h=c;do{switch(h.tag){case
3:h=h.stateNode.context;break b;case 1:if(Ff(h.type))
{h=h.stateNode.__reactInternalMemoizedMergedChildContext;break
b}}h=h.return}while(null!==h);throw Error(y(171));}if(1===c.tag){var
k=c.type;if(Ff(k)){c=If(c,k,h);break a}}c=h}else c=Cf;null===b.context?
b.context=c:b.pendingContext=c;b=zg(f,g);b.payload={element:a};d=void 0===d?
null:d;null!==
d&&(b.callback=d);Ag(e,b);Jg(e,g,f);return g}function mk(a){a=a.current;if(!
a.child)return null;switch(a.child.tag){case 5:return
a.child.stateNode;default:return a.child.stateNode}}function nk(a,b)
{a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var
c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function ok(a,b){nk(a,b);
(a=a.alternate)&&nk(a,b)}function pk(){return null}
function qk(a,b,c){var d=null!=c&&null!
=c.hydrationOptions&&c.hydrationOptions.mutableSources||null;c=new jk(a,b,null!
=c&&!0===c.hydrate);b=nh(3,null,null,2===b?7:1===b?
3:0);c.current=b;b.stateNode=c;xg(b);a[ff]=c.current;cf(8===a.nodeType?
a.parentNode:a);if(d)for(a=0;a<d.length;a++){b=d[a];var
e=b._getVersion;e=e(b._source);null==c.mutableSourceEagerHydrationData?
c.mutableSourceEagerHydrationData=[b,e]:c.mutableSourceEagerHydrationData.push(b,e)
}this._internalRoot=c}
qk.prototype.render=function(a)
{lk(a,this._internalRoot,null,null)};qk.prototype.unmount=function(){var
a=this._internalRoot,b=a.containerInfo;lk(null,a,null,function()
{b[ff]=null})};function rk(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!
==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}
function sk(a,b){b||(b=a?9===a.nodeType?a.documentElement:a.firstChild:null,b=!(!
b||1!==b.nodeType||!b.hasAttribute("data-reactroot")));if(!b)for(var
c;c=a.lastChild;)a.removeChild(c);return new qk(a,0,b?{hydrate:!0}:void 0)}
function tk(a,b,c,d,e){var f=c._reactRootContainer;if(f){var
g=f._internalRoot;if("function"===typeof e){var h=e;e=function(){var
a=mk(g);h.call(a)}}lk(b,g,a,e)}else{f=c._reactRootContainer=sk(c,d);g=f._internalRo
ot;if("function"===typeof e){var k=e;e=function(){var
a=mk(g);k.call(a)}}Xj(function(){lk(b,g,a,e)})}return mk(g)}ec=function(a)
{if(13===a.tag){var b=Hg();Jg(a,4,b);ok(a,4)}};fc=function(a){if(13===a.tag){var
b=Hg();Jg(a,67108864,b);ok(a,67108864)}};
gc=function(a){if(13===a.tag){var
b=Hg(),c=Ig(a);Jg(a,c,b);ok(a,c)}};hc=function(a,b){return b()};
yb=function(a,b,c){switch(b){case
"input":ab(a,c);b=c.name;if("radio"===c.type&&null!=b)
{for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll("input[name="+JSON.strin
gify(""+b)+'][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!
==a&&d.form===a.form){var e=Db(d);if(!e)throw
Error(y(90));Wa(d);ab(d,e)}}}break;case "textarea":ib(a,c);break;case
"select":b=c.value,null!=b&&fb(a,!!c.multiple,b,!1)}};Gb=Wj;
Hb=function(a,b,c,d,e){var f=X;X|=4;try{return
gg(98,a.bind(null,b,c,d,e))}finally{X=f,0===X&&(wj(),ig())}};Ib=function()
{0===(X&49)&&(Vj(),Oj())};Jb=function(a,b){var c=X;X|=2;try{return
a(b)}finally{X=c,0===X&&(wj(),ig())}};function uk(a,b){var
c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!rk(b))throw
Error(y(200));return kk(a,b,null,c)}var vk={Events:[Cb,ue,Db,Eb,Fb,Oj,{current:!
1}]},wk={findFiberByHostInstance:wc,bundleType:0,version:"17.0.2",rendererPackageNa
me:"react-dom"};
var
xk={bundleType:wk.bundleType,version:wk.version,rendererPackageName:wk.rendererPack
ageName,rendererConfig:wk.rendererConfig,overrideHookState:null,overrideHookStateDe
letePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDele
tePath:null,overridePropsRenamePath:null,setSuspenseHandler:null,scheduleUpdate:nul
l,currentDispatcherRef:ra.ReactCurrentDispatcher,findHostInstanceByFiber:function(a
){a=cc(a);return null===a?
null:a.stateNode},findFiberByHostInstance:wk.findFiberByHostInstance||
pk,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefre
shHandler:null,getCurrentFiber:null};if("undefined"!==typeof
__REACT_DEVTOOLS_GLOBAL_HOOK__){var yk=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!
yk.isDisabled&&yk.supportsFiber)try{Lf=yk.inject(xk),Mf=yk}catch(a)
{}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=vk;exports.createPort
al=uk;
exports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return
a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw
Error(y(188));throw Error(y(268,Object.keys(a)));}a=cc(b);a=null===a?
null:a.stateNode;return a};exports.flushSync=function(a,b){var c=X;if(0!
==(c&48))return a(b);X|=1;try{if(a)return
gg(99,a.bind(null,b))}finally{X=c,ig()}};exports.hydrate=function(a,b,c){if(!
rk(b))throw Error(y(200));return tk(null,a,b,!0,c)};
exports.render=function(a,b,c){if(!rk(b))throw Error(y(200));return tk(null,a,b,!
1,c)};exports.unmountComponentAtNode=function(a){if(!rk(a))throw
Error(y(40));return a._reactRootContainer?(Xj(function(){tk(null,null,a,!
1,function(){a._reactRootContainer=null;a[ff]=null})}),!0):!
1};exports.unstable_batchedUpdates=Wj;exports.unstable_createPortal=function(a,b)
{return uk(a,b,2<arguments.length&&void 0!==arguments[2]?arguments[2]:null)};
exports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!rk(c))throw
Error(y(200));if(null==a||void 0===a._reactInternals)throw Error(y(38));return
tk(a,b,c,!1,d)};exports.version="17.0.2";
/***/ }),
/***/ 73935:
"use strict";
function checkDCE() {
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
if (
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
) {
return;
}
if (false) {}
try {
// Verify that the code above has been dead code eliminated (DCE'd).
__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
} catch (err) {
// DevTools shouldn't crash React, no matter what.
// We should still report in case we break this code.
console.error(err);
}
}
if (true) {
// DCE check should happen before ReactDOM bundle executes so that
// DevTools can report bad minification during injection.
checkDCE();
} else {}
/***/ }),
/***/ 69921:
"use strict";
var __webpack_unused_export__;
/**
* @license React
* react-is.production.min.js
*
*
*/
var
b=Symbol.for("react.element"),c=Symbol.for("react.portal"),d=Symbol.for("react.frag
ment"),e=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.fo
r("react.provider"),h=Symbol.for("react.context"),k=Symbol.for("react.server_contex
t"),l=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),n=Symbol.for("
react.suspense_list"),p=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),t=Symbo
l.for("react.offscreen"),u;u=Symbol.for("react.module.reference");
function v(a){if("object"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case
b:switch(a=a.type,a){case d:case f:case e:case m:case n:return
a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case
g:return a;default:return r}}case c:return
r}}}__webpack_unused_export__=h;__webpack_unused_export__=g;__webpack_unused_export
__=b;__webpack_unused_export__=l;__webpack_unused_export__=d;__webpack_unused_expor
t__=q;__webpack_unused_export__=p;__webpack_unused_export__=c;__webpack_unused_expo
rt__=f;__webpack_unused_export__=e;__webpack_unused_export__=m;
__webpack_unused_export__=n;__webpack_unused_export__=function(){return!
1};__webpack_unused_export__=function(){return!
1};exports.isContextConsumer=function(a){return
v(a)===h};__webpack_unused_export__=function(a){return
v(a)===g};__webpack_unused_export__=function(a){return"object"===typeof a&&null!
==a&&a.$$typeof===b};__webpack_unused_export__=function(a){return
v(a)===l};__webpack_unused_export__=function(a){return
v(a)===d};__webpack_unused_export__=function(a){return
v(a)===q};__webpack_unused_export__=function(a){return v(a)===p};
__webpack_unused_export__=function(a){return
v(a)===c};__webpack_unused_export__=function(a){return
v(a)===f};__webpack_unused_export__=function(a){return
v(a)===e};__webpack_unused_export__=function(a){return
v(a)===m};__webpack_unused_export__=function(a){return v(a)===n};
__webpack_unused_export__=function(a){return"string"===typeof
a||"function"===typeof a||a===d||a===f||a===e||a===m||a===n||
a===t||"object"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$
$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!
==a.getModuleId)?!0:!1};__webpack_unused_export__=v;
/***/ }),
/***/ 59864:
"use strict";
if (true) {
} else {}
/***/ }),
/***/ 50906:
"use strict";
/* harmony export */ "V": () => (/* binding */ createInvalidArgFactory)
function createInvalidArgFactory(arg, name) {
return (dispatch, options) => {
throw new Error(Ìnvalid value of type ${typeof arg} for ${name} argument when
connecting component ${options.wrappedComponentName}.`);
};
}
/***/ }),
/***/ 55112:
"use strict";
/* harmony export */ "W": () => (/* binding */ mapDispatchToPropsFactory)
_utils_bindActionCreators__WEBPACK_IMPORTED_MODULE_1__ =
}
/* harmony import */ var _wrapMapToProps__WEBPACK_IMPORTED_MODULE_0__ =
}
/* harmony import */ var _invalidArgFactory__WEBPACK_IMPORTED_MODULE_2__ =
}
function mapDispatchToPropsFactory(mapDispatchToProps) {
return mapDispatchToProps && typeof mapDispatchToProps === 'object' ?
(0,_wrapMapToProps__WEBPACK_IMPORTED_MODULE_0__/* .wrapMapToPropsConstant */ .dX)
(dispatch => // @ts-ignore
(0,_utils_bindActionCreators__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)
(mapDispatchToProps, dispatch)) : !mapDispatchToProps ?
(dispatch => ({
dispatch
})) : typeof mapDispatchToProps === 'function' ? // @ts-ignore
(0,_wrapMapToProps__WEBPACK_IMPORTED_MODULE_0__/* .wrapMapToPropsFunc */ .xv)
(mapDispatchToProps, 'mapDispatchToProps') :
(0,_invalidArgFactory__WEBPACK_IMPORTED_MODULE_2__/* .createInvalidArgFactory
*/ .V)(mapDispatchToProps, 'mapDispatchToProps');
}
/***/ }),
/***/ 11743:
"use strict";
/* harmony export */ "R": () => (/* binding */ mapStateToPropsFactory)
/* harmony import */ var _wrapMapToProps__WEBPACK_IMPORTED_MODULE_0__ =
}
}
function mapStateToPropsFactory(mapStateToProps) {
return !mapStateToProps ?
(() => ({})) : typeof mapStateToProps === 'function' ? // @ts-ignore
(0,_wrapMapToProps__WEBPACK_IMPORTED_MODULE_0__/* .wrapMapToPropsFunc */ .xv)
(mapStateToProps, 'mapStateToProps') :
*/ .V)(mapStateToProps, 'mapStateToProps');
}
/***/ }),
/***/ 5532:
"use strict";
/* harmony export */ "eV": () => (/* binding */ mergePropsFactory)
/* unused harmony exports defaultMergeProps, wrapMergePropsFunc */
_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__ =
}
}
function defaultMergeProps(stateProps, dispatchProps, ownProps) {

// @ts-ignore
return (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__/*
["default"] */ .Z)({}, ownProps, stateProps, dispatchProps);
}
function wrapMergePropsFunc(mergeProps) {
return function initMergePropsProxy(dispatch, {
displayName,
areMergedPropsEqual
}) {
let hasRunOnce = false;
let mergedProps;
return function mergePropsProxy(stateProps, dispatchProps, ownProps) {
const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);
if (hasRunOnce) {
if (!areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps =
nextMergedProps;
} else {
hasRunOnce = true;
mergedProps = nextMergedProps;
if (false) {}
}
return mergedProps;
};
};
}
function mergePropsFactory(mergeProps) {
return !mergeProps ? () => defaultMergeProps : typeof mergeProps === 'function' ?
wrapMergePropsFunc(mergeProps) :
*/ .V)(mergeProps, 'mergeProps');
}
/***/ }),
/***/ 38548:
"use strict";
/* harmony export */ "Z": () => (/* binding */ finalPropsSelectorFactory)
/* unused harmony export pureFinalPropsSelectorFactory */
_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_0_
_ = __webpack_require__(63366);
}
const _excluded = (/* runtime-dependent pure expression or super */ 828 !=

__webpack_require__.j ? (["initMapStateToProps", "initMapDispatchToProps",
"initMergeProps"]) : null);
function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps,

mergeProps, dispatch, {
areStatesEqual,
areOwnPropsEqual,
areStatePropsEqual
}) {
let hasRunAtLeastOnce = false;
let state;
let ownProps;
let stateProps;
let dispatchProps;
let mergedProps;
function handleFirstCall(firstState, firstOwnProps) {

state = firstState;
ownProps = firstOwnProps;
stateProps = mapStateToProps(state, ownProps);
dispatchProps = mapDispatchToProps(dispatch, ownProps);
mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
hasRunAtLeastOnce = true;
return mergedProps;
}
function handleNewPropsAndNewState() {
stateProps = mapStateToProps(state, ownProps);
if (mapDispatchToProps.dependsOnOwnProps) dispatchProps =
mapDispatchToProps(dispatch, ownProps);
return mergedProps;
}
function handleNewProps() {
if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state,
ownProps);
if (mapDispatchToProps.dependsOnOwnProps) dispatchProps =
mapDispatchToProps(dispatch, ownProps);
return mergedProps;
}
function handleNewState() {
const nextStateProps = mapStateToProps(state, ownProps);
const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);
stateProps = nextStateProps;
if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps,
ownProps);
return mergedProps;
}
function handleSubsequentCalls(nextState, nextOwnProps) {

const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);
const stateChanged = !areStatesEqual(nextState, state);
state = nextState;
ownProps = nextOwnProps;
if (propsChanged && stateChanged) return handleNewPropsAndNewState();
if (propsChanged) return handleNewProps();
if (stateChanged) return handleNewState();
return mergedProps;
}
return function pureFinalPropsSelector(nextState, nextOwnProps) {

return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) :
handleFirstCall(nextState, nextOwnProps);
};
}
// TODO: Add more comments
// The selector returned by selectorFactory will memoize its results,
// allowing connect's shouldComponentUpdate to return false if final
// props have not changed.
function finalPropsSelectorFactory(dispatch, _ref) {
let {
initMapStateToProps,
initMapDispatchToProps,
initMergeProps
} = _ref,
options =
(0,_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE
_0__/* ["default"] */ .Z)(_ref, _excluded);
const mapStateToProps = initMapStateToProps(dispatch, options);

const mapDispatchToProps = initMapDispatchToProps(dispatch, options);
const mergeProps = initMergeProps(dispatch, options);
if (false) {}
return pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps,

mergeProps, dispatch, options);
}
/***/ }),
/***/ 26343:
"use strict";
/* harmony export */ "dX": () => (/* binding */ wrapMapToPropsConstant),
/* harmony export */ "xv": () => (/* binding */ wrapMapToPropsFunc)
/* unused harmony export getDependsOnOwnProps */
function wrapMapToPropsConstant( // * Note:

// It seems that the dispatch argument
// could be a dispatch function in some cases (ex:
whenMapDispatchToPropsIsMissing)
// and a state object in some others (ex: whenMapStateToPropsIsMissing)
getConstant) {
return function initConstantSelector(dispatch) {
const constant = getConstant(dispatch);
function constantSelector() {
return constant;
}
constantSelector.dependsOnOwnProps = false;
return constantSelector;
};
} // dependsOnOwnProps is used by createMapToPropsProxy to determine whether to
pass props as args
// to the mapToProps function being wrapped. It is also used by
makePurePropsSelector to determine
// whether mapToProps needs to be invoked when props have changed.
//
// A length of one signals that mapToProps does not depend on props from the parent
component.
// A length of zero is assumed to mean mapToProps is getting args via arguments
or ...args and
// therefore not reporting its length accurately..
// TODO Can this get pulled out so that we can subscribe directly to the store if
we don't need ownProps?
function getDependsOnOwnProps(mapToProps) {
return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) :
mapToProps.length !== 1;
} // Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,
// this function wraps mapToProps in a proxy function which does several things:
//
// * Detects whether the mapToProps function being called depends on props, which
// is used by selectorFactory to decide if it should reinvoke on props changes.
//
// * On first call, handles mapToProps if returns another function, and treats
that
// new function as the true mapToProps for subsequent calls.
//
// * On first call, verifies the first result is a plain object, in order to warn
// the developer that their mapToProps function is not returning a valid result.
//
function wrapMapToPropsFunc(mapToProps, methodName) {

return function initProxySelector(dispatch, {
displayName
}) {
const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {
return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch,
ownProps) : proxy.mapToProps(stateOrDispatch, undefined);
}; // allow detectFactoryAndVerify to get ownProps
proxy.dependsOnOwnProps = true;
proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {

proxy.mapToProps = mapToProps;
proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);
let props = proxy(stateOrDispatch, ownProps);
if (typeof props === 'function') {

proxy.mapToProps = props;
proxy.dependsOnOwnProps = getDependsOnOwnProps(props);
props = proxy(stateOrDispatch, ownProps);
}
if (false) {}
return props;
};
return proxy;
};
}
/***/ }),
/***/ 85656:
"use strict";
// ESM COMPAT FLAG
// EXPORTS
"Provider": () => (/* reexport */ components_Provider),
"ReactReduxContext": () => (/* reexport */ ReactReduxContext),
"batch": () => (/* reexport */ react_dom.unstable_batchedUpdates),
"connect": () => (/* reexport */ components_connect),
"createDispatchHook": () => (/* reexport */ createDispatchHook),
"createSelectorHook": () => (/* reexport */ createSelectorHook),
"createStoreHook": () => (/* reexport */ createStoreHook),
"shallowEqual": () => (/* reexport */ shallowEqual/* default */.Z),
"useDispatch": () => (/* reexport */ useDispatch),
"useSelector": () => (/* reexport */ useSelector),
"useStore": () => (/* reexport */ useStore_useStore)
});
// EXTERNAL MODULE: ./node_modules/use-sync-external-store/shim/index.js

// EXTERNAL MODULE: ./node_modules/use-sync-external-store/shim/with-selector.js
var with_selector = __webpack_require__(52798);
// EXTERNAL MODULE: ./node_modules/react-dom/index.js
var react_dom = __webpack_require__(73935);
;// CONCATENATED MODULE: ./node_modules/react-redux/es/utils/reactBatchedUpdates.js
// EXTERNAL MODULE: ./node_modules/react-redux/es/utils/batch.js

var utils_batch = __webpack_require__(9256);
// EXTERNAL MODULE: ./node_modules/react/index.js
var react = __webpack_require__(67294);
;// CONCATENATED MODULE: ./node_modules/react-redux/es/components/Context.js
const ReactReduxContext = /*#__PURE__*/react.createContext(null);
if (false) {}
/* harmony default export */ const Context = ((/* unused pure expression or super
*/ null && (ReactReduxContext)));
;// CONCATENATED MODULE: ./node_modules/react-redux/es/hooks/useReduxContext.js
/**
* A hook to access the value of the `ReactReduxContext`. This is a low-level
* hook that you should usually not need to call directly.
*
* @returns {any} the value of the `ReactReduxContext`
*
* @example
*
* import React from 'react'
* import { useReduxContext } from 'react-redux'
*
* export const CounterComponent = () => {
* const { store } = useReduxContext()
* return <div>{store.getState()}</div>
* }
*/
function useReduxContext_useReduxContext() {
const contextValue = (0,react.useContext)(ReactReduxContext);
if (false) {}
return contextValue;
}
// EXTERNAL MODULE: ./node_modules/react-redux/es/utils/useSyncExternalStore.js
var useSyncExternalStore = __webpack_require__(76726);
;// CONCATENATED MODULE: ./node_modules/react-redux/es/hooks/useSelector.js
let useSyncExternalStoreWithSelector = useSyncExternalStore/* notInitialized */.B;

const initializeUseSelector = fn => {
useSyncExternalStoreWithSelector = fn;
};
const refEquality = (a, b) => a === b;

/**
* Hook factory, which creates a ùseSelector` hook bound to a given context.
*
* @param {React.Context} [context=ReactReduxContext] Context passed to your
`<Provider>`.
* @returns {Function} A ùseSelector` hook bound to the specified context.
*/
function createSelectorHook(context = ReactReduxContext) {

const useReduxContext = context === ReactReduxContext ?
useReduxContext_useReduxContext : () => (0,react.useContext)(context);
return function useSelector(selector, equalityFn = refEquality) {
if (false) {}
const {
store,
subscription,
getServerState
} = useReduxContext();
const selectedState =
useSyncExternalStoreWithSelector(subscription.addNestedSub, store.getState,
getServerState || store.getState, selector, equalityFn);
(0,react.useDebugValue)(selectedState);
return selectedState;
};
}
/**
* A hook to access the redux store's state. This hook takes a selector function
* as an argument. The selector is called with the store state.
*
* This hook takes an optional equality comparison function as the second parameter
* that allows you to customize the way the selected state is compared to determine
* whether the component needs to be re-rendered.
*
* @param {Function} selector the selector function
* @param {Function=} equalityFn the function that will be used to determine
equality
*
* @returns {any} the selected state
*
* @example
*
* import { useSelector } from 'react-redux'
*
* export const CounterComponent = () => {
* const counter = useSelector(state => state.counter)
* return <div>{counter}</div>
* }
*/
const useSelector = /*#__PURE__*/createSelectorHook();

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__(87462);
// EXTERNAL MODULE:
./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
var objectWithoutPropertiesLoose = __webpack_require__(63366);
// EXTERNAL MODULE: ./node_modules/hoist-non-react-statics/dist/hoist-non-react-
statics.cjs.js
var hoist_non_react_statics_cjs = __webpack_require__(8679);
var hoist_non_react_statics_cjs_default =
/*#__PURE__*/__webpack_require__.n(hoist_non_react_statics_cjs);
// EXTERNAL MODULE: ./node_modules/react-is/index.js
var react_is = __webpack_require__(59864);
// EXTERNAL MODULE: ./node_modules/react-redux/es/connect/selectorFactory.js
var selectorFactory = __webpack_require__(38548);
// EXTERNAL MODULE: ./node_modules/react-redux/es/connect/mapDispatchToProps.js
var connect_mapDispatchToProps = __webpack_require__(55112);
// EXTERNAL MODULE: ./node_modules/react-redux/es/connect/mapStateToProps.js
var connect_mapStateToProps = __webpack_require__(11743);
// EXTERNAL MODULE: ./node_modules/react-redux/es/connect/mergeProps.js
var connect_mergeProps = __webpack_require__(5532);
;// CONCATENATED MODULE: ./node_modules/react-redux/es/utils/Subscription.js
// encapsulates the subscription logic for connecting a component to the redux
store, as
// well as nesting subscriptions of descendant components, so that we can ensure
the
// ancestor components re-render before descendants
function createListenerCollection() {
const batch = (0,utils_batch/* getBatch */.k)();
let first = null;
let last = null;
return {
clear() {
first = null;
last = null;
},
notify() {
batch(() => {
let listener = first;
while (listener) {
listener.callback();
listener = listener.next;
}
});
},
get() {
let listeners = [];
let listener = first;
while (listener) {
listeners.push(listener);
listener = listener.next;
}
return listeners;
},
subscribe(callback) {
let isSubscribed = true;
let listener = last = {
callback,
next: null,
prev: last
};
if (listener.prev) {
listener.prev.next = listener;
} else {
first = listener;
}
return function unsubscribe() {

if (!isSubscribed || first === null) return;
isSubscribed = false;
if (listener.next) {
listener.next.prev = listener.prev;
} else {
last = listener.prev;
}
if (listener.prev) {
listener.prev.next = listener.next;
} else {
first = listener.next;
}
};
}
};
}
const nullListeners = {
notify() {},
get: () => []
};
function createSubscription(store, parentSub) {
let unsubscribe;
let listeners = nullListeners;
function addNestedSub(listener) {
trySubscribe();
return listeners.subscribe(listener);
}
function notifyNestedSubs() {
listeners.notify();
}
function handleChangeWrapper() {
if (subscription.onStateChange) {
subscription.onStateChange();
}
}
function isSubscribed() {
return Boolean(unsubscribe);
}
function trySubscribe() {
if (!unsubscribe) {
unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) :
store.subscribe(handleChangeWrapper);
listeners = createListenerCollection();
}
}
function tryUnsubscribe() {
if (unsubscribe) {
unsubscribe();
unsubscribe = undefined;
listeners.clear();
listeners = nullListeners;
}
}
const subscription = {
addNestedSub,
notifyNestedSubs,
handleChangeWrapper,
isSubscribed,
trySubscribe,
tryUnsubscribe,
getListeners: () => listeners
};
return subscription;
}
;// CONCATENATED MODULE:
./node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js
// React currently throws a warning when using useLayoutEffect on the server.
// To get around it, we can conditionally useEffect on the server (no-op) and
// useLayoutEffect in the browser. We need useLayoutEffect to ensure the store
// subscription callback always has the selector from the latest render commit
// available, otherwise a store update may happen between render and the effect,
// which may cause missed updates; we also must ensure the store subscription
// is created synchronously, otherwise a store update may occur before the
// subscription is created and an inconsistent state may be observed
// Matches logic in React's `shared/ExecutionEnvironment` file
const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !==
'undefined' && typeof window.document.createElement !== 'undefined');
const useIsomorphicLayoutEffect = canUseDOM ? react.useLayoutEffect :
react.useEffect;
// EXTERNAL MODULE: ./node_modules/react-redux/es/utils/shallowEqual.js
var shallowEqual = __webpack_require__(35067);
;// CONCATENATED MODULE: ./node_modules/react-redux/es/components/connect.js
const _excluded = ["reactReduxForwardedRef"];
/* eslint-disable valid-jsdoc, @typescript-eslint/no-unused-vars */
let connect_useSyncExternalStore = useSyncExternalStore/* notInitialized */.B;

const initializeConnect = fn => {
connect_useSyncExternalStore = fn;
}; // Define some constant arrays just to avoid re-creating these
const EMPTY_ARRAY = (/* unused pure expression or super */ null && ([null, 0]));
const NO_SUBSCRIPTION_ARRAY = [null, null]; // Attempts to stringify whatever not-
really-a-component value we were given
// for logging in an error message
const stringifyComponent = Comp => {

try {
return JSON.stringify(Comp);
} catch (err) {
return String(Comp);
}
};
// This is "just" a ùseLayoutEffect`, but with two modifications:

// - we need to fall back to ùseEffect` in SSR to avoid annoying warnings
// - we extract this to a separate function to avoid closing over values
// and causing memory leaks
function useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {
useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies);
} // Effect callback, extracted: assign the latest props values to refs for later
usage
function captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled,

wrapperProps, // actualChildProps: unknown,
childPropsFromStoreUpdate, notifyNestedSubs) {
// We want to capture the wrapper props and child props we used for later
comparisons
lastWrapperProps.current = wrapperProps;
renderIsScheduled.current = false; // If the render was from a store update,
clear out that reference and cascade the subscriber update
if (childPropsFromStoreUpdate.current) {
childPropsFromStoreUpdate.current = null;
notifyNestedSubs();
}
} // Effect callback, extracted: subscribe to the Redux store or nearest connected
ancestor,
// check for updates after dispatched actions, and trigger re-renders.
function subscribeUpdates(shouldHandleStateChanges, store, subscription,

childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted,
childPropsFromStoreUpdate, notifyNestedSubs, // forceComponentUpdateDispatch:
React.Dispatch<any>,
additionalSubscribeListener) {
// If we're not subscribed to the store, nothing to do here
if (!shouldHandleStateChanges) return () => {}; // Capture values for checking if
and when this component unmounts
let didUnsubscribe = false;

let lastThrownError = null; // We'll run this callback every time a store
subscription update propagates to this component
const checkForUpdates = () => {

if (didUnsubscribe || !isMounted.current) {
// Don't run stale listeners.
// Redux doesn't guarantee unsubscriptions happen until next dispatch.
return;
} // TODO We're currently calling getState ourselves here, rather than letting
ùSES` do it
const latestStoreState = store.getState();

let newChildProps, error;
try {
// Actually run the selector with the most recent store state and wrapper
props
// to determine what the child props should be
newChildProps = childPropsSelector(latestStoreState,
lastWrapperProps.current);
} catch (e) {
error = e;
lastThrownError = e;
}
if (!error) {
lastThrownError = null;
} // If the child props haven't changed, nothing to do here - cascade the
subscription update
if (newChildProps === lastChildProps.current) {

if (!renderIsScheduled.current) {
notifyNestedSubs();
}
} else {
// Save references to the new child props. Note that we track the "child
props from store update"
// as a ref instead of a useState/useReducer because we need a way to
determine if that value has
// been processed. If this went into useState/useReducer, we couldn't clear
out the value without
// forcing another re-render, which we don't want.
lastChildProps.current = newChildProps;
childPropsFromStoreUpdate.current = newChildProps;
renderIsScheduled.current = true; // TODO This is hacky and not how ùSES` is
meant to be used
// Trigger the React ùseSyncExternalStore` subscriber
additionalSubscribeListener();
}
}; // Actually subscribe to the nearest connected ancestor (or store)
subscription.onStateChange = checkForUpdates;
subscription.trySubscribe(); // Pull data from the store after first render in
case the store has
// changed since we began.
checkForUpdates();
const unsubscribeWrapper = () => {

didUnsubscribe = true;
subscription.tryUnsubscribe();
subscription.onStateChange = null;
if (lastThrownError) {
// It's possible that we caught an error due to a bad mapState function, but
the
// parent re-rendered without this component and we're about to unmount.
// This shouldn't happen as long as we do top-down subscriptions correctly,
but
// if we ever do those wrong, this throw will surface the error in our tests.
// In that case, throw the error from here so it doesn't get lost.
throw lastThrownError;
}
};
return unsubscribeWrapper;
} // Reducer initial state creation for our update reducer
const initStateUpdates = () => EMPTY_ARRAY;
function strictEqual(a, b) {
return a === b;
}
/**
* Infers the type of props that a connector will inject into a component.
*/
let hasWarnedAboutDeprecatedPureOption = false;

/**
* Connects a React component to a Redux store.
*
* - Without arguments, just wraps the component, without changing the behavior /
props
*
* - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior
* is to override ownProps (as stated in the docs), so what remains is everything
that's
* not a state or dispatch prop
*
* - When 3rd param is passed, we don't know if ownProps propagate and whether they
* should be valid component props, because it depends on mergeProps
implementation.
* As such, it is the user's responsibility to extend ownProps interface from state
or
* dispatch props or both when applicable
*
* @param mapStateToProps A function that extracts values from state
* @param mapDispatchToProps Setup for dispatching actions
* @param mergeProps Optional callback to merge state and dispatch props together
* @param options Options for configuring the connection
*
*/
function connect(mapStateToProps, mapDispatchToProps, mergeProps, {

// The `pure` option has been removed, so TS doesn't like us destructuring this
to check its existence.
// @ts-ignore
pure,
areStatesEqual = strictEqual,
areOwnPropsEqual = shallowEqual/* default */.Z,
areStatePropsEqual = shallowEqual/* default */.Z,
areMergedPropsEqual = shallowEqual/* default */.Z,
// use React's forwardRef to expose a ref of the wrapped component
forwardRef = false,
// the context consumer to use
context = ReactReduxContext
} = {}) {
if (false) {}
const Context = context;

const initMapStateToProps = (0,connect_mapStateToProps/* mapStateToPropsFactory
*/.R)(mapStateToProps);
const initMapDispatchToProps = (0,connect_mapDispatchToProps/*
mapDispatchToPropsFactory */.W)(mapDispatchToProps);
const initMergeProps = (0,connect_mergeProps/* mergePropsFactory */.eV)
(mergeProps);
const shouldHandleStateChanges = Boolean(mapStateToProps);
const wrapWithConnect = WrappedComponent => {

if (false) {}
const wrappedComponentName = WrappedComponent.displayName ||

WrappedComponent.name || 'Component';
const displayName = `Connect(${wrappedComponentName})`;
const selectorFactoryOptions = {
shouldHandleStateChanges,
displayName,
wrappedComponentName,
WrappedComponent,
// @ts-ignore
initMapStateToProps,
// @ts-ignore
initMapDispatchToProps,
initMergeProps,
areStatesEqual,
areStatePropsEqual,
areOwnPropsEqual,
areMergedPropsEqual
};
function ConnectFunction(props) {
const [propsContext, reactReduxForwardedRef, wrapperProps] =
(0,react.useMemo)(() => {
// Distinguish between actual "data" props that were passed to the wrapper
component,
// and values needed to control behavior (forwarded refs, alternate context
instances).
// To maintain the wrapperProps object reference, memoize this
destructuring.
const {
reactReduxForwardedRef
} = props,
wrapperProps = (0,objectWithoutPropertiesLoose/* default */.Z)(props,
_excluded);
return [props.context, reactReduxForwardedRef, wrapperProps];

}, [props]);
const ContextToUse = (0,react.useMemo)(() => {
// Users may optionally pass in a custom context instance to use instead of
our ReactReduxContext.
// Memoize the check that determines which context instance we should use.
return propsContext && propsContext.Consumer && // @ts-ignore
(0,react_is.isContextConsumer)(
/*#__PURE__*/react.createElement(propsContext.Consumer, null)) ? propsContext :
Context;
}, [propsContext, Context]); // Retrieve the store and ancestor subscription
via context, if available
const contextValue = (0,react.useContext)(ContextToUse); // The store _must_

exist as either a prop or in context.
// We'll check to see if it _looks_ like a Redux store first.
// This allows us to pass through a `store` prop that is just a plain value.
const didStoreComeFromProps = Boolean(props.store) &&

Boolean(props.store.getState) && Boolean(props.store.dispatch);
const didStoreComeFromContext = Boolean(contextValue) &&
Boolean(contextValue.store);
if (false) {} // Based on the previous check, one of these must be true
const store = didStoreComeFromProps ? props.store : contextValue.store;

const getServerState = didStoreComeFromContext ?
contextValue.getServerState : store.getState;
const childPropsSelector = (0,react.useMemo)(() => {
// The child props selector needs the store reference as an input.
// Re-create this selector whenever the store changes.
return (0,selectorFactory/* default */.Z)(store.dispatch,
selectorFactoryOptions);
}, [store]);
const [subscription, notifyNestedSubs] = (0,react.useMemo)(() => {
if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; // This
Subscription's source should match where store came from: props vs. context. A
component
// connected to the store via props shouldn't use subscription from
context, or vice versa.
const subscription = createSubscription(store, didStoreComeFromProps ?

undefined : contextValue.subscription); // `notifyNestedSubs` is duplicated to
handle the case where the component is unmounted in
// the middle of the notification loop, where `subscription` will then be
null. This can
// probably be avoided if Subscription's listeners logic is changed to not
call listeners
// that have been unsubscribed in the middle of the notification loop.
const notifyNestedSubs = subscription.notifyNestedSubs.bind(subscription);

return [subscription, notifyNestedSubs];
}, [store, didStoreComeFromProps, contextValue]); // Determine what {store,
subscription} value should be put into nested context, if necessary,
// and memoize that value to avoid unnecessary context updates.
const overriddenContextValue = (0,react.useMemo)(() => {

if (didStoreComeFromProps) {
// This component is directly subscribed to a store from props.
// We don't want descendants reading from this store - pass down whatever
// the existing context value is from the nearest connected ancestor.
return contextValue;
} // Otherwise, put this component's subscription instance into context, so
that
// connected descendants won't update until after this component is done
return (0,esm_extends/* default */.Z)({}, contextValue, {

subscription
});
}, [didStoreComeFromProps, contextValue, subscription]); // Set up refs to
coordinate values between the subscription effect and the render logic
const lastChildProps = (0,react.useRef)();

const lastWrapperProps = (0,react.useRef)(wrapperProps);
const childPropsFromStoreUpdate = (0,react.useRef)();
const renderIsScheduled = (0,react.useRef)(false);
const isProcessingDispatch = (0,react.useRef)(false);
const isMounted = (0,react.useRef)(false);
const latestSubscriptionCallbackError = (0,react.useRef)();
useIsomorphicLayoutEffect(() => {
isMounted.current = true;
return () => {
isMounted.current = false;
};
}, []);
const actualChildPropsSelector = (0,react.useMemo)(() => {
const selector = () => {
// Tricky logic here:
// - This render may have been triggered by a Redux store update that
produced new child props
// - However, we may have gotten new wrapper props after that
// If we have new child props, and the same wrapper props, we know we
should use the new child props as-is.
// But, if we have new wrapper props, those might change the child props,
so we have to recalculate things.
// So, we'll use the child props from store update only if the wrapper
props are the same as last time.
if (childPropsFromStoreUpdate.current && wrapperProps ===
lastWrapperProps.current) {
return childPropsFromStoreUpdate.current;
} // TODO We're reading the store directly in render() here. Bad idea?
// This will likely cause Bad Things (TM) to happen in Concurrent Mode.
// Note that we do this because on renders _not_ caused by store updates,
we need the latest store state
// to determine what the child props should be.
return childPropsSelector(store.getState(), wrapperProps);

};
return selector;
}, [store, wrapperProps]); // We need this to execute synchronously every
time we re-render. However, React warns
// about useLayoutEffect in SSR, so we try to detect environment and fall
back to
// just useEffect instead to avoid the warning, since neither will run
anyway.
const subscribeForReact = (0,react.useMemo)(() => {

const subscribe = reactListener => {
if (!subscription) {
return () => {};
}
return subscribeUpdates(shouldHandleStateChanges, store, subscription, //

@ts-ignore
childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled,
isMounted, childPropsFromStoreUpdate, notifyNestedSubs, reactListener);
};
return subscribe;
}, [subscription]);
useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [lastWrapperProps,
lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate,
notifyNestedSubs]);
let actualChildProps;
try {
actualChildProps = connect_useSyncExternalStore( // TODO We're passing
through a big wrapper that does a bunch of extra side effects besides subscribing
subscribeForReact, // TODO This is incredibly hacky. We've already
processed the store update and calculated new child props,
// TODO and we're just passing that through so it triggers a re-render for
us rather than relying on ùSES`.
actualChildPropsSelector, getServerState ? () =>
childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector);
} catch (err) {
if (latestSubscriptionCallbackError.current) {
;
err.message += `\nThe error may be correlated with this previous error:\
n${latestSubscriptionCallbackError.current.stack}\n\n`;
}
throw err;
}
latestSubscriptionCallbackError.current = undefined;
childPropsFromStoreUpdate.current = undefined;
lastChildProps.current = actualChildProps;
}); // Now that all that's done, we can finally try to actually render the
child component.
// We memoize the elements for the rendered child component as an
optimization.
const renderedWrappedComponent = (0,react.useMemo)(() => {

return (
/*#__PURE__*/
// @ts-ignore
react.createElement(WrappedComponent, (0,esm_extends/* default */.Z)({},
actualChildProps, {
ref: reactReduxForwardedRef
}))
);
}, [reactReduxForwardedRef, WrappedComponent, actualChildProps]); // If React
sees the exact same element reference as last time, it bails out of re-rendering
// that child, same as if it was wrapped in React.memo() or returned false
from shouldComponentUpdate.
const renderedChild = (0,react.useMemo)(() => {

if (shouldHandleStateChanges) {
// If this component is subscribed to store updates, we need to pass its
own
// subscription instance down to our descendants. That means rendering
the same
// Context instance, and putting a different value into the context.
return /*#__PURE__*/react.createElement(ContextToUse.Provider, {
value: overriddenContextValue
}, renderedWrappedComponent);
}
return renderedWrappedComponent;
}, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);
return renderedChild;
}
const _Connect = react.memo(ConnectFunction);
// Add a hacky cast to get the right output type

const Connect = _Connect;
Connect.WrappedComponent = WrappedComponent;
Connect.displayName = ConnectFunction.displayName = displayName;
if (forwardRef) {
const _forwarded = react.forwardRef(function forwardConnectRef(props, ref) {
// @ts-ignore
return /*#__PURE__*/react.createElement(Connect, (0,esm_extends/* default
*/.Z)({}, props, {
reactReduxForwardedRef: ref
}));
});
const forwarded = _forwarded;

forwarded.displayName = displayName;
forwarded.WrappedComponent = WrappedComponent;
return hoist_non_react_statics_cjs_default()(forwarded, WrappedComponent);
}
return hoist_non_react_statics_cjs_default()(Connect, WrappedComponent);

};
return wrapWithConnect;
}
/* harmony default export */ const components_connect = (connect);

;// CONCATENATED MODULE: ./node_modules/react-redux/es/components/Provider.js
function Provider({
store,
context,
children,
serverState
}) {
const contextValue = (0,react.useMemo)(() => {
const subscription = createSubscription(store);
return {
store,
subscription,
getServerState: serverState ? () => serverState : undefined
};
}, [store, serverState]);
const previousState = (0,react.useMemo)(() => store.getState(), [store]);
const {
subscription
} = contextValue;
subscription.onStateChange = subscription.notifyNestedSubs;
subscription.trySubscribe();
if (previousState !== store.getState()) {

subscription.notifyNestedSubs();
}
return () => {
subscription.tryUnsubscribe();
subscription.onStateChange = undefined;
};
}, [contextValue, previousState]);
const Context = context || ReactReduxContext; // @ts-ignore 'AnyAction' is
assignable to the constraint of type 'A', but 'A' could be instantiated with a
different subtype
return /*#__PURE__*/react.createElement(Context.Provider, {
value: contextValue
}, children);
}
/* harmony default export */ const components_Provider = (Provider);

;// CONCATENATED MODULE: ./node_modules/react-redux/es/hooks/useStore.js
/**
* Hook factory, which creates a ùseStore` hook bound to a given context.
*
`<Provider>`.
* @returns {Function} A ùseStore` hook bound to the specified context.
*/
function createStoreHook(context = ReactReduxContext) {

const useReduxContext = // @ts-ignore
context === ReactReduxContext ? useReduxContext_useReduxContext : () =>
(0,react.useContext)(context);
return function useStore() {
const {
store
} = useReduxContext(); // @ts-ignore
return store;
};
}
/**
* A hook to access the redux store.
*
* @returns {any} the redux store
*
* @example
*
* import { useStore } from 'react-redux'
*
* export const ExampleComponent = () => {
* const store = useStore()
* return <div>{store.getState()}</div>
* }
*/
const useStore_useStore = /*#__PURE__*/createStoreHook();

;// CONCATENATED MODULE: ./node_modules/react-redux/es/hooks/useDispatch.js
/**
* Hook factory, which creates a ùseDispatch` hook bound to a given context.
*
`<Provider>`.
* @returns {Function} A ùseDispatch` hook bound to the specified context.
*/
function createDispatchHook(context = ReactReduxContext) {

const useStore = // @ts-ignore
context === ReactReduxContext ? useStore_useStore : createStoreHook(context);
return function useDispatch() {
const store = useStore(); // @ts-ignore
return store.dispatch;
};
}
/**
* A hook to access the redux `dispatch` function.
*
* @returns {any|function} redux store's `dispatch` function
*
* @example
*
* import React, { useCallback } from 'react'
* import { useDispatch } from 'react-redux'
*
* export const CounterComponent = ({ value }) => {
* const dispatch = useDispatch()
* const increaseCounter = useCallback(() => dispatch({ type: 'increase-
counter' }), [])
* return (
* <div>
* <span>{value}</span>
* <button onClick={increaseCounter}>Increase counter</button>
* </div>
* )
* }
*/
const useDispatch = /*#__PURE__*/createDispatchHook();

;// CONCATENATED MODULE: ./node_modules/react-redux/es/exports.js
;// CONCATENATED MODULE: ./node_modules/react-redux/es/index.js

// The primary entry point assumes we're working with standard ReactDOM/RN, but
// older versions that do not include ùseSyncExternalStore` (React 16.9 - 17.x).
// Because of that, the useSyncExternalStore compat shim is needed.
initializeUseSelector(with_selector.useSyncExternalStoreWithSelector);
initializeConnect(shim.useSyncExternalStore); // Enable batched updates in our
subscriptions for use
// with standard React renderers (ReactDOM, React Native)
(0,utils_batch/* setBatch */.F)(react_dom.unstable_batchedUpdates);
/***/ }),
/***/ 9256:
"use strict";
/* harmony export */ "F": () => (/* binding */ setBatch),
/* harmony export */ "k": () => (/* binding */ getBatch)
// Default to a dummy "batch" implementation that just runs the callback
function defaultNoopBatch(callback) {
callback();
}
let batch = (/* runtime-dependent pure expression or super */ 828 !=

__webpack_require__.j ? (defaultNoopBatch) : null); // Allow injecting another
batching function later
const setBatch = newBatch => batch = newBatch; // Supply a getter just to skip
dealing with ESM bindings
const getBatch = () => batch;
/***/ }),
/***/ 63480:
"use strict";
/* harmony export */ "Z": () => (/* binding */ bindActionCreators)
function bindActionCreators(actionCreators, dispatch) {
const boundActionCreators = {};
for (const key in actionCreators) {

const actionCreator = actionCreators[key];
if (typeof actionCreator === 'function') {

boundActionCreators[key] = (...args) => dispatch(actionCreator(...args));
}
}
return boundActionCreators;
}
/***/ }),
/***/ 35067:
"use strict";
/* harmony export */ "Z": () => (/* binding */ shallowEqual)
function is(x, y) {
if (x === y) {
return x !== 0 || y !== 0 || 1 / x === 1 / y;
} else {
return x !== x && y !== y;
}
}
function shallowEqual(objA, objB) {

if (is(objA, objB)) return true;
if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB
=== null) {
return false;
}
const keysA = Object.keys(objA);

const keysB = Object.keys(objB);
if (keysA.length !== keysB.length) return false;
for (let i = 0; i < keysA.length; i++) {

if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !
is(objA[keysA[i]], objB[keysA[i]])) {
return false;
}
}
return true;
}
/***/ }),
/***/ 76726:
"use strict";
/* harmony export */ "B": () => (/* binding */ notInitialized)
const notInitialized = () => {
throw new Error('uSES not initialized!');
};
/***/ }),
/***/ 6032:
"use strict";
// ESM COMPAT FLAG
// EXPORTS
"Modal": () => (/* binding */ Modal),
"default": () => (/* binding */ react_responsive_modal_esm)
});
// EXTERNAL MODULE: ./node_modules/react/index.js

var react = __webpack_require__(67294);
// EXTERNAL MODULE: ./node_modules/react-dom/index.js
var react_dom = __webpack_require__(73935);
// EXTERNAL MODULE: ./node_modules/classnames/index.js
var classnames = __webpack_require__(94184);
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
;// CONCATENATED MODULE: ./node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 =
Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else {
return Array.from(arr); } }
// Older browsers don't support event options, feature detect it.
// Adopted and modified solution from Bohdan Didukh (2017)

// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-
behind-a-fixed-overlay-and-maintain-scroll-posi
var hasPassiveEvents = false;

if (typeof window !== 'undefined') {
var passiveTestOptions = {
get passive() {
hasPassiveEvents = true;
return undefined;
}
};
window.addEventListener('testPassive', null, passiveTestOptions);
window.removeEventListener('testPassive', null, passiveTestOptions);
}
var isIosDevice = typeof window !== 'undefined' && window.navigator &&

window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) ||
window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);
var locks = [];

var documentListenerAdded = false;
var initialClientY = -1;
var previousBodyOverflowSetting = void 0;
var previousBodyPaddingRight = void 0;
// returns true if èl` should be allowed to receive touchmove events.

var allowTouchMove = function allowTouchMove(el) {
return locks.some(function (lock) {
if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {
return true;
}
return false;
});
};
var preventDefault = function preventDefault(rawEvent) {

var e = rawEvent || window.event;
// For the case whereby consumers adds a touchmove event listener to document.
// Recall that we do document.addEventListener('touchmove', preventDefault,
{ passive: false })
// in disableBodyScroll - so if we provide this opportunity to allowTouchMove,
then
// the touchmove event on document will break.
if (allowTouchMove(e.target)) {
return true;
}
// Do not prevent if the event has more than one touch (usually meaning this is a
multi touch gesture like pinch to zoom).
if (e.touches.length > 1) return true;
if (e.preventDefault) e.preventDefault();
return false;
};
var setOverflowHidden = function setOverflowHidden(options) {

// If previousBodyPaddingRight is already set, don't set it again.
if (previousBodyPaddingRight === undefined) {
var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;
var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;
if (_reserveScrollBarGap && scrollBarGap > 0) {

previousBodyPaddingRight = document.body.style.paddingRight;
document.body.style.paddingRight = scrollBarGap + 'px';
}
}
// If previousBodyOverflowSetting is already set, don't set it again.

if (previousBodyOverflowSetting === undefined) {
previousBodyOverflowSetting = document.body.style.overflow;
document.body.style.overflow = 'hidden';
}
};
var restoreOverflowSetting = function restoreOverflowSetting() {

if (previousBodyPaddingRight !== undefined) {
document.body.style.paddingRight = previousBodyPaddingRight;
// Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it

// can be set again.
previousBodyPaddingRight = undefined;
}
if (previousBodyOverflowSetting !== undefined) {

document.body.style.overflow = previousBodyOverflowSetting;
// Restore previousBodyOverflowSetting to undefined

// so setOverflowHidden knows it can be set again.
previousBodyOverflowSetting = undefined;
}
};
//
https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_
solutions
var isTargetElementTotallyScrolled = function
isTargetElementTotallyScrolled(targetElement) {
return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <=
targetElement.clientHeight : false;
};
var handleScroll = function handleScroll(event, targetElement) {

var clientY = event.targetTouches[0].clientY - initialClientY;
if (allowTouchMove(event.target)) {
return false;
}
if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {

// element is at the top of its scroll.
return preventDefault(event);
}
if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {

// element is at the bottom of its scroll.
return preventDefault(event);
}
return true;
};
var disableBodyScroll = function disableBodyScroll(targetElement, options) {

// targetElement must be provided
if (!targetElement) {
console.error('disableBodyScroll unsuccessful - targetElement must be provided
when calling disableBodyScroll on IOS devices.');
return;
}
// disableBodyScroll must not have been called on this targetElement before

if (locks.some(function (lock) {
return lock.targetElement === targetElement;
})) {
return;
}
var lock = {
targetElement: targetElement,
options: options || {}
};
locks = [].concat(_toConsumableArray(locks), [lock]);
if (isIosDevice) {
targetElement.ontouchstart = function (event) {
// detect single touch.
initialClientY = event.targetTouches[0].clientY;
}
};
targetElement.ontouchmove = function (event) {
// detect single touch.
handleScroll(event, targetElement);
}
};
if (!documentListenerAdded) {
document.addEventListener('touchmove', preventDefault, hasPassiveEvents ?
{ passive: false } : undefined);
documentListenerAdded = true;
}
} else {
setOverflowHidden(options);
}
};
var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {
if (isIosDevice) {
// Clear all locks ontouchstart/ontouchmove handlers, and the references.
locks.forEach(function (lock) {
lock.targetElement.ontouchstart = null;
lock.targetElement.ontouchmove = null;
});
if (documentListenerAdded) {
document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ?
documentListenerAdded = false;
}
// Reset initial clientY.

initialClientY = -1;
} else {
restoreOverflowSetting();
}
locks = [];
};
var enableBodyScroll = function enableBodyScroll(targetElement) {

if (!targetElement) {
console.error('enableBodyScroll unsuccessful - targetElement must be provided
when calling enableBodyScroll on IOS devices.');
return;
}
locks = locks.filter(function (lock) {

return lock.targetElement !== targetElement;
});
if (isIosDevice) {
targetElement.ontouchstart = null;
targetElement.ontouchmove = null;
if (documentListenerAdded && locks.length === 0) {

document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ?
documentListenerAdded = false;
}
} else if (!locks.length) {
restoreOverflowSetting();
}
};
// EXTERNAL MODULE: ./node_modules/@bedrock-layout/use-forwarded-ref/lib/index.m.js

var index_m = __webpack_require__(45722);
;// CONCATENATED MODULE: ./node_modules/react-responsive-modal/dist/react-
responsive-modal.esm.js
function _extends() {
_extends = Object.assign || function (target) {
var source = arguments[i];
for (var key in source) {

if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);

}
var CloseIcon = function CloseIcon(_ref) {

var classes = _ref.classes,
classNames = _ref.classNames,
styles = _ref.styles,
id = _ref.id,
closeIcon = _ref.closeIcon,
onClick = _ref.onClick;
return react.createElement("button", {
id: id,
className: classnames_default()(classes.closeButton, classNames == null ? void
0 : classNames.closeButton),
style: styles == null ? void 0 : styles.closeButton,
onClick: onClick,
"data-testid": "close-button"
}, closeIcon ? closeIcon : react.createElement("svg", {
className: classNames == null ? void 0 : classNames.closeIcon,
style: styles == null ? void 0 : styles.closeIcon,
width: 28,
height: 28,
viewBox: "0 0 36 36",
"data-testid": "close-icon"
}, react.createElement("path", {
d: "M28.5 9.62L26.38 7.5 18 15.88 9.62 7.5 7.5 9.62 15.88 18 7.5 26.38l2.12
2.12L18 20.12l8.38 8.38 2.12-2.12L20.12 18z"
})));
};
var isBrowser = typeof window !== 'undefined';
// https://github.com/alexandrzavalii/focus-trap-js/blob/master/src/index.js v1.1.0
var candidateSelectors = ['input', 'select', 'textarea', 'a[href]', 'button',
'[tabindex]', 'audio[controls]', 'video[controls]',
'[contenteditable]:not([contenteditable="false"])'];
function isHidden(node) {
// offsetParent being null will allow detecting cases where an element is
invisible or inside an invisible element,
// as long as the element does not use position: fixed. For them, their
visibility has to be checked directly as well.
return node.offsetParent === null || getComputedStyle(node).visibility ===
'hidden';
}
function getCheckedRadio(nodes, form) {

for (var i = 0; i < nodes.length; i++) {
if (nodes[i].checked && nodes[i].form === form) {
return nodes[i];
}
}
}
function isNotRadioOrTabbableRadio(node) {
if (node.tagName !== 'INPUT' || node.type !== 'radio' || !node.name) {
return true;
}
var radioScope = node.form || node.ownerDocument;

var radioSet = radioScope.querySelectorAll('input[type="radio"][name="' +
node.name + '"]');
var checked = getCheckedRadio(radioSet, node.form);
return checked === node || checked === undefined && radioSet[0] === node;
}
function getAllTabbingElements(parentElem) {
var currentActiveElement = document.activeElement;
var tabbableNodes = parentElem.querySelectorAll(candidateSelectors.join(','));
var onlyTabbable = [];
for (var i = 0; i < tabbableNodes.length; i++) {

var node = tabbableNodes[i];
if (currentActiveElement === node || !node.disabled && getTabindex(node) > -1

&& !isHidden(node) && isNotRadioOrTabbableRadio(node)) {
onlyTabbable.push(node);
}
}
return onlyTabbable;
}
function tabTrappingKey(event, parentElem) {
// check if current event keyCode is tab
if (!event || event.key !== 'Tab') return;
if (!parentElem || !parentElem.contains) {
if (process && "production" === 'development') {}
return false;
}
if (!parentElem.contains(event.target)) {
return false;
}
var allTabbingElements = getAllTabbingElements(parentElem);

var firstFocusableElement = allTabbingElements[0];
var lastFocusableElement = allTabbingElements[allTabbingElements.length - 1];
if (event.shiftKey && event.target === firstFocusableElement) {

lastFocusableElement.focus();
return true;
} else if (!event.shiftKey && event.target === lastFocusableElement) {
firstFocusableElement.focus();
return true;
}
return false;
}
function getTabindex(node) {
var tabindexAttr = parseInt(node.getAttribute('tabindex'), 10);
if (!isNaN(tabindexAttr)) return tabindexAttr; // Browsers do not return tabIndex
correctly for contentEditable nodes;
// so if they don't have a tabindex attribute specifically set, assume it's 0.
if (isContentEditable(node)) return 0;
return node.tabIndex;
}
function isContentEditable(node) {
return node.getAttribute('contentEditable');
}
var FocusTrap = function FocusTrap(_ref) {

var container = _ref.container,
initialFocusRef = _ref.initialFocusRef;
var refLastFocus = (0,react.useRef)();
/**
* Handle focus lock on the modal
*/
(0,react.useEffect)(function () {
var handleKeyEvent = function handleKeyEvent(event) {
if (container == null ? void 0 : container.current) {
tabTrappingKey(event, container.current);
}
};
if (isBrowser) {
document.addEventListener('keydown', handleKeyEvent);
} // On mount we focus on the first focusable element in the modal if there is
one
if (isBrowser && (container == null ? void 0 : container.current)) {

var savePreviousFocus = function savePreviousFocus() {
// First we save the last focused element
// only if it's a focusable element
if (candidateSelectors.findIndex(function (selector) {
var _document$activeEleme;
return (_document$activeEleme = document.activeElement) == null ? void

0 : _document$activeEleme.matches(selector);
}) !== -1) {
refLastFocus.current = document.activeElement;
}
};
if (initialFocusRef) {
savePreviousFocus(); // We need to schedule focusing on a next frame - this
allows to focus on the modal root
requestAnimationFrame(function () {
var _initialFocusRef$curr;
(_initialFocusRef$curr = initialFocusRef.current) == null ? void 0 :

_initialFocusRef$curr.focus();
});
} else {
var allTabbingElements = getAllTabbingElements(container.current);
if (allTabbingElements[0]) {
savePreviousFocus();
allTabbingElements[0].focus();
}
}
}
if (isBrowser) {
var _refLastFocus$current;
document.removeEventListener('keydown', handleKeyEvent); // On unmount we

restore the focus to the last focused element
(_refLastFocus$current = refLastFocus.current) == null ? void 0 :

_refLastFocus$current.focus();
}
};
}, [container, initialFocusRef]);
return null;
};
var modals = [];

/**
* Handle the order of the modals.
* Inspired by the material-ui implementation.
*/
var modalManager = {
/**
* Register a new modal
*/
add: function add(newModal) {
modals.push(newModal);
},
/**
* Remove a modal
*/
remove: function remove(oldModal) {
modals = modals.filter(function (modal) {
return modal !== oldModal;
});
},
/**
* When multiple modals are rendered will return true if current modal is the
last one
*/
isTopModal: function isTopModal(modal) {
return !!modals.length && modals[modals.length - 1] === modal;
}
};
function useModalManager(ref, open) {
if (open) {
modalManager.add(ref);
}
modalManager.remove(ref);
};
}, [open, ref]);
}
var useScrollLock = function useScrollLock(refModal, open, showPortal, blockScroll,

reserveScrollBarGap) {
var oldRef = (0,react.useRef)(null);
if (open && refModal.current && blockScroll) {
oldRef.current = refModal.current;
disableBodyScroll(refModal.current, {
reserveScrollBarGap: reserveScrollBarGap
});
}
if (oldRef.current) {
enableBodyScroll(oldRef.current);
oldRef.current = null;
}
};
}, [open, showPortal, refModal, blockScroll, reserveScrollBarGap]);
};
var classes = {
root: 'react-responsive-modal-root',
overlay: 'react-responsive-modal-overlay',
overlayAnimationIn: 'react-responsive-modal-overlay-in',
overlayAnimationOut: 'react-responsive-modal-overlay-out',
modalContainer: 'react-responsive-modal-container',
modalContainerCenter: 'react-responsive-modal-containerCenter',
modal: 'react-responsive-modal-modal',
modalAnimationIn: 'react-responsive-modal-modal-in',
modalAnimationOut: 'react-responsive-modal-modal-out',
closeButton: 'react-responsive-modal-closeButton'
};
var Modal = /*#__PURE__*/react.forwardRef(function (_ref, ref) {
var _classNames$overlayAn, _classNames$overlayAn2, _classNames$modalAnim,
_classNames$modalAnim2;
var open = _ref.open,

center = _ref.center,
_ref$blockScroll = _ref.blockScroll,
blockScroll = _ref$blockScroll === void 0 ? true : _ref$blockScroll,
_ref$closeOnEsc = _ref.closeOnEsc,
closeOnEsc = _ref$closeOnEsc === void 0 ? true : _ref$closeOnEsc,
_ref$closeOnOverlayCl = _ref.closeOnOverlayClick,
closeOnOverlayClick = _ref$closeOnOverlayCl === void 0 ? true :
_ref$closeOnOverlayCl,
container = _ref.container,
_ref$showCloseIcon = _ref.showCloseIcon,
showCloseIcon = _ref$showCloseIcon === void 0 ? true : _ref$showCloseIcon,
closeIconId = _ref.closeIconId,
closeIcon = _ref.closeIcon,
_ref$focusTrapped = _ref.focusTrapped,
focusTrapped = _ref$focusTrapped === void 0 ? true : _ref$focusTrapped,
_ref$initialFocusRef = _ref.initialFocusRef,
initialFocusRef = _ref$initialFocusRef === void 0 ? undefined :
_ref$initialFocusRef,
_ref$animationDuratio = _ref.animationDuration,
animationDuration = _ref$animationDuratio === void 0 ? 300 :
_ref$animationDuratio,
classNames = _ref.classNames,
styles = _ref.styles,
_ref$role = _ref.role,
role = _ref$role === void 0 ? 'dialog' : _ref$role,
ariaDescribedby = _ref.ariaDescribedby,
ariaLabelledby = _ref.ariaLabelledby,
modalId = _ref.modalId,
onClose = _ref.onClose,
onEscKeyDown = _ref.onEscKeyDown,
onOverlayClick = _ref.onOverlayClick,
onAnimationEnd = _ref.onAnimationEnd,
children = _ref.children,
reserveScrollBarGap = _ref.reserveScrollBarGap;
var refDialog = (0,index_m/* default */.Z)(ref);
var refModal = (0,react.useRef)(null);
var refShouldClose = (0,react.useRef)(null);
var refContainer = (0,react.useRef)(null); // Lazily create the ref instance
// https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily
if (refContainer.current === null && isBrowser) {

refContainer.current = document.createElement('div');
} // The value should be false for srr, that way when the component is hydrated
client side,
// it will match the server rendered content
var _useState = (0,react.useState)(false),

showPortal = _useState[0],
setShowPortal = _useState[1]; // Hook used to manage multiple modals opened
at the same time
useModalManager(refModal, open); // Hook used to manage the scroll
useScrollLock(refModal, open, showPortal, blockScroll, reserveScrollBarGap);
var handleOpen = function handleOpen() {

if (refContainer.current && !container && !
document.body.contains(refContainer.current)) {
document.body.appendChild(refContainer.current);
}
document.addEventListener('keydown', handleKeydown);
};
var handleClose = function handleClose() {

if (refContainer.current && !container &&
document.body.contains(refContainer.current)) {
document.body.removeChild(refContainer.current);
}
document.removeEventListener('keydown', handleKeydown);
};
var handleKeydown = function handleKeydown(event) {

// Only the last modal need to be escaped when pressing the esc key
if (event.keyCode !== 27 || !modalManager.isTopModal(refModal)) {
return;
}
onEscKeyDown == null ? void 0 : onEscKeyDown(event);
if (closeOnEsc) {
onClose();
}
};
if (showPortal) {
// When the modal is closed or removed directly, cleanup the listeners
handleClose();
}
};
}, [showPortal]);
// If the open prop is changing, we need to open the modal
// This is also called on the first render if the open prop is true when the
modal is created
if (open && !showPortal) {
setShowPortal(true);
handleOpen();
}
}, [open]);
var handleClickOverlay = function handleClickOverlay(event) {

if (refShouldClose.current === null) {
refShouldClose.current = true;
}
if (!refShouldClose.current) {
refShouldClose.current = null;
return;
}
onOverlayClick == null ? void 0 : onOverlayClick(event);
if (closeOnOverlayClick) {
onClose();
}
refShouldClose.current = null;
};
var handleModalEvent = function handleModalEvent() {

refShouldClose.current = false;
};
var handleAnimationEnd = function handleAnimationEnd() {

if (!open) {
setShowPortal(false);
}
onAnimationEnd == null ? void 0 : onAnimationEnd();

};
var containerModal = container || refContainer.current;

var overlayAnimation = open ? (_classNames$overlayAn = classNames == null ? void
0 : classNames.overlayAnimationIn) != null ? _classNames$overlayAn :
classes.overlayAnimationIn : (_classNames$overlayAn2 = classNames == null ? void
0 : classNames.overlayAnimationOut) != null ? _classNames$overlayAn2 :
classes.overlayAnimationOut;
var modalAnimation = open ? (_classNames$modalAnim = classNames == null ? void
0 : classNames.modalAnimationIn) != null ? _classNames$modalAnim :
classes.modalAnimationIn : (_classNames$modalAnim2 = classNames == null ? void 0 :
classNames.modalAnimationOut) != null ? _classNames$modalAnim2 :
classes.modalAnimationOut;
return showPortal && containerModal ?
react_dom.createPortal(react.createElement("div", {
className: classnames_default()(classes.root, classNames == null ? void 0 :
classNames.root),
style: styles == null ? void 0 : styles.root,
"data-testid": "root"
}, react.createElement("div", {
className: classnames_default()(classes.overlay, classNames == null ? void 0 :
classNames.overlay),
"data-testid": "overlay",
"aria-hidden": true,
style: _extends({
animation: overlayAnimation + " " + animationDuration + "ms"
}, styles == null ? void 0 : styles.overlay)
}), react.createElement("div", {
ref: refModal,
className: classnames_default()(classes.modalContainer, center &&
classes.modalContainerCenter, classNames == null ? void 0 :
classNames.modalContainer),
style: styles == null ? void 0 : styles.modalContainer,
"data-testid": "modal-container",
onClick: handleClickOverlay
}, react.createElement("div", {
ref: refDialog,
className: classnames_default()(classes.modal, classNames == null ? void 0 :
classNames.modal),
style: _extends({
animation: modalAnimation + " " + animationDuration + "ms"
}, styles == null ? void 0 : styles.modal),
onMouseDown: handleModalEvent,
onMouseUp: handleModalEvent,
onClick: handleModalEvent,
onAnimationEnd: handleAnimationEnd,
id: modalId,
role: role,
"aria-modal": "true",
"aria-labelledby": ariaLabelledby,
"aria-describedby": ariaDescribedby,
"data-testid": "modal",
tabIndex: -1
}, focusTrapped && react.createElement(FocusTrap, {
container: refDialog,
initialFocusRef: initialFocusRef
}), children, showCloseIcon && react.createElement(CloseIcon, {
classes: classes,
styles: styles,
closeIcon: closeIcon,
onClick: onClose,
id: closeIconId
})))), containerModal) : null;
});
/* harmony default export */ const react_responsive_modal_esm = (Modal);
//# sourceMappingURL=react-responsive-modal.esm.js.map
/***/ }),
/***/ 72408:
"use strict";
* react.production.min.js
*
*
*/
var
l=__webpack_require__(27418),n=60103,p=60106;exports.Fragment=60107;exports.StrictM
ode=60108;exports.Profiler=60114;var
q=60109,r=60110,t=60112;exports.Suspense=60113;var u=60115,v=60116;
if("function"===typeof Symbol&&Symbol.for){var
w=Symbol.for;n=w("react.element");p=w("react.portal");exports.Fragment=w("react.fra
gment");exports.StrictMode=w("react.strict_mode");exports.Profiler=w("react.profile
r");q=w("react.provider");r=w("react.context");t=w("react.forward_ref");exports.Sus
pense=w("react.suspense");u=w("react.memo");v=w("react.lazy")}var
x="function"===typeof Symbol&&Symbol.iterator;
function y(a){if(null===a||"object"!==typeof a)return null;a=x&&a[x]||
a["@@iterator"];return"function"===typeof a?a:null}function z(a){for(var
b="https://reactjs.org/docs/error-decoder.html?
invariant="+a,c=1;c<arguments.length;c+
+)b+="&args[]="+encodeURIComponent(arguments[c]);return"Minified React error
#"+a+"; visit "+b+" for the full message or use the non-minified dev environment
for full errors and additional helpful warnings."}
var A={isMounted:function(){return!1},enqueueForceUpdate:function()
{},enqueueReplaceState:function(){},enqueueSetState:function(){}},B={};function
C(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||
A}C.prototype.isReactComponent={};C.prototype.setState=function(a,b){if("object"!
==typeof a&&"function"!==typeof a&&null!=a)throw
Error(z(85));this.updater.enqueueSetState(this,a,b,"setState")};C.prototype.forceUp
date=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};
function D(){}D.prototype=C.prototype;function E(a,b,c)
{this.props=a;this.context=b;this.refs=B;this.updater=c||A}var F=E.prototype=new
D;F.constructor=E;l(F,C.prototype);F.isPureReactComponent=!0;var
G={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!
0,__source:!0};
function J(a,b,c){var e,d={},k=null,h=null;if(null!=b)for(e in void 0!
==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)H.call(b,e)&&!
I.hasOwnProperty(e)&&(d[e]=b[e]);var g=arguments.length-
2;if(1===g)d.children=c;else if(1<g){for(var f=Array(g),m=0;m<g;m+
+)f[m]=arguments[m+2];d.children=f}if(a&&a.defaultProps)for(e in
g=a.defaultProps,g)void 0===d[e]&&(d[e]=g[e]);return{$
$typeof:n,type:a,key:k,ref:h,props:d,_owner:G.current}}
function K(a,b){return{$
$typeof:n,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function L(a)
{return"object"===typeof a&&null!==a&&a.$$typeof===n}function escape(a){var
b={"=":"=0",":":"=2"};return"$"+a.replace(/[=:]/g,function(a){return b[a]})}var
M=/\/+/g;function N(a,b){return"object"===typeof a&&null!==a&&null!=a.key?
escape(""+a.key):b.toString(36)}
function O(a,b,c,e,d){var k=typeof a;if("undefined"===k||"boolean"===k)a=null;var
h=!1;if(null===a)h=!0;else switch(k){case "string":case "number":h=!0;break;case
"object":switch(a.$$typeof){case n:case p:h=!0}}if(h)return
h=a,d=d(h),a=""===e?"."+N(h,0):e,Array.isArray(d)?(c="",null!
=a&&(c=a.replace(M,"$&/")+"/"),O(d,b,c,"",function(a){return a})):null!
=d&&(L(d)&&(d=K(d,c+(!d.key||h&&h.key===d.key?"":(""+d.key).replace(M,"$&/")+"/")
+a)),b.push(d)),1;h=0;e=""===e?".":e+":";if(Array.isArray(a))for(var g=
0;g<a.length;g++){k=a[g];var f=e+N(k,g);h+=O(k,b,c,f,d)}else
if(f=y(a),"function"===typeof f)for(a=f.call(a),g=0;!
(k=a.next()).done;)k=k.value,f=e+N(k,g++),h+=O(k,b,c,f,d);else
if("object"===k)throw b=""+a,Error(z(31,"[object Object]"===b?"object with keys
{"+Object.keys(a).join(", ")+"}":b));return h}function P(a,b,c){if(null==a)return
a;var e=[],d=0;O(a,e,"","",function(a){return b.call(c,a,d++)});return e}
function Q(a){if(-1===a._status){var
b=a._result;b=b();a._status=0;a._result=b;b.then(function(b)
{0===a._status&&(b=b.default,a._status=1,a._result=b)},function(b)
{0===a._status&&(a._status=2,a._result=b)})}if(1===a._status)return a._result;throw
a._result;}var R={current:null};function S(){var a=R.current;if(null===a)throw
Error(z(321));return a}var T={ReactCurrentDispatcher:R,ReactCurrentBatchConfig:
{transition:0},ReactCurrentOwner:G,IsSomeRendererActing:{current:!1},assign:l};
exports.Children={map:P,forEach:function(a,b,c){P(a,function()
{b.apply(this,arguments)},c)},count:function(a){var b=0;P(a,function(){b++});return
b},toArray:function(a){return P(a,function(a){return a})||[]},only:function(a){if(!
L(a))throw Error(z(143));return
a}};exports.Component=C;exports.PureComponent=E;exports.__SECRET_INTERNALS_DO_NOT_U
SE_OR_YOU_WILL_BE_FIRED=T;
exports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw
Error(z(267,a));var e=l({},a.props),d=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!
==b.ref&&(k=b.ref,h=G.current);void 0!
==b.key&&(d=""+b.key);if(a.type&&a.type.defaultProps)var
g=a.type.defaultProps;for(f in b)H.call(b,f)&&!I.hasOwnProperty(f)&&(e[f]=void
0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)e.children=c;else
if(1<f){g=Array(f);for(var m=0;m<f;m++)g[m]=arguments[m+2];e.children=g}return{$
$typeof:n,type:a.type,
key:d,ref:k,props:e,_owner:h}};exports.createContext=function(a,b){void
0===b&&(b=null);a={$
$typeof:r,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,P
rovider:null,Consumer:null};a.Provider={$$typeof:q,_context:a};return
a.Consumer=a};exports.createElement=J;exports.createFactory=function(a){var
b=J.bind(null,a);b.type=a;return b};exports.createRef=function()
{return{current:null}};exports.forwardRef=function(a){return{$
$typeof:t,render:a}};exports.isValidElement=L;
exports.lazy=function(a){return{$$typeof:v,_payload:{_status:-
1,_result:a},_init:Q}};exports.memo=function(a,b){return{$
$typeof:u,type:a,compare:void 0===b?null:b}};exports.useCallback=function(a,b)
{return S().useCallback(a,b)};exports.useContext=function(a,b){return
S().useContext(a,b)};exports.useDebugValue=function()
{};exports.useEffect=function(a,b){return
S().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return
S().useImperativeHandle(a,b,c)};
exports.useLayoutEffect=function(a,b){return
S().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return
S().useMemo(a,b)};exports.useReducer=function(a,b,c){return
S().useReducer(a,b,c)};exports.useRef=function(a){return
S().useRef(a)};exports.useState=function(a){return
S().useState(a)};exports.version="17.0.2";
/***/ }),
/***/ 67294:
"use strict";
if (true) {
} else {}
/***/ }),
/***/ 94500:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
!function(e,t){ true?t(exports):0}(this,function(e){"use strict";function t(e,t)

{e.super_=t,e.prototype=Object.create(t.prototype,{constructor:
{value:e,enumerable:!1,writable:!0,configurable:!0}})}function r(e,t)
{Object.defineProperty(this,"kind",{value:e,enumerable:!
0}),t&&t.length&&Object.defineProperty(this,"path",{value:t,enumerable:!
0})}function n(e,t,r){n.super_.call(this,"E",e),Object.defineProperty(this,"lhs",
{value:t,enumerable:!0}),Object.defineProperty(this,"rhs",{value:r,enumerable:!
0})}function o(e,t){o.super_.call(this,"N",e),Object.defineProperty(this,"rhs",
{value:t,enumerable:!0})}function i(e,t)
{i.super_.call(this,"D",e),Object.defineProperty(this,"lhs",{value:t,enumerable:!
0})}function a(e,t,r){a.super_.call(this,"A",e),Object.defineProperty(this,"index",
{value:t,enumerable:!0}),Object.defineProperty(this,"item",{value:r,enumerable:!
0})}function f(e,t,r){var n=e.slice((r||t)+1||e.length);return e.length=t<0?
e.length+t:t,e.push.apply(e,n),e}function u(e){var t="undefined"==typeof
e?"undefined":N(e);return"object"!==t?
t:e===Math?"math":null===e?"null":Array.isArray(e)?"array":"[object
Date]"===Object.prototype.toString.call(e)?"date":"function"==typeof
e.toString&&/^\/.*\//.test(e.toString())?"regexp":"object"}function
l(e,t,r,c,s,d,p){s=s||[],p=p||[];var g=s.slice(0);if("undefined"!=typeof d){if(c)
{if("function"==typeof c&&c(g,d))return;if("object"===("undefined"==typeof
c?"undefined":N(c))){if(c.prefilter&&c.prefilter(g,d))return;if(c.normalize){var
h=c.normalize(g,d,e,t);h&&(e=h[0],t=h[1])}}}g.push(d)}"regexp"===u(e)&&"regexp"===u
(t)&&(e=e.toString(),t=t.toString());var y="undefined"==typeof
e?"undefined":N(e),v="undefined"==typeof t?"undefined":N(t),b="undefined"!==y||
p&&p[p.length-1].lhs&&p[p.length-1].lhs.hasOwnProperty(d),m="undefined"!==v||
p&&p[p.length-1].rhs&&p[p.length-1].rhs.hasOwnProperty(d);if(!b&&m)r(new
o(g,t));else if(!m&&b)r(new i(g,e));else if(u(e)!==u(t))r(new n(g,e,t));else
if("date"===u(e)&&e-t!==0)r(new n(g,e,t));else if("object"===y&&null!==e&&null!
==t)if(p.filter(function(t){return t.lhs===e}).length)e!==t&&r(new
n(g,e,t));else{if(p.push({lhs:e,rhs:t}),Array.isArray(e)){var
w;e.length;for(w=0;w<e.length;w++)w>=t.length?r(new a(g,w,new i(void
0,e[w]))):l(e[w],t[w],r,c,g,w,p);for(;w<t.length;)r(new a(g,w,new o(void 0,t[w+
+])))}else{var x=Object.keys(e),S=Object.keys(t);x.forEach(function(n,o){var
i=S.indexOf(n);i>=0?(l(e[n],t[n],r,c,g,n,p),S=f(S,i)):l(e[n],void
0,r,c,g,n,p)}),S.forEach(function(e){l(void 0,t[e],r,c,g,e,p)})}p.length=p.length-
1}else e!==t&&("number"===y&&isNaN(e)&&isNaN(t)||r(new n(g,e,t)))}function
c(e,t,r,n){return n=n||[],l(e,t,function(e){e&&n.push(e)},r),n.length?n:void
0}function s(e,t,r){if(r.path&&r.path.length){var n,o=e[t],i=r.path.length-
1;for(n=0;n<i;n++)o=o[r.path[n]];switch(r.kind)
{case"A":s(o[r.path[n]],r.index,r.item);break;case"D":delete
o[r.path[n]];break;case"E":case"N":o[r.path[n]]=r.rhs}}else switch(r.kind)
{case"A":s(e[t],r.index,r.item);break;case"D":e=f(e,t);break;case"E":case"N":e[t]=r
.rhs}return e}function d(e,t,r){if(e&&t&&r&&r.kind){for(var n=e,o=-1,i=r.path?
r.path.length-1:0;++o<i;)"undefined"==typeof
n[r.path[o]]&&(n[r.path[o]]="number"==typeof r.path[o]?[]:
{}),n=n[r.path[o]];switch(r.kind){case"A":s(r.path?
n[r.path[o]]:n,r.index,r.item);break;case"D":delete
n[r.path[o]];break;case"E":case"N":n[r.path[o]]=r.rhs}}}function p(e,t,r)
{if(r.path&&r.path.length){var n,o=e[t],i=r.path.length-1;for(n=0;n<i;n+
+)o=o[r.path[n]];switch(r.kind)
{case"A":p(o[r.path[n]],r.index,r.item);break;case"D":o[r.path[n]]=r.lhs;break;case
"E":o[r.path[n]]=r.lhs;break;case"N":delete o[r.path[n]]}}else switch(r.kind)
{case"A":p(e[t],r.index,r.item);break;case"D":e[t]=r.lhs;break;case"E":e[t]=r.lhs;b
reak;case"N":e=f(e,t)}return e}function g(e,t,r){if(e&&t&&r&&r.kind){var
n,o,i=e;for(o=r.path.length-1,n=0;n<o;n++)"undefined"==typeof
i[r.path[n]]&&(i[r.path[n]]={}),i=i[r.path[n]];switch(r.kind)
{case"A":p(i[r.path[n]],r.index,r.item);break;case"D":i[r.path[n]]=r.lhs;break;case
"E":i[r.path[n]]=r.lhs;break;case"N":delete i[r.path[n]]}}}function h(e,t,r)
{if(e&&t){var n=function(n){r&&!r(e,t,n)||d(e,t,n)};l(e,t,n)}}function y(e)
{return"color: "+F[e].color+"; font-weight: bold"}function v(e){var
t=e.kind,r=e.path,n=e.lhs,o=e.rhs,i=e.index,a=e.item;switch(t)
{case"E":return[r.join("."),n,"→",o];case"N":return[r.join("."),o];case"D":return[r
.join(".")];case"A":return[r.join(".")+"["+i+"]",a];default:return[]}}function
b(e,t,r,n){var o=c(e,t);try{n?r.groupCollapsed("diff"):r.group("diff")}catch(e)
{r.log("diff")}o?o.forEach(function(e){var t=e.kind,n=v(e);r.log.apply(r,["%c
"+F[t].text,y(t)].concat(P(n)))}):r.log("—— no diff ——");try{r.groupEnd()}catch(e)
{r.log("—— diff end —— ")}}function m(e,t,r,n){switch("undefined"==typeof
e?"undefined":N(e)){case"object":return"function"==typeof e[n]?
e[n].apply(e,P(r)):e[n];case"function":return e(t);default:return e}}function w(e)
{var t=e.timestamp,r=e.duration;return function(e,n,o){var i=["action"];return
i.push("%c"+String(e.type)),t&&i.push("%c@ "+n),r&&i.push("%c(in "+o.toFixed(2)+"
ms)"),i.join(" ")}}function x(e,t){var
r=t.logger,n=t.actionTransformer,o=t.titleFormatter,i=void 0===o?
w(t):o,a=t.collapsed,f=t.colors,u=t.level,l=t.diff,c="undefined"==typeof
t.titleFormatter;e.forEach(function(o,s){var
d=o.started,p=o.startedTime,g=o.action,h=o.prevState,y=o.error,v=o.took,w=o.nextSta
te,x=e[s+1];x&&(w=x.prevState,v=x.started-d);var S=n(g),k="function"==typeof a?
a(function(){return w},g,o):a,j=D(p),E=f.title?"color: "+f.title(S)
+";":"",A=["color: gray; font-weight:
lighter;"];A.push(E),t.timestamp&&A.push("color: gray; font-weight:
lighter;"),t.duration&&A.push("color: gray; font-weight: lighter;");var
O=i(S,j,v);try{k?f.title&&c?r.groupCollapsed.apply(r,["%c
"+O].concat(A)):r.groupCollapsed(O):f.title&&c?r.group.apply(r,["%c
"+O].concat(A)):r.group(O)}catch(e){r.log(O)}var N=m(u,S,[h],"prevState"),P=m(u,S,
[S],"action"),C=m(u,S,[y,h],"error"),F=m(u,S,[w],"nextState");if(N)if(f.prevState)
{var L="color: "+f.prevState(h)+"; font-weight: bold";r[N]("%c prev
state",L,h)}else r[N]("prev state",h);if(P)if(f.action){var T="color: "+f.action(S)
+"; font-weight: bold";r[P]("%c action ",T,S)}else r[P]("action
",S);if(y&&C)if(f.error){var M="color: "+f.error(y,h)+"; font-weight: bold;";r[C]
("%c error ",M,y)}else r[C]("error ",y);if(F)if(f.nextState){var _="color:
"+f.nextState(w)+"; font-weight: bold";r[F]("%c next state",_,w)}else r[F]("next
state",w);l&&b(h,w,r,k);try{r.groupEnd()}catch(e){r.log("—— log end
——")}})}function S(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:
{},t=Object.assign({},L,e),r=t.logger,n=t.stateTransformer,o=t.errorTransformer,i=t
.predicate,a=t.logErrors,f=t.diffPredicate;if("undefined"==typeof r)return
function(){return function(e){return function(t){return
e(t)}}};if(e.getState&&e.dispatch)return console.error("[redux-logger] redux-logger
not installed. Make sure to pass logger instance as middleware:\n// Logger with
default options\nimport { logger } from 'redux-logger'\nconst store = createStore(\
n reducer,\n applyMiddleware(logger)\n)\n// Or you can create your own logger
with custom options http://bit.ly/redux-logger-options\nimport createLogger from
'redux-logger'\nconst logger = createLogger({\n // ...options\n});\nconst store =
createStore(\n reducer,\n applyMiddleware(logger)\n)\n"),function(){return
function(e){return function(t){return e(t)}}};var u=[];return function(e){var
r=e.getState;return function(e){return function(l){if("function"==typeof i&&!
i(r,l))return e(l);var c={};u.push(c),c.started=O.now(),c.startedTime=new
Date,c.prevState=n(r()),c.action=l;var s=void 0;if(a)try{s=e(l)}catch(e)
{c.error=o(e)}else s=e(l);c.took=O.now()-c.started,c.nextState=n(r());var
d=t.diff&&"function"==typeof f?f(r,l):t.diff;if(x(u,Object.assign({},t,
{diff:d})),u.length=0,c.error)throw c.error;return s}}}}var k,j,E=function(e,t)
{return new Array(t+1).join(e)},A=function(e,t){return E("0",t-e.toString().length)
+e},D=function(e){return
A(e.getHours(),2)+":"+A(e.getMinutes(),2)+":"+A(e.getSeconds(),2)+"."+A(e.getMillis
econds(),3)},O="undefined"!=typeof performance&&null!
==performance&&"function"==typeof performance.now?
performance:Date,N="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?
function(e){return typeof e}:function(e){return e&&"function"==typeof
Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof
e},P=function(e){if(Array.isArray(e)){for(var t=0,r=Array(e.length);t<e.length;t+
+)r[t]=e[t];return r}return Array.from(e)},C=[];k="object"===("undefined"==typeof
__webpack_require__.g?"undefined":N(__webpack_require__.g))&&__webpack_require__.g?
__webpack_require__.g:"undefined"!=typeof window?window:
{},j=k.DeepDiff,j&&C.push(function(){"undefined"!=typeof
j&&k.DeepDiff===c&&(k.DeepDiff=j,j=void
0)}),t(n,r),t(o,r),t(i,r),t(a,r),Object.defineProperties(c,{diff:
{value:c,enumerable:!0},observableDiff:{value:l,enumerable:!0},applyDiff:
{value:h,enumerable:!0},applyChange:{value:d,enumerable:!0},revertChange:
{value:g,enumerable:!0},isConflict:{value:function(){return"undefined"!=typeof
j},enumerable:!0},noConflict:{value:function(){return C&&(C.forEach(function(e)
{e()}),C=null),c},enumerable:!0}});var F={E:{color:"#2196F3",text:"CHANGED:"},N:
{color:"#4CAF50",text:"ADDED:"},D:{color:"#F44336",text:"DELETED:"},A:
{color:"#2196F3",text:"ARRAY:"}},L={level:"log",logger:console,logErrors:!
0,collapsed:void 0,predicate:void 0,duration:!1,timestamp:!
0,stateTransformer:function(e){return e},actionTransformer:function(e){return
e},errorTransformer:function(e){return e},colors:{title:function()
{return"inherit"},prevState:function(){return"#9E9E9E"},action:function()
{return"#03A9F4"},nextState:function(){return"#4CAF50"},error:function()
{return"#F20404"}},diff:!1,diffPredicate:void 0,transformer:void 0},T=function()
{var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:
{},t=e.dispatch,r=e.getState;return"function"==typeof
t||"function"==typeof r?S()({dispatch:t,getState:r}):void console.error("\n[redux-
logger v3] BREAKING CHANGE\n[redux-logger v3] Since 3.0.0 redux-logger exports by
default logger with default settings.\n[redux-logger v3] Change\n[redux-logger v3]
import createLogger from 'redux-logger'\n[redux-logger v3] to\n[redux-logger v3]
import { createLogger } from 'redux-logger'\
n")};e.defaults=L,e.createLogger=S,e.logger=T,e.default=T,Object.defineProperty(e,"
__esModule",{value:!0})});
/***/ }),
/***/ 53894:
"use strict";
/* harmony export */ "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
/** A function that accepts a potential "extra argument" value to be injected
later,
* and returns an instance of the thunk middleware that uses that value
*/
function createThunkMiddleware(extraArgument) {
// Standard Redux middleware definition pattern:
// See: https://redux.js.org/tutorials/fundamentals/part-4-store#writing-custom-
middleware
var middleware = function middleware(_ref) {
var dispatch = _ref.dispatch,
getState = _ref.getState;
return function (next) {
// The thunk middleware looks for any functions that were passed to
`store.dispatch`.
// If this "action" is really a function, call it and return the result.
if (typeof action === 'function') {
// Inject the store's `dispatch` and `getState` methods, as well as any
"extra arg"
return action(dispatch, getState, extraArgument);
} // Otherwise, pass the action down the middleware chain as usual
return next(action);
};
};
};
return middleware;
}
var thunk = createThunkMiddleware(); // Attach the factory function so users can

create a customized version
// with whatever "extra arg" they want to inject into their thunks
thunk.withExtraArgument = createThunkMiddleware;
dependent pure expression or super */ 828 != __webpack_require__.j ? (thunk) :
null));
/***/ }),
/***/ 53697:
"use strict";
var functionsHaveConfigurableNames =
(__webpack_require__(25972).functionsHaveConfigurableNames)();
var $Object = Object;

var $TypeError = TypeError;
module.exports = function flags() {

if (this != null && this !== $Object(this)) {
throw new $TypeError('RegExp.prototype.flags getter called on non-
object');
}
var result = '';
if (this.hasIndices) {
result += 'd';
}
if (this.global) {
result += 'g';
}
if (this.ignoreCase) {
result += 'i';
}
if (this.multiline) {
result += 'm';
}
if (this.dotAll) {
result += 's';
}
if (this.unicode) {
result += 'u';
}
if (this.sticky) {
result += 'y';
}
return result;
};
if (functionsHaveConfigurableNames && Object.defineProperty) {

Object.defineProperty(module.exports, "name", ({ value: 'get flags' }));
}
/***/ }),
/***/ 2847:
"use strict";

var flagsBound = callBind(getPolyfill());
define(flagsBound, {
shim: shim
});
module.exports = flagsBound;
/***/ }),
/***/ 71721:
"use strict";
var supportsDescriptors = (__webpack_require__(4289).supportsDescriptors);

var $gOPD = Object.getOwnPropertyDescriptor;

if (supportsDescriptors && (/a/mig).flags === 'gim') {
var descriptor = $gOPD(RegExp.prototype, 'flags');
if (
descriptor
&& typeof descriptor.get === 'function'
&& typeof RegExp.prototype.dotAll === 'boolean'
&& typeof RegExp.prototype.hasIndices === 'boolean'
) {
/* eslint getter-return: 0 */
var calls = '';
var o = {};
Object.defineProperty(o, 'hasIndices', {
get: function () {
calls += 'd';
}
});
Object.defineProperty(o, 'sticky', {
get: function () {
calls += 'y';
}
});
if (calls === 'dy') {
return descriptor.get;
}
}
}
};
/***/ }),
/***/ 32753:
"use strict";
var supportsDescriptors = (__webpack_require__(4289).supportsDescriptors);

var defineProperty = Object.defineProperty;
var TypeErr = TypeError;
var getProto = Object.getPrototypeOf;
var regex = /a/;
module.exports = function shimFlags() {

if (!supportsDescriptors || !getProto) {
throw new TypeErr('RegExp.prototype.flags requires a true ES5
environment that supports property descriptors');
}
var proto = getProto(regex);
var descriptor = gOPD(proto, 'flags');
if (!descriptor || descriptor.get !== polyfill) {
defineProperty(proto, 'flags', {
configurable: true,
enumerable: false,
get: polyfill
});
}
return polyfill;
};
/***/ }),
/***/ 44815:
"use strict";
/* harmony export */ "PW": () => (/* binding */ defaultMemoize)
/* unused harmony exports defaultEqualityCheck, createCacheKeyComparator */
// Cache implementation based on Erik Rasmussen's `lru-memoize`:
// https://github.com/erikras/lru-memoize
var NOT_FOUND = 'NOT_FOUND';
function createSingletonCache(equals) {
var entry;
return {
get: function get(key) {
if (entry && equals(entry.key, key)) {
return entry.value;
}
return NOT_FOUND;
},
put: function put(key, value) {
entry = {
key: key,
value: value
};
},
getEntries: function getEntries() {
return entry ? [entry] : [];
},
clear: function clear() {
entry = undefined;
}
};
}
function createLruCache(maxSize, equals) {

var entries = [];
function get(key) {
var cacheIndex = entries.findIndex(function (entry) {
return equals(key, entry.key);
}); // We found a cached entry
if (cacheIndex > -1) {

var entry = entries[cacheIndex]; // Cached entry not at top of cache, move it
to the top
if (cacheIndex > 0) {
entries.splice(cacheIndex, 1);
entries.unshift(entry);
}
return entry.value;
} // No entry found in cache, return sentinel
return NOT_FOUND;
}
function put(key, value) {

if (get(key) === NOT_FOUND) {
// TODO Is unshift slow?
entries.unshift({
key: key,
value: value
});
if (entries.length > maxSize) {

entries.pop();
}
}
}
function getEntries() {
return entries;
}
function clear() {
entries = [];
}
return {
get: get,
put: put,
getEntries: getEntries,
clear: clear
};
}
var defaultEqualityCheck = function defaultEqualityCheck(a, b) {

return a === b;
};
function createCacheKeyComparator(equalityCheck) {
return function areArgumentsShallowlyEqual(prev, next) {
if (prev === null || next === null || prev.length !== next.length) {
return false;
} // Do this in a for loop (and not a `forEach` or an èvery`) so we can
determine equality as fast as possible.
var length = prev.length;
for (var i = 0; i < length; i++) {

if (!equalityCheck(prev[i], next[i])) {
return false;
}
}
return true;
};
}
// defaultMemoize now supports a configurable cache size with LRU behavior,
// and optional comparison of the result value with existing values
function defaultMemoize(func, equalityCheckOrOptions) {
var providedOptions = typeof equalityCheckOrOptions === 'object' ?
equalityCheckOrOptions : {
equalityCheck: equalityCheckOrOptions
};
var _providedOptions$equa = providedOptions.equalityCheck,
equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck :
_providedOptions$equa,
_providedOptions$maxS = providedOptions.maxSize,
maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS,
resultEqualityCheck = providedOptions.resultEqualityCheck;
var comparator = createCacheKeyComparator(equalityCheck);
var cache = maxSize === 1 ? createSingletonCache(comparator) :
createLruCache(maxSize, comparator); // we reference arguments instead of spreading
them for performance reasons
function memoized() {
var value = cache.get(arguments);
if (value === NOT_FOUND) {

// @ts-ignore
value = func.apply(null, arguments);
if (resultEqualityCheck) {
var entries = cache.getEntries();
var matchingEntry = entries.find(function (entry) {
return resultEqualityCheck(entry.value, value);
});
if (matchingEntry) {
value = matchingEntry.value;
}
}
cache.put(arguments, value);
}
return value;
}
memoized.clearCache = function () {
return cache.clear();
};
return memoized;
}
/***/ }),
/***/ 22222:
"use strict";
/* harmony export */ "P1": () => (/* binding */ createSelector)
/* unused harmony exports createSelectorCreator, createStructuredSelector */
/* harmony import */ var _defaultMemoize__WEBPACK_IMPORTED_MODULE_0__ =
}
function getDependencies(funcs) {
var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;
if (!dependencies.every(function (dep) {
return typeof dep === 'function';
})) {
var dependencyTypes = dependencies.map(function (dep) {
return typeof dep === 'function' ? "function " + (dep.name || 'unnamed') +
"()" : typeof dep;
}).join(', ');
throw new Error("createSelector expects all input-selectors to be functions,
but received the following types: [" + dependencyTypes + "]");
}
return dependencies;
}
function createSelectorCreator(memoize) {
for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ?
_len - 1 : 0), _key = 1; _key < _len; _key++) {
memoizeOptionsFromArgs[_key - 1] = arguments[_key];
}
var createSelector = function createSelector() {

for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 <
_len2; _key2++) {
funcs[_key2] = arguments[_key2];
}
var _recomputations = 0;
var _lastResult; // Due to the intricacies of rest params, we can't do an

optional arg after `...funcs`.
// So, start by declaring the default value here.
// (And yes, the words 'memoize' and 'options' appear too many times in this
next sequence.)
var directlyPassedOptions = {
memoizeOptions: undefined
}; // Normally, the result func or "output selector" is the last arg
var resultFunc = funcs.pop(); // If the result func is actually an _object_,

assume it's our options object
if (typeof resultFunc === 'object') {

directlyPassedOptions = resultFunc; // and pop the real result func off
resultFunc = funcs.pop();
}
if (typeof resultFunc !== 'function') {

throw new Error("createSelector expects an output function after the inputs,
but received: [" + typeof resultFunc + "]");
} // Determine which set of options we're using. Prefer options passed
directly,
// but fall back to options given to createSelectorCreator.
var _directlyPassedOption = directlyPassedOptions,

_directlyPassedOption2 = _directlyPassedOption.memoizeOptions,
memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs
: _directlyPassedOption2; // Simplifying assumption: it's unlikely that the first
options arg of the provided memoizer
// is an array. In most libs I've looked at, it's an equality function or
options object.
// Based on that, if `memoizeOptions` _is_ an array, we assume it's a full
// user-provided array of options. Otherwise, it must be just the _first_ arg,
and so
// we wrap it in an array so we can apply it.
var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions :

[memoizeOptions];
var dependencies = getDependencies(funcs);
var memoizedResultFunc = memoize.apply(void 0, [function () {
_recomputations++; // apply arguments instead of spreading for performance.
return resultFunc.apply(null, arguments);

}].concat(finalMemoizeOptions)); // If a selector is called with the exact same
arguments we don't need to traverse our dependencies again.
var selector = memoize(function () {

var params = [];
var length = dependencies.length;
for (var i = 0; i < length; i++) {

// apply arguments instead of spreading and mutate a local list of params
for performance.
// @ts-ignore
params.push(dependencies[i].apply(null, arguments));
} // apply arguments instead of spreading for performance.
_lastResult = memoizedResultFunc.apply(null, params);

return _lastResult;
});
Object.assign(selector, {
resultFunc: resultFunc,
memoizedResultFunc: memoizedResultFunc,
dependencies: dependencies,
lastResult: function lastResult() {
return _lastResult;
},
recomputations: function recomputations() {
return _recomputations;
},
resetRecomputations: function resetRecomputations() {
return _recomputations = 0;
}
});
return selector;
}; // @ts-ignore
return createSelector;
}
var createSelector = /* #__PURE__ */(/* runtime-dependent pure expression or super
*/ 828 != __webpack_require__.j ?
(createSelectorCreator(_defaultMemoize__WEBPACK_IMPORTED_MODULE_0__/
* .defaultMemoize */ .PW)) : null);
// Manual definition of state and output arguments
var createStructuredSelector = function createStructuredSelector(selectors,
selectorCreator) {
if (selectorCreator === void 0) {
selectorCreator = createSelector;
}
if (typeof selectors !== 'object') {

throw new Error('createStructuredSelector expects first argument to be an
object ' + ("where each property is a selector, instead received a " + typeof
selectors));
}
var objectKeys = Object.keys(selectors);
var resultSelector = selectorCreator( // @ts-ignore
objectKeys.map(function (key) {
return selectors[key];
}), function () {
for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3
< _len3; _key3++) {
values[_key3] = arguments[_key3];
}
return values.reduce(function (composition, value, index) {

composition[objectKeys[index]] = value;
return composition;
}, {});
});
return resultSelector;
};
/***/ }),
/***/ 60053:
"use strict";
* scheduler.production.min.js
*
*
*/
var f,g,h,k;if("object"===typeof performance&&"function"===typeof performance.now)
{var l=performance;exports.unstable_now=function(){return l.now()}}else{var
p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}
if("undefined"===typeof window||"function"!==typeof MessageChannel){var
t=null,u=null,w=function(){if(null!==t)try{var a=exports.unstable_now();t(!
0,a);t=null}catch(b){throw setTimeout(w,0),b;}};f=function(a){null!==t?
setTimeout(f,0,a):(t=a,setTimeout(w,0))};g=function(a,b)
{u=setTimeout(a,b)};h=function()
{clearTimeout(u)};exports.unstable_shouldYield=function(){return!
1};k=exports.unstable_forceFrameRate=function(){}}else{var
x=window.setTimeout,y=window.clearTimeout;if("undefined"!==typeof console){var z=
window.cancelAnimationFrame;"function"!==typeof
window.requestAnimationFrame&&console.error("This browser doesn't support
requestAnimationFrame. Make sure that you load a polyfill in older browsers.
https://reactjs.org/link/react-polyfills");"function"!==typeof
z&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that
you load a polyfill in older browsers. https://reactjs.org/link/react-
polyfills")}var A=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function()
{return exports.unstable_now()>=
E};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?
console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame
rates higher than 125 fps is not supported"):D=0<a?Math.floor(1E3/a):5};var F=new
MessageChannel,G=F.port2;F.port1.onmessage=function(){if(null!==B){var
a=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!
1,B=null)}catch(b){throw G.postMessage(null),b;}}else A=!1};f=function(a){B=a;A||
(A=!0,G.postMessage(null))};g=function(a,b){C=
x(function(){a(exports.unstable_now())},b)};h=function(){y(C);C=-1}}function H(a,b)
{var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!
==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;else break a}}function J(a){a=a[0];return void
0===a?null:a}
function K(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var
d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!
==n&&0>I(n,c))void 0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else
if(void 0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return
null}function I(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var
L=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;
function T(a){for(var b=J(M);null!==b;){if(null===b.callback)K(M);else
if(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);else
break;b=J(M)}}function U(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else{var
b=J(M);null!==b&&g(U,b.startTime-a)}}
function V(a,b){R=!1;S&&(S=!1,h());Q=!0;var c=P;try{T(b);for(O=J(L);null!==O&&(!
(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){var
d=O.callback;if("function"===typeof d){O.callback=null;P=O.priorityLevel;var
e=d(O.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?
O.callback=e:O===J(L)&&K(L);T(b)}else K(L);O=J(L)}if(null!==O)var m=!0;else{var
n=J(M);null!==n&&g(U,n.startTime-b);m=!1}return m}finally{O=null,P=c,Q=!1}}var
W=k;exports.unstable_IdlePriority=5;
exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstabl
e_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPri
ority=2;exports.unstable_cancelCallback=function(a)
{a.callback=null};exports.unstable_continueExecution=function(){R||Q||(R=!
0,f(V))};exports.unstable_getCurrentPriorityLevel=function(){return
P};exports.unstable_getFirstCallbackNode=function(){return J(L)};
exports.unstable_next=function(a){switch(P){case 1:case 2:case 3:var
b=3;break;default:b=P}var c=P;P=b;try{return
a()}finally{P=c}};exports.unstable_pauseExecution=function()
{};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b)
{switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var
c=P;P=a;try{return b()}finally{P=c}};
exports.unstable_scheduleCallback=function(a,b,c){var
d=exports.unstable_now();"object"===typeof c&&null!==c?
(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-
1;break;case 2:e=250;break;case 5:e=1073741823;break;case
4:e=1E4;break;default:e=5E3}e=c+e;a={id:N+
+,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?
(a.sortIndex=c,H(M,a),null===J(L)&&a===J(M)&&(S?h():S=!0,g(U,c-d))):
(a.sortIndex=e,H(L,a),R||Q||(R=!0,f(V)));return a};
exports.unstable_wrapCallback=function(a){var b=P;return function(){var
c=P;P=b;try{return a.apply(this,arguments)}finally{P=c}}};
/***/ }),
/***/ 63840:
"use strict";
if (true) {
} else {}
/***/ }),
/***/ 37478:
"use strict";

var inspect = __webpack_require__(70631);
var $TypeError = GetIntrinsic('%TypeError%');

var $WeakMap = GetIntrinsic('%WeakMap%', true);
var $Map = GetIntrinsic('%Map%', true);
var $weakMapGet = callBound('WeakMap.prototype.get', true);

var $weakMapSet = callBound('WeakMap.prototype.set', true);
var $weakMapHas = callBound('WeakMap.prototype.has', true);
var $mapGet = callBound('Map.prototype.get', true);
var $mapSet = callBound('Map.prototype.set', true);
var $mapHas = callBound('Map.prototype.has', true);
/*
* This function traverses the list returning the node corresponding to the
* given key.
*
* That node is also moved to the head of the list, so that if it's accessed
* again we don't need to traverse the whole list. By doing so, all the recently
* used nodes can be accessed relatively quickly.
*/
var listGetNode = function (list, key) { // eslint-disable-line consistent-return
for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
if (curr.key === key) {
prev.next = curr.next;
curr.next = list.next;
list.next = curr; // eslint-disable-line no-param-reassign
return curr;
}
}
};
var listGet = function (objects, key) {

var node = listGetNode(objects, key);
return node && node.value;
};
var listSet = function (objects, key, value) {
var node = listGetNode(objects, key);
if (node) {
node.value = value;
} else {
// Prepend the new node to the beginning of the list
objects.next = { // eslint-disable-line no-param-reassign
key: key,
next: objects.next,
value: value
};
}
};
var listHas = function (objects, key) {
return !!listGetNode(objects, key);
};
module.exports = function getSideChannel() {

var $wm;
var $m;
var $o;
var channel = {
assert: function (key) {
if (!channel.has(key)) {
throw new $TypeError('Side channel does not contain ' +
inspect(key));
}
},
get: function (key) { // eslint-disable-line consistent-return
if ($WeakMap && key && (typeof key === 'object' || typeof key ===
'function')) {
if ($wm) {
return $weakMapGet($wm, key);
}
} else if ($Map) {
if ($m) {
return $mapGet($m, key);
}
} else {
if ($o) { // eslint-disable-line no-lonely-if
return listGet($o, key);
}
}
},
has: function (key) {
'function')) {
if ($wm) {
return $weakMapHas($wm, key);
}
} else if ($Map) {
if ($m) {
return $mapHas($m, key);
}
} else {
if ($o) { // eslint-disable-line no-lonely-if
return listHas($o, key);
}
}
return false;
},
set: function (key, value) {
'function')) {
if (!$wm) {
$wm = new $WeakMap();
}
$weakMapSet($wm, key, value);
} else if ($Map) {
if (!$m) {
$m = new $Map();
}
$mapSet($m, key, value);
} else {
if (!$o) {
/*
* Initialize the linked list as an empty node, so
that we don't have
* to special-case handling of the first node: we can
always refer to
* it as (previous node).next, instead of something
like (list).head
*/
$o = { key: {}, next: null };
}
listSet($o, key, value);
}
}
};
return channel;
};
/***/ }),
/***/ 76005:
"use strict";
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__
= __webpack_require__(93379);
_default =
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_injectStylesIntoStyle
Tag_js__WEBPACK_IMPORTED_MODULE_0__);
_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1__ =
_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default =
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_styleDomAPI_js__WEBPA
CK_IMPORTED_MODULE_1__);
_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2__ =
_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default
=
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_insertBySelector_js__
WEBPACK_IMPORTED_MODULE_2__);
_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODU
LE_3__ = __webpack_require__(3565);
_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MODU
LE_3___default =
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_setAttributesWithoutA
ttributes_js__WEBPACK_IMPORTED_MODULE_3__);
_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4__ =
_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___defau
lt =
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_insertStyleElement_js
__WEBPACK_IMPORTED_MODULE_4__);
_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5__ =
_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___defaul
t =
/*#__PURE__*/__webpack_require__.n(_style_loader_dist_runtime_styleTagTransform_js_
_WEBPACK_IMPORTED_MODULE_5__);
_css_loader_dist_cjs_js_styles_css__WEBPACK_IMPORTED_MODULE_6__ =
var options = {};
options.styleTagTransform =
(_style_loader_dist_runtime_styleTagTransform_js__WEBPACK_IMPORTED_MODULE_5___defau
lt());
options.setAttributes =
(_style_loader_dist_runtime_setAttributesWithoutAttributes_js__WEBPACK_IMPORTED_MOD
ULE_3___default());
options.insert =
_style_loader_dist_runtime_insertBySelector_js__WEBPACK_IMPORTED_MODULE_2___default
().bind(null, "head");
options.domAPI =
(_style_loader_dist_runtime_styleDomAPI_js__WEBPACK_IMPORTED_MODULE_1___default());
options.insertStyleElement =
(_style_loader_dist_runtime_insertStyleElement_js__WEBPACK_IMPORTED_MODULE_4___defa
ult());
var update =
_default()(_css_loader_dist_cjs_js_styles_css__WEBPACK_IMPORTED_MODULE_6__/*
["default"] */ .Z, options);
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ =

(_css_loader_dist_cjs_js_styles_css__WEBPACK_IMPORTED_MODULE_6__/* ["default"]
*/ .Z && _css_loader_dist_cjs_js_styles_css__WEBPACK_IMPORTED_MODULE_6__/*
["default"].locals */ .Z.locals ?
_css_loader_dist_cjs_js_styles_css__WEBPACK_IMPORTED_MODULE_6__/*
["default"].locals */ .Z.locals : undefined);
/***/ }),
/***/ 93379:
/***/ ((module) => {
"use strict";
var stylesInDOM = [];
function getIndexByIdentifier(identifier) {
var result = -1;
for (var i = 0; i < stylesInDOM.length; i++) {

if (stylesInDOM[i].identifier === identifier) {
result = i;
break;
}
}
return result;
}
function modulesToDom(list, options) {

var idCountMap = {};
var identifiers = [];
for (var i = 0; i < list.length; i++) {

var item = list[i];
var id = options.base ? item[0] + options.base : item[0];
var count = idCountMap[id] || 0;
var identifier = "".concat(id, " ").concat(count);
idCountMap[id] = count + 1;
var indexByIdentifier = getIndexByIdentifier(identifier);
var obj = {
css: item[1],
media: item[2],
sourceMap: item[3],
supports: item[4],
layer: item[5]
};
if (indexByIdentifier !== -1) {

stylesInDOM[indexByIdentifier].references++;
stylesInDOM[indexByIdentifier].updater(obj);
} else {
var updater = addElementStyle(obj, options);
options.byIndex = i;
stylesInDOM.splice(i, 0, {
identifier: identifier,
updater: updater,
references: 1
});
}
identifiers.push(identifier);
}
return identifiers;
}
function addElementStyle(obj, options) {

var api = options.domAPI(options);
api.update(obj);
var updater = function updater(newObj) {

if (newObj) {
if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap
=== obj.sourceMap && newObj.supports === obj.supports && newObj.layer ===
obj.layer) {
return;
}
api.update(obj = newObj);
} else {
api.remove();
}
};
return updater;
}
module.exports = function (list, options) {

options = options || {};
list = list || [];
var lastIdentifiers = modulesToDom(list, options);
return function update(newList) {
newList = newList || [];
for (var i = 0; i < lastIdentifiers.length; i++) {

var identifier = lastIdentifiers[i];
var index = getIndexByIdentifier(identifier);
stylesInDOM[index].references--;
}
var newLastIdentifiers = modulesToDom(newList, options);
for (var _i = 0; _i < lastIdentifiers.length; _i++) {

var _identifier = lastIdentifiers[_i];
var _index = getIndexByIdentifier(_identifier);
if (stylesInDOM[_index].references === 0) {
stylesInDOM[_index].updater();
stylesInDOM.splice(_index, 1);
}
}
lastIdentifiers = newLastIdentifiers;
};
};
/***/ }),
/***/ 90569:
/***/ ((module) => {
"use strict";
var memo = {};

/* istanbul ignore next */
function getTarget(target) {
if (typeof memo[target] === "undefined") {
var styleTarget = document.querySelector(target); // Special case to return
head of iframe instead of iframe itself
if (window.HTMLIFrameElement && styleTarget instanceof

window.HTMLIFrameElement) {
try {
// This will throw an exception if access to iframe is blocked
// due to cross-origin restrictions
styleTarget = styleTarget.contentDocument.head;
} catch (e) {
// istanbul ignore next
styleTarget = null;
}
}
memo[target] = styleTarget;
}
return memo[target];
}
function insertBySelector(insert, style) {

var target = getTarget(insert);
if (!target) {
throw new Error("Couldn't find a style target. This probably means that the
value for the 'insert' parameter is invalid.");
}
target.appendChild(style);
}
module.exports = insertBySelector;
/***/ }),
/***/ 19216:
/***/ ((module) => {
"use strict";
function insertStyleElement(options) {
var element = document.createElement("style");
options.setAttributes(element, options.attributes);
options.insert(element, options.options);
return element;
}
module.exports = insertStyleElement;
/***/ }),
/***/ 3565:
"use strict";

function setAttributesWithoutAttributes(styleElement) {
var nonce = true ? __webpack_require__.nc : 0;
if (nonce) {
styleElement.setAttribute("nonce", nonce);
}
}
module.exports = setAttributesWithoutAttributes;
/***/ }),
/***/ 7795:
/***/ ((module) => {
"use strict";

function apply(styleElement, options, obj) {
var css = "";
if (obj.supports) {
css += "@supports (".concat(obj.supports, ") {");
}
if (obj.media) {
css += "@media ".concat(obj.media, " {");
}
var needLayer = typeof obj.layer !== "undefined";
if (needLayer) {
css += "@layer".concat(obj.layer.length > 0 ? " ".concat(obj.layer) : "", "
{");
}
css += obj.css;
if (needLayer) {
css += "}";
}
if (obj.media) {
css += "}";
}
if (obj.supports) {
css += "}";
}
var sourceMap = obj.sourceMap;
if (sourceMap && typeof btoa !== "undefined") {

css += "\n/*#
sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURICompo
nent(JSON.stringify(sourceMap)))), " */");
} // For old IE
/* istanbul ignore if */
options.styleTagTransform(css, styleElement, options.options);

}
function removeStyleElement(styleElement) {
// istanbul ignore if
if (styleElement.parentNode === null) {
return false;
}
styleElement.parentNode.removeChild(styleElement);
}
function domAPI(options) {
var styleElement = options.insertStyleElement(options);
return {
update: function update(obj) {
apply(styleElement, options, obj);
},
remove: function remove() {
removeStyleElement(styleElement);
}
};
}
module.exports = domAPI;
/***/ }),
/***/ 44589:
/***/ ((module) => {
"use strict";

function styleTagTransform(css, styleElement) {
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = css;
} else {
while (styleElement.firstChild) {
styleElement.removeChild(styleElement.firstChild);
}
styleElement.appendChild(document.createTextNode(css));
}
}
module.exports = styleTagTransform;
/***/ }),
/***/ 36609:
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ?

(function(o, m, k, k2) {
}
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ?
(function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
var result = {};
return result;
};
const react_1 = __importStar(__webpack_require__(67294));
const react_2 = __webpack_require__(85411);
const react_responsive_modal_1 = __webpack_require__(6032);
const types_1 = __webpack_require__(42388);
const formattingUtils_1 = __webpack_require__(43842);
const icons_1 = __webpack_require__(86968);
const gamepadConfig_1 = __webpack_require__(4053);
const formatCodeName = (code) => {
return (0, formattingUtils_1.camelToSpace)(code.replace(/^(Key|Digit)/, ''));
};
function KeybindingsForButton({ button, value, onChange, readOnly, error,
useSpacers = false }) {
const [isListening, setIsListening] = (0, react_1.useState)(false);
const keyListener = (0, react_1.useRef)(null);
const codes = (0, react_1.useMemo)(() => (!value ? [] : Array.isArray(value) ?
value : [value]), [value]);
const handleCancelListen = (0, react_1.useCallback)(() => {
setIsListening(false);
if (keyListener.current)
document.removeEventListener('keydown', keyListener.current);
}, []);
const handleContextMenu = (0, react_1.useCallback)((e) => e.preventDefault(),
[]);
const handleMouseDown = (0, react_1.useCallback)((e) => {
if (e.cancelable)
e.preventDefault();
const { button: mouseButton } = e;
if (types_1.MouseButtons[mouseButton]) {
const code = types_1.MouseButtons[mouseButton];
if (codes.indexOf(code) === -1) {
onChange === null || onChange === void 0 ? void 0 :
onChange(button, codes.concat([code]));
}
}
handleCancelListen();
return false;
}, [button, codes, handleCancelListen, onChange]);
const handleWheel = (0, react_1.useCallback)((e) => {
if (e.cancelable)
e.preventDefault();
const { deltaY } = e;
const scrollCode = deltaY < 0 ? 'ScrollUp' : 'ScrollDown';
if (codes.indexOf(scrollCode) === -1) {
onChange === null || onChange === void 0 ? void 0 : onChange(button,
codes.concat([scrollCode]));
}
}, [button, codes, handleCancelListen, onChange]);
const handleClickAdd = (0, react_1.useCallback)(() => {
if (readOnly)
return;
setIsListening(true);
keyListener.current = function onKeyDown(e) {
if (e.cancelable)
e.preventDefault();
const { code } = e;
if (code !== 'Escape' && codes.indexOf(code) === -1) {
onChange === null || onChange === void 0 ? void 0 :
onChange(button, codes.concat([code]));
}
};
document.addEventListener('keydown', keyListener.current, false);
}, [button, codes, readOnly, handleCancelListen, onChange]);
const handleRemove = (i) => {
onChange === null || onChange === void 0 ? void 0 : onChange(button,
codes.filter((_, j) => i !== j));
};
const showNoneMessage = !codes.length && readOnly;
const canAddMore = codes.length < gamepadConfig_1.MAX_BINDINGS_PER_BUTTON;
const showAddBtn = !readOnly && canAddMore;
const numSpacers = readOnly || codes.length >=
gamepadConfig_1.MAX_BINDINGS_PER_BUTTON - 1 ? 0 : 1;
const spacers = !useSpacers || showNoneMessage ? [] : new
Array(numSpacers).fill(' ');
const modal = (react_1.default.createElement(react_responsive_modal_1.Modal,
{ center: true, open: isListening, onClose: handleCancelListen, showCloseIcon:
false, focusTrapped: true, closeOnEsc: false },
react_1.default.createElement("div", { className: "vertical centered
unselectable", style: { width: '60vw', height: '50vh', padding: 20 }, onMouseDown:
isListening ? handleMouseDown : undefined, onContextMenu: handleContextMenu,
onWheel: isListening ? handleWheel : undefined },
react_1.default.createElement("h3", null, "Press any key or click to
bind..."),
react_1.default.createElement("p", null, "(Press Esc to cancel)"))));
const errorNotice = error ? (react_1.default.createElement(react_2.TooltipHost,
{ content: error, id: `keybind-error-tooltip-${button}`, directionalHint:
react_2.DirectionalHint.rightCenter },
react_1.default.createElement(icons_1.ExclamationCircle, { className:
"error margin-left-s" }))) : null;
let buttonFriendly = (0, formattingUtils_1.camelToSpace)(button);
if (buttonFriendly.indexOf(' ') === -1) {
buttonFriendly = buttonFriendly + ' Button';
}
return (react_1.default.createElement("tr", null,
react_1.default.createElement("th", null,
buttonFriendly,
modal,
errorNotice),
showNoneMessage ? (react_1.default.createElement("td", { className: "none",
colSpan: 3 }, "No bindings for button")) : null,
codes.map((code, i) => (react_1.default.createElement("td", { key: code },
react_1.default.createElement("div", null,
react_1.default.createElement("span", null, formatCodeName(code)),
readOnly ? null :
(react_1.default.createElement(react_2.IconButton, { className: "error-bg delete-
icon", size: 18, iconProps: { iconName: 'BoxMultiplySolid', className: 'error' },
title: "Remove binding", disabled: isListening, onClick: () =>
handleRemove(i) })))))),
showAddBtn ? (react_1.default.createElement("td", null,
react_1.default.createElement(react_2.IconButton, { iconProps:
{ iconName: 'Add' }, title: "Add binding", size: 18, disabled: isListening,
onClick: handleClickAdd }))) : null,
spacers.map((_, i) => (react_1.default.createElement("td", { className:
"empty", key: `s${i}` },
react_1.default.createElement("div", null, "Empty Binding"))))));
}
exports["default"] = (0, react_1.memo)(KeybindingsForButton);
/***/ }),
/***/ 72208:
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
const react_1 = __importDefault(__webpack_require__(67294));
const gamepadConfig_1 = __webpack_require__(4053);
const KeybindingsForButton_1 = __importDefault(__webpack_require__(36609));
function KeybindingsTable({ className, gamepadConfig, errors, isEditing,
onKeybindChange, hideMissing, }) {
let keys = Object.keys(gamepadConfig_1.emptyGamepadConfig.keyConfig);
if (hideMissing) {
keys = keys.filter((key) => { var _a; return !!((_a =
gamepadConfig.keyConfig[key]) === null || _a === void 0 ? void 0 : _a.length); });
}
return (react_1.default.createElement("table", { className: className },
react_1.default.createElement("tbody", null, keys.map((button) => {
const val = gamepadConfig.keyConfig[button];
return (react_1.default.createElement(KeybindingsForButton_1.default, {
key: button.toString(), useSpacers: true, button: button, readOnly: !isEditing,
value: val, onChange: onKeybindChange, error: errors === null || errors === void
0 ? void 0 : errors.keyConfig[button] }));
}))));
}
exports["default"] = KeybindingsTable;
/***/ }),
/***/ 86968:
"use strict";
// All Icons from Font Awesome Pro 5.15.4 by @fontawesome - https://fontawesome.com

// License - https://fontawesome.com/license (Commercial License)
var __createBinding = (this && this.__createBinding) || (Object.create ?
(function(o, m, k, k2) {
}
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ?
(function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
var result = {};
return result;
};
exports.Wrench = exports.ExclamationCircle = exports.ChevronRightIcon =
exports.ChevronLeftIcon = exports.PlusCircleIcon = void 0;
/* eslint-disable max-len */
// Generated via https://react-svgr.com/playground/?
icon=true&memo=true&prettierConfig=%7B%0A%20%20%22semi%22%3A%20true%0A
%7D&typescript=true
const react_1 = __importStar(__webpack_require__(67294));
exports.PlusCircleIcon = (0, react_1.memo)(function PlusCircleIcon(props) {
return (react_1.default.createElement("svg", Object.assign({ xmlns:
"http://www.w3.org/2000/svg", viewBox: "0 0 512 512", width: "1em", height:
"1em" }, props),
react_1.default.createElement("path", { d: "M256 8C119 8 8 119 8 256s111
248 248 248 248-111 248-248S393 8 256 8zm144 276c0 6.6-5.4 12-12 12h-92v92c0 6.6-
5.4 12-12 12h-56c-6.6 0-12-5.4-12-12v-92h-92c-6.6 0-12-5.4-12-12v-56c0-6.6 5.4-12
12-12h92v-92c0-6.6 5.4-12 12-12h56c6.6 0 12 5.4 12 12v92h92c6.6 0 12 5.4 12 12v56z"
})));
});
exports.ChevronLeftIcon = (0, react_1.memo)(function ChevronLeftIcon(props) {
"1em" }, props),
react_1.default.createElement("path", { d: "M231.293 473.899l19.799-
19.799c4.686-4.686 4.686-12.284 0-16.971L70.393 256 251.092 74.87c4.686-4.686
4.686-12.284 0-16.971L231.293 38.1c-4.686-4.686-12.284-4.686-16.971 0L4.908
247.515c-4.686 4.686-4.686 12.284 0 16.971L214.322 473.9c4.687 4.686 12.285 4.686
16.971-.001z" })));
});
exports.ChevronRightIcon = (0, react_1.memo)(function ChevronRightIcon(props) {
"1em" }, props),
react_1.default.createElement("path", { d: "M24.707 38.101L4.908 57.899c-
4.686 4.686-4.686 12.284 0 16.971L185.607 256 4.908 437.13c-4.686 4.686-4.686
12.284 0 16.971L24.707 473.9c4.686 4.686 12.284 4.686 16.971 0l209.414-
209.414c4.686-4.686 4.686-12.284 0-16.971L41.678 38.101c-4.687-4.687-12.285-4.687-
16.971 0z" })));
});
exports.ExclamationCircle = (0, react_1.memo)(function ExclamationCircle(props) {
"1em" }, props),
react_1.default.createElement("path", { d: "M504 256c0 136.997-111.043 248-
248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-
25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-
165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982
11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-
12.356 5.78-11.981 12.654z" })));
});
exports.Wrench = (0, react_1.memo)(function Wrench(props) {
"1em" }, props),
react_1.default.createElement("path", { d: "M507.73 109.1c-2.24-9.03-13.54-
12.09-20.12-5.51l-74.36 74.36-67.88-11.31-11.31-67.88 74.36-74.36c6.62-6.62 3.43-
17.9-5.66-20.16-47.38-11.74-99.55.91-136.58 37.93-39.64 39.64-50.55 97.1-34.05
147.2L18.74 402.76c-24.99 24.99-24.99 65.51 0 90.5 24.99 24.99 65.51 24.99 90.5
0l213.21-213.21c50.12 16.71 107.47 5.68 147.37-34.22 37.07-37.07 49.7-89.32 37.91-
136.73zM64 472c-13.25 0-24-10.75-24-24 0-13.26 10.75-24 24-24s24 10.74 24 24c0
13.25-10.75 24-24 24z" })));
});
/***/ }),
/***/ 53201:
"use strict";

exports.defaultPrefs = void 0;
exports.defaultPrefs = { showControlsOverlay: false };
/***/ }),
/***/ 43842:
"use strict";

exports.camelToSpace = void 0;
function camelToSpace(str) {
const cleanedUp = str.replace(/([a-z|0-9])([A-Z])/g, '$1 $2');
return cleanedUp.charAt(0).toUpperCase() + cleanedUp.slice(1);
}
exports.camelToSpace = camelToSpace;
/***/ }),
/***/ 4053:
"use strict";

exports.emptyGamepadConfig = exports.defaultGamepadConfig =
exports.isGamepadConfigValid = exports.validateMouseConfig =
exports.processGamepadConfig = exports.upgradeOldGamepadConfig =
exports.isButtonMapping = exports.MAX_BINDINGS_PER_BUTTON =
exports.DEFAULT_SENSITIVITY = exports.MAX_NUM_CONFIGS = exports.DEFAULT_CONFIG_NAME
= void 0;
const formattingUtils_1 = __webpack_require__(43842);
exports.DEFAULT_CONFIG_NAME = 'default';
exports.MAX_NUM_CONFIGS = 25;
exports.DEFAULT_SENSITIVITY = 10;
exports.MAX_BINDINGS_PER_BUTTON = 2; // TODO do people want/need tripple keybinds?
const buttonToGamepadIndex = {
a: 0,
b: 1,
x: 2,
y: 3,
leftShoulder: 4,
rightShoulder: 5,
leftTrigger: 6,
rightTrigger: 7,
select: 8,
start: 9,
leftStickPressed: 10,
rightStickPressed: 11,
dpadUp: 12,
dpadDown: 13,
dpadLeft: 14,
dpadRight: 15,
home: 16,
};
const buttonToAxisIndex = (button) => {
return button[0] === 'l' ? 0 : 1;
};
const buttonToAxisDirection = (button) => {
return button.replace(/^(left|right)Stick/, '')[0].toLowerCase();
};
const isButtonMapping = (mapping) => {
return mapping.gamepadIndex !== undefined;
};
exports.isButtonMapping = isButtonMapping;
// Modifies a gamepad config in-place to convert old schemas
function upgradeOldGamepadConfig(config) {
const { keyConfig } = config;
Object.keys(keyConfig).forEach((button) => {
const keyMap = keyConfig[button];
if (!keyMap) {
return;
}
const codes = (!Array.isArray(keyMap) ? [keyMap] : keyMap).flatMap((code)
=> {
// Expand any special code into a group of codes (e.g. 'Scroll' ->
['ScrollUp', 'ScrollDown'])
if (code === 'Scroll') {
return ['ScrollUp', 'ScrollDown'];
}
return code;
});
keyConfig[button] = codes;
});
}
exports.upgradeOldGamepadConfig = upgradeOldGamepadConfig;
function processGamepadConfig(config) {
// Validate a given code has only one button
// and normalize from code to buttons array
const codeMapping = {};
const invalidButtons = {};
Object.keys(config).forEach((button) => {
const keyMap = config[button];
if (!keyMap) {
return;
}
const codes = !Array.isArray(keyMap) ? [keyMap] : keyMap;
// Technically we allow importing configs with more than
MAX_BINDINGS_PER_BUTTON, but it is not possible
// in the UI. We could validate it here if we want to be more strict.
// if (codes.length > MAX_BINDINGS_PER_BUTTON) {
// invalidButtons[button] = Ònly ${MAX_BINDINGS_PER_BUTTON} bindings per
button is allowed`;
// return;
// }
for (const code of codes) {
if (code === 'Escape') {
invalidButtons[button] = 'Binding Escape key is not allowed';
continue;
}
if (codeMapping[code]) {
invalidButtons[button] = `'${code}' is already bound to button '$
{(0, formattingUtils_1.camelToSpace)(codeMapping[code].button)}'`;
continue;
}
const gamepadIndex = buttonToGamepadIndex[button];
if (gamepadIndex !== undefined) {
codeMapping[code] = { button, gamepadIndex };
}
else {
const axisIndex = buttonToAxisIndex(button);
const axisDirection = buttonToAxisDirection(button);
codeMapping[code] = { button, axisIndex, axisDirection };
}
}
});
return { codeMapping, invalidButtons, hasErrors:
Object.keys(invalidButtons).length > 0 };
}
exports.processGamepadConfig = processGamepadConfig;
function validateMouseConfig(mouseConfig) {
const { sensitivity, mouseControls } = mouseConfig;
const errors = {};
if (mouseControls !== undefined && mouseControls !== 0 && mouseControls !== 1)
{
errors.mouseControls = 'Invalid stick number';
}
if (sensitivity < 1 || sensitivity > 1000) {
errors.mouseControls = 'Invalid sensitivity value. Must be between 1 and
1000.';
}
return { errors, hasErrors: Object.keys(errors).length > 0 };
}
exports.validateMouseConfig = validateMouseConfig;
function isGamepadConfigValid(gamepadConfig) {
try {
const { hasErrors: mouseErrors } =
validateMouseConfig(gamepadConfig.mouseConfig);
if (mouseErrors) {
return false;
}
const { hasErrors: buttonErrors } =
processGamepadConfig(gamepadConfig.keyConfig);
return !buttonErrors;
}
catch (e) {
return false;
}
}
exports.isGamepadConfigValid = isGamepadConfigValid;
exports.defaultGamepadConfig = {
mouseConfig: {
mouseControls: 1,
sensitivity: exports.DEFAULT_SENSITIVITY,
},
// Find "event.code" from https://keycode.info/
keyConfig: {
a: 'Space',
b: ['ControlLeft', 'Backspace'],
x: 'KeyR',
y: ['ScrollUp', 'ScrollDown'],
leftShoulder: ['KeyC', 'KeyG'],
leftTrigger: 'RightClick',
rightShoulder: 'KeyQ',
rightTrigger: 'Click',
start: 'Enter',
select: 'Tab',
home: undefined,
dpadUp: ['ArrowUp', 'KeyX'],
dpadLeft: ['ArrowLeft', 'KeyN'],
dpadDown: ['ArrowDown', 'KeyZ'],
dpadRight: 'ArrowRight',
leftStickUp: 'KeyW',
leftStickLeft: 'KeyA',
leftStickDown: 'KeyS',
leftStickRight: 'KeyD',
rightStickUp: 'KeyO',
rightStickLeft: 'KeyK',
rightStickDown: 'KeyL',
rightStickRight: 'Semicolon',
leftStickPressed: 'ShiftLeft',
rightStickPressed: 'KeyF',
},
};
exports.emptyGamepadConfig = {
mouseConfig: {
mouseControls: undefined,
sensitivity: exports.DEFAULT_SENSITIVITY,
},
keyConfig:
Object.keys(exports.defaultGamepadConfig.keyConfig).reduce((keyConfig, key) => {
keyConfig[key] = undefined;
return keyConfig;
}, {}),
};
/***/ }),
/***/ 28724:
"use strict";

exports.closeWindowMsg = exports.updatePrefsMsg = exports.disableGamepadMsg =
exports.activateGamepadConfigMsg = exports.initializeResponseMsg =
exports.seenOnboardingMsg = exports.gameChangedMsg = exports.intializedMsg =
exports.injectedMsg = exports.MessageTypes = void 0;
var MessageTypes;
(function (MessageTypes) {
MessageTypes["INJECTED"] = "INJECTED";
MessageTypes["INITIALIZED"] = "INITIALIZED";
MessageTypes["GAME_CHANGED"] = "GAME_CHANGED";
MessageTypes["ACTIVATE_GAMEPAD_CONFIG"] = "ACTIVATE_GAMEPAD_CONFIG";
MessageTypes["INITIALIZE_RESPONSE"] = "INITIALIZE_RESPONSE";
MessageTypes["SEEN_ONBOARDING"] = "SEEN_ONBOARDING";
MessageTypes["UPDATE_PREFS"] = "UPDATE_PREFS";
MessageTypes["CLOSE_WINDOW"] = "CLOSE_WINDOW";
})(MessageTypes = exports.MessageTypes || (exports.MessageTypes = {}));
// Sent from page to background to enable the context button in the toolbar
function injectedMsg() {
return { type: MessageTypes.INJECTED };
}
exports.injectedMsg = injectedMsg;
// Sent from page to background to load all settings
function intializedMsg(gameName) {
return { type: MessageTypes.INITIALIZED, gameName };
}
exports.intializedMsg = intializedMsg;
// Sent from page to background to set game name manually
function gameChangedMsg(gameName) {
return { type: MessageTypes.GAME_CHANGED, gameName };
}
exports.gameChangedMsg = gameChangedMsg;
// Sent from the page to background to note the user has seen the onboarding
function seenOnboardingMsg(seen = true) {
return { type: MessageTypes.SEEN_ONBOARDING, seen };
}
exports.seenOnboardingMsg = seenOnboardingMsg;
// Sent from background to page for user's first time using the extension
function initializeResponseMsg(name, gamepadConfig, seenOnboarding, prefs) {
return { type: MessageTypes.INITIALIZE_RESPONSE, name, gamepadConfig,
seenOnboarding, prefs };
}
exports.initializeResponseMsg = initializeResponseMsg;
// Sent from background to page to set active mouse+keyboard config (null for
disabled)
function activateGamepadConfigMsg(name, gamepadConfig) {
return { type: MessageTypes.ACTIVATE_GAMEPAD_CONFIG, name, gamepadConfig };
}
exports.activateGamepadConfigMsg = activateGamepadConfigMsg;
function disableGamepadMsg() {
return activateGamepadConfigMsg(null, null);
}
exports.disableGamepadMsg = disableGamepadMsg;
// Sent from the background to page when preferences are updated that would impact
it
function updatePrefsMsg(prefs) {
return { type: MessageTypes.UPDATE_PREFS, prefs };
}
exports.updatePrefsMsg = updatePrefsMsg;
// Sent from the background to popup to close
function closeWindowMsg() {
return { type: MessageTypes.CLOSE_WINDOW };
}
exports.closeWindowMsg = closeWindowMsg;
/***/ }),
/***/ 44660:
"use strict";

exports.getInjectedImagePath = exports.injectImagePaths = exports.injectCssFile =
exports.injectInitialScriptFile = void 0;
const META_IMAGE_PATHS = 'xmc-extension-image-paths';
// Chrome extensions can run content scripts "in the page", but they
// are sandboxed to an 'isolated world', so all variables/window/etc.
// are isolated from the page.
// The only shared thing between the two is the DOM.
// https://developer.chrome.com/docs/extensions/mv3/content_scripts/#isolated_world
function injectInitialScriptFile(file) {
// Runs a script file without Chrome extension content scripts sandboxing
const s = document.createElement('script');
s.setAttribute('type', 'text/javascript');
s.setAttribute('src', file);
s.async = false;
// https://stackoverflow.com/a/28188390/2359478
document.documentElement.appendChild(s);
}
exports.injectInitialScriptFile = injectInitialScriptFile;
function injectCssFile(file) {
const css = document.createElement('link');
css.rel = 'stylesheet';
css.href = file;
document.head.appendChild(css);
}
exports.injectCssFile = injectCssFile;
function injectImagePaths(files) {
const meta = document.createElement('meta');
meta.name = META_IMAGE_PATHS;
meta.content = files.join(',');
document.head.appendChild(meta);
}
exports.injectImagePaths = injectImagePaths;
let imagePaths;
function getInjectedImagePaths() {
if (imagePaths)
return imagePaths;
const meta = document.head.querySelector(`meta[name=${META_IMAGE_PATHS}]`);
if (meta) {
const content = meta.getAttribute('content');
if (content) {
const vals = content.split(',');
imagePaths = vals.reduce((acc, val) => {
const exec = /[^/]*$/.exec(val);
const fileName = exec && exec[0];
if (fileName) {
acc[fileName] = val;
}
return acc;
}, {});
}
}
else {
return {};
}
return imagePaths;
}
function getInjectedImagePath(path) {
return getInjectedImagePaths()[path] || '';
}
exports.getInjectedImagePath = getInjectedImagePath;
/***/ }),
/***/ 42388:
"use strict";

exports.getAllEnumKeys = exports.MouseButtons = exports.Direction = void 0;
var Direction;
(function (Direction) {
Direction["UP"] = "u";
Direction["DOWN"] = "d";
Direction["LEFT"] = "l";
Direction["RIGHT"] = "r";
})(Direction = exports.Direction || (exports.Direction = {}));
// The enum number maps to MouseEvent.button
// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button#value
var MouseButtons;
(function (MouseButtons) {
MouseButtons[MouseButtons["Click"] = 0] = "Click";
MouseButtons[MouseButtons["MiddleClick"] = 1] = "MiddleClick";
MouseButtons[MouseButtons["RightClick"] = 2] = "RightClick";
MouseButtons[MouseButtons["Aux4Click"] = 3] = "Aux4Click";
MouseButtons[MouseButtons["Aux5Click"] = 4] = "Aux5Click";
})(MouseButtons = exports.MouseButtons || (exports.MouseButtons = {}));
function getAllEnumKeys(someEnum) {
// https://www.crojach.com/blog/2019/2/6/getting-enum-keys-in-typescript
return Object.keys(someEnum).filter((key) => typeof key === 'string');
}
exports.getAllEnumKeys = getAllEnumKeys;
/***/ }),
/***/ 53250:
"use strict";
/**
* @license React
* use-sync-external-store-shim.production.min.js
*
*
*/
var e=__webpack_require__(67294);function h(a,b){return a===b&&(0!==a||1/a===1/b)||
a!==a&&b!==b}var k="function"===typeof Object.is?
Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;functi
on q(a,b){var d=b(),f=l({inst:
{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function()
{c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function()
{r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}
function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f)
{return!0}}function t(a,b){return b()}var u="undefined"===typeof
window||"undefined"===typeof window.document||"undefined"===typeof
window.document.createElement?t:q;exports.useSyncExternalStore=void 0!
==e.useSyncExternalStore?e.useSyncExternalStore:u;
/***/ }),
/***/ 50139:
"use strict";
/**
* @license React
* use-sync-external-store-shim/with-selector.production.min.js
*
*
*/
var h=__webpack_require__(67294),n=__webpack_require__(61688);function p(a,b)
{return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q="function"===typeof
Object.is?
Object.is:p,r=n.useSyncExternalStore,t=h.useRef,u=h.useEffect,v=h.useMemo,w=h.useDe
bugValue;
exports.useSyncExternalStoreWithSelector=function(a,b,e,l,g){var
c=t(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else
f=c.current;c=v(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!
==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q(d,a))return
b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void
0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return
a(m())}]},[b,e,l,g]);var d=r(a,c[0],c[1]);
u(function(){f.hasValue=!0;f.value=d},[d]);w(d);return d};
/***/ }),
/***/ 61688:
"use strict";
if (true) {
} else {}
/***/ }),
/***/ 52798:
"use strict";
if (true) {
} else {}
/***/ }),
/***/ 93150:
/***/ (function(module, exports) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__,

__WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {
if (true) {
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [module], __WEBPACK_AMD_DEFINE_FACTORY__ =
(factory),
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__
=== 'function' ?
(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports,
__WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports =
__WEBPACK_AMD_DEFINE_RESULT__));
} else { var mod; }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ?
self : this, function (module) {
/* webextension-polyfill - v0.7.0 - Tue Nov 10 2020 20:24:04 */
/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
if (typeof browser === "undefined" || Object.getPrototypeOf(browser) !==

Object.prototype) {
const CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE = "The message port
closed before a response was received.";
const SEND_RESPONSE_DEPRECATION_WARNING = "Returning a Promise is the preferred
way to send a reply from an onMessage/onMessageExternal listener, as the
sendResponse will be removed from the specs (See
https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/runtime/
onMessage)"; // Wrapping the bulk of this polyfill in a one-time-use function is a
minor
// optimization for Firefox. Since Spidermonkey does not fully parse the
// contents of a function until the first time it's called, and since it will
// never actually need to be called, this allows the polyfill to be included
// in Firefox nearly for free.
const wrapAPIs = extensionAPIs => {

// NOTE: apiMetadata is associated to the content of the api-metadata.json
file
// at build time by replacing the following "include" with the content of the
// JSON file.
const apiMetadata = {
"alarms": {
"clear": {
"minArgs": 0,
"maxArgs": 1
},
"clearAll": {
"minArgs": 0,
"maxArgs": 0
},
"get": {
"minArgs": 0,
"maxArgs": 1
},
"getAll": {
"minArgs": 0,
"maxArgs": 0
}
},
"bookmarks": {
"create": {
"minArgs": 1,
"maxArgs": 1
},
"get": {
"minArgs": 1,
"maxArgs": 1
},
"getChildren": {
"minArgs": 1,
"maxArgs": 1
},
"getRecent": {
"minArgs": 1,
"maxArgs": 1
},
"getSubTree": {
"minArgs": 1,
"maxArgs": 1
},
"getTree": {
"minArgs": 0,
"maxArgs": 0
},
"move": {
"minArgs": 2,
"maxArgs": 2
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"removeTree": {
"minArgs": 1,
"maxArgs": 1
},
"search": {
"minArgs": 1,
"maxArgs": 1
},
"update": {
"minArgs": 2,
"maxArgs": 2
}
},
"browserAction": {
"disable": {
"minArgs": 0,
"maxArgs": 1,
"fallbackToNoCallback": true
},
"enable": {
"minArgs": 0,
"maxArgs": 1,
},
"getBadgeBackgroundColor": {
"minArgs": 1,
"maxArgs": 1
},
"getBadgeText": {
"minArgs": 1,
"maxArgs": 1
},
"getPopup": {
"minArgs": 1,
"maxArgs": 1
},
"getTitle": {
"minArgs": 1,
"maxArgs": 1
},
"openPopup": {
"minArgs": 0,
"maxArgs": 0
},
"setBadgeBackgroundColor": {
"minArgs": 1,
"maxArgs": 1,
},
"setBadgeText": {
"minArgs": 1,
"maxArgs": 1,
},
"setIcon": {
"minArgs": 1,
"maxArgs": 1
},
"setPopup": {
"minArgs": 1,
"maxArgs": 1,
},
"setTitle": {
"minArgs": 1,
"maxArgs": 1,
}
},
"browsingData": {
"remove": {
"minArgs": 2,
"maxArgs": 2
},
"removeCache": {
"minArgs": 1,
"maxArgs": 1
},
"removeCookies": {
"minArgs": 1,
"maxArgs": 1
},
"removeDownloads": {
"minArgs": 1,
"maxArgs": 1
},
"removeFormData": {
"minArgs": 1,
"maxArgs": 1
},
"removeHistory": {
"minArgs": 1,
"maxArgs": 1
},
"removeLocalStorage": {
"minArgs": 1,
"maxArgs": 1
},
"removePasswords": {
"minArgs": 1,
"maxArgs": 1
},
"removePluginData": {
"minArgs": 1,
"maxArgs": 1
},
"settings": {
"minArgs": 0,
"maxArgs": 0
}
},
"commands": {
"getAll": {
"minArgs": 0,
"maxArgs": 0
}
},
"contextMenus": {
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"removeAll": {
"minArgs": 0,
"maxArgs": 0
},
"update": {
"minArgs": 2,
"maxArgs": 2
}
},
"cookies": {
"get": {
"minArgs": 1,
"maxArgs": 1
},
"getAll": {
"minArgs": 1,
"maxArgs": 1
},
"getAllCookieStores": {
"minArgs": 0,
"maxArgs": 0
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"set": {
"minArgs": 1,
"maxArgs": 1
}
},
"devtools": {
"inspectedWindow": {
"eval": {
"minArgs": 1,
"maxArgs": 2,
"singleCallbackArg": false
}
},
"panels": {
"create": {
"minArgs": 3,
"maxArgs": 3,
"singleCallbackArg": true
},
"elements": {
"createSidebarPane": {
"minArgs": 1,
"maxArgs": 1
}
}
}
},
"downloads": {
"cancel": {
"minArgs": 1,
"maxArgs": 1
},
"download": {
"minArgs": 1,
"maxArgs": 1
},
"erase": {
"minArgs": 1,
"maxArgs": 1
},
"getFileIcon": {
"minArgs": 1,
"maxArgs": 2
},
"open": {
"minArgs": 1,
"maxArgs": 1,
},
"pause": {
"minArgs": 1,
"maxArgs": 1
},
"removeFile": {
"minArgs": 1,
"maxArgs": 1
},
"resume": {
"minArgs": 1,
"maxArgs": 1
},
"search": {
"minArgs": 1,
"maxArgs": 1
},
"show": {
"minArgs": 1,
"maxArgs": 1,
}
},
"extension": {
"isAllowedFileSchemeAccess": {
"minArgs": 0,
"maxArgs": 0
},
"isAllowedIncognitoAccess": {
"minArgs": 0,
"maxArgs": 0
}
},
"history": {
"addUrl": {
"minArgs": 1,
"maxArgs": 1
},
"deleteAll": {
"minArgs": 0,
"maxArgs": 0
},
"deleteRange": {
"minArgs": 1,
"maxArgs": 1
},
"deleteUrl": {
"minArgs": 1,
"maxArgs": 1
},
"getVisits": {
"minArgs": 1,
"maxArgs": 1
},
"search": {
"minArgs": 1,
"maxArgs": 1
}
},
"i18n": {
"detectLanguage": {
"minArgs": 1,
"maxArgs": 1
},
"getAcceptLanguages": {
"minArgs": 0,
"maxArgs": 0
}
},
"identity": {
"launchWebAuthFlow": {
"minArgs": 1,
"maxArgs": 1
}
},
"idle": {
"queryState": {
"minArgs": 1,
"maxArgs": 1
}
},
"management": {
"get": {
"minArgs": 1,
"maxArgs": 1
},
"getAll": {
"minArgs": 0,
"maxArgs": 0
},
"getSelf": {
"minArgs": 0,
"maxArgs": 0
},
"setEnabled": {
"minArgs": 2,
"maxArgs": 2
},
"uninstallSelf": {
"minArgs": 0,
"maxArgs": 1
}
},
"notifications": {
"clear": {
"minArgs": 1,
"maxArgs": 1
},
"create": {
"minArgs": 1,
"maxArgs": 2
},
"getAll": {
"minArgs": 0,
"maxArgs": 0
},
"getPermissionLevel": {
"minArgs": 0,
"maxArgs": 0
},
"update": {
"minArgs": 2,
"maxArgs": 2
}
},
"pageAction": {
"getPopup": {
"minArgs": 1,
"maxArgs": 1
},
"getTitle": {
"minArgs": 1,
"maxArgs": 1
},
"hide": {
"minArgs": 1,
"maxArgs": 1,
},
"setIcon": {
"minArgs": 1,
"maxArgs": 1
},
"setPopup": {
"minArgs": 1,
"maxArgs": 1,
},
"setTitle": {
"minArgs": 1,
"maxArgs": 1,
},
"show": {
"minArgs": 1,
"maxArgs": 1,
}
},
"permissions": {
"contains": {
"minArgs": 1,
"maxArgs": 1
},
"getAll": {
"minArgs": 0,
"maxArgs": 0
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"request": {
"minArgs": 1,
"maxArgs": 1
}
},
"runtime": {
"getBackgroundPage": {
"minArgs": 0,
"maxArgs": 0
},
"getPlatformInfo": {
"minArgs": 0,
"maxArgs": 0
},
"openOptionsPage": {
"minArgs": 0,
"maxArgs": 0
},
"requestUpdateCheck": {
"minArgs": 0,
"maxArgs": 0
},
"sendMessage": {
"minArgs": 1,
"maxArgs": 3
},
"sendNativeMessage": {
"minArgs": 2,
"maxArgs": 2
},
"setUninstallURL": {
"minArgs": 1,
"maxArgs": 1
}
},
"sessions": {
"getDevices": {
"minArgs": 0,
"maxArgs": 1
},
"getRecentlyClosed": {
"minArgs": 0,
"maxArgs": 1
},
"restore": {
"minArgs": 0,
"maxArgs": 1
}
},
"storage": {
"local": {
"clear": {
"minArgs": 0,
"maxArgs": 0
},
"get": {
"minArgs": 0,
"maxArgs": 1
},
"getBytesInUse": {
"minArgs": 0,
"maxArgs": 1
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"set": {
"minArgs": 1,
"maxArgs": 1
}
},
"managed": {
"get": {
"minArgs": 0,
"maxArgs": 1
},
"getBytesInUse": {
"minArgs": 0,
"maxArgs": 1
}
},
"sync": {
"clear": {
"minArgs": 0,
"maxArgs": 0
},
"get": {
"minArgs": 0,
"maxArgs": 1
},
"getBytesInUse": {
"minArgs": 0,
"maxArgs": 1
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"set": {
"minArgs": 1,
"maxArgs": 1
}
}
},
"tabs": {
"captureVisibleTab": {
"minArgs": 0,
"maxArgs": 2
},
"create": {
"minArgs": 1,
"maxArgs": 1
},
"detectLanguage": {
"minArgs": 0,
"maxArgs": 1
},
"discard": {
"minArgs": 0,
"maxArgs": 1
},
"duplicate": {
"minArgs": 1,
"maxArgs": 1
},
"executeScript": {
"minArgs": 1,
"maxArgs": 2
},
"get": {
"minArgs": 1,
"maxArgs": 1
},
"getCurrent": {
"minArgs": 0,
"maxArgs": 0
},
"getZoom": {
"minArgs": 0,
"maxArgs": 1
},
"getZoomSettings": {
"minArgs": 0,
"maxArgs": 1
},
"goBack": {
"minArgs": 0,
"maxArgs": 1
},
"goForward": {
"minArgs": 0,
"maxArgs": 1
},
"highlight": {
"minArgs": 1,
"maxArgs": 1
},
"insertCSS": {
"minArgs": 1,
"maxArgs": 2
},
"move": {
"minArgs": 2,
"maxArgs": 2
},
"query": {
"minArgs": 1,
"maxArgs": 1
},
"reload": {
"minArgs": 0,
"maxArgs": 2
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"removeCSS": {
"minArgs": 1,
"maxArgs": 2
},
"sendMessage": {
"minArgs": 2,
"maxArgs": 3
},
"setZoom": {
"minArgs": 1,
"maxArgs": 2
},
"setZoomSettings": {
"minArgs": 1,
"maxArgs": 2
},
"update": {
"minArgs": 1,
"maxArgs": 2
}
},
"topSites": {
"get": {
"minArgs": 0,
"maxArgs": 0
}
},
"webNavigation": {
"getAllFrames": {
"minArgs": 1,
"maxArgs": 1
},
"getFrame": {
"minArgs": 1,
"maxArgs": 1
}
},
"webRequest": {
"handlerBehaviorChanged": {
"minArgs": 0,
"maxArgs": 0
}
},
"windows": {
"create": {
"minArgs": 0,
"maxArgs": 1
},
"get": {
"minArgs": 1,
"maxArgs": 2
},
"getAll": {
"minArgs": 0,
"maxArgs": 1
},
"getCurrent": {
"minArgs": 0,
"maxArgs": 1
},
"getLastFocused": {
"minArgs": 0,
"maxArgs": 1
},
"remove": {
"minArgs": 1,
"maxArgs": 1
},
"update": {
"minArgs": 2,
"maxArgs": 2
}
}
};
if (Object.keys(apiMetadata).length === 0) {
throw new Error("api-metadata.json has not been included in browser-
polyfill");
}
/**
* A WeakMap subclass which creates and stores a value for any key which does
* not exist when accessed, but behaves exactly as an ordinary WeakMap
* otherwise.
*
* @param {function} createItem
* A function which will be called in order to create the value for
any
* key which does not exist, the first time it is accessed. The
* function receives, as its only argument, the key being created.
*/
class DefaultWeakMap extends WeakMap {

constructor(createItem, items = undefined) {
super(items);
this.createItem = createItem;
}
get(key) {
if (!this.has(key)) {
this.set(key, this.createItem(key));
}
return super.get(key);
}
}
/**
* Returns true if the given object is an object with a `then` method, and
can
* therefore be assumed to behave as a Promise.
*
* @param {*} value The value to test.
* @returns {boolean} True if the value is thenable.
*/
const isThenable = value => {

return value && typeof value === "object" && typeof value.then ===
"function";
};
/**
* Creates and returns a function which, when called, will resolve or reject
* the given promise based on how it is called:
*
* - If, when called, `chrome.runtime.lastError` contains a non-null object,
* the promise is rejected with that value.
* - If the function is called with exactly one argument, the promise is
* resolved to that value.
* - Otherwise, the promise is resolved to an array containing all of the
* function's arguments.
*
* @param {object} promise
* An object containing the resolution and rejection functions of a
* promise.
* @param {function} promise.resolve
* The promise's resolution function.
* @param {function} promise.rejection
* The promise's rejection function.
* @param {object} metadata
* Metadata about the wrapped method which has created the callback.
* @param {integer} metadata.maxResolvedArgs
* The maximum number of arguments which may be passed to the
* callback created by the wrapped async function.
*
* @returns {function}
* The generated callback function.
*/
const makeCallback = (promise, metadata) => {

return (...callbackArgs) => {
if (extensionAPIs.runtime.lastError) {
promise.reject(extensionAPIs.runtime.lastError);
} else if (metadata.singleCallbackArg || callbackArgs.length <= 1 &&
metadata.singleCallbackArg !== false) {
promise.resolve(callbackArgs[0]);
} else {
promise.resolve(callbackArgs);
}
};
};
const pluralizeArguments = numArgs => numArgs == 1 ? "argument" :

"arguments";
/**
* Creates a wrapper function for a method with the given name and metadata.
*
* @param {string} name
* The name of the method which is being wrapped.
* @param {object} metadata
* Metadata about the method being wrapped.
* @param {integer} metadata.minArgs
* The minimum number of arguments which must be passed to the
* function. If called with fewer than this number of arguments, the
* wrapper will raise an exception.
* @param {integer} metadata.maxArgs
* function. If called with more than this number of arguments, the
* wrapper will raise an exception.
* @param {integer} metadata.maxResolvedArgs
* callback created by the wrapped async function.
*
* @returns {function(object, ...*)}
* The generated wrapper function.
*/
const wrapAsyncFunction = (name, metadata) => {

return function asyncFunctionWrapper(target, ...args) {
if (args.length < metadata.minArgs) {
throw new Error(Èxpected at least ${metadata.minArgs} $
{pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);
}
if (args.length > metadata.maxArgs) {

throw new Error(Èxpected at most ${metadata.maxArgs} $
{pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);
}
return new Promise((resolve, reject) => {

if (metadata.fallbackToNoCallback) {
// This API method has currently no callback on Chrome, but it return
a promise on Firefox,
// and so the polyfill will try to call it with a callback first, and
it will fallback
// to not passing the callback if the first call fails.
try {
target[name](...args, makeCallback({
resolve,
reject
}, metadata));
} catch (cbError) {
console.warn(`${name} API method doesn't seem to support the
callback parameter, ` + "falling back to call it without a callback: ", cbError);
target[name](...args); // Update the API method metadata, so that
the next API calls will not try to
// use the unsupported callback anymore.
metadata.fallbackToNoCallback = false;
metadata.noCallback = true;
resolve();
}
} else if (metadata.noCallback) {
target[name](...args);
resolve();
} else {
target[name](...args, makeCallback({
resolve,
reject
}, metadata));
}
});
};
};
/**
* Wraps an existing method of the target object, so that calls to it are
* intercepted by the given wrapper function. The wrapper function receives,
* as its first argument, the original `target` object, followed by each of
* the arguments passed to the original method.
*
* @param {object} target
* The original target object that the wrapped method belongs to.
* @param {function} method
* The method being wrapped. This is used as the target of the Proxy
* object which is created to wrap the method.
* @param {function} wrapper
* The wrapper function which is called in place of a direct
invocation
* of the wrapped method.
*
* @returns {Proxy<function>}
* A Proxy object for the given method, which invokes the given
wrapper
* method in its place.
*/
const wrapMethod = (target, method, wrapper) => {

return new Proxy(method, {
apply(targetMethod, thisObj, args) {
return wrapper.call(thisObj, target, ...args);
}
});
};
let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);

/**
* Wraps an object in a Proxy which intercepts and wraps certain methods
* based on the given `wrappers` and `metadata` objects.
*
* @param {object} target
* The target object to wrap.
*
* @param {object} [wrappers = {}]
* An object tree containing wrapper functions for special cases. Any
* function present in this object tree is called in place of the
* method in the same location in the `target` object tree. These
* wrapper methods are invoked as described in {@see wrapMethod}.
*
* @param {object} [metadata = {}]
* An object tree containing metadata used to automatically generate
* Promise-based wrapper functions for asynchronous. Any function in
* the `target` object tree which has a corresponding metadata object
* in the same location in the `metadata` tree is replaced with an
* automatically-generated wrapper function, as described in
* {@see wrapAsyncFunction}
*
* @returns {Proxy<object>}
*/
const wrapObject = (target, wrappers = {}, metadata = {}) => {

let cache = Object.create(null);
let handlers = {
has(proxyTarget, prop) {
return prop in target || prop in cache;
},
get(proxyTarget, prop, receiver) {

if (prop in cache) {
return cache[prop];
}
if (!(prop in target)) {
return undefined;
}
let value = target[prop];
if (typeof value === "function") {

// This is a method on the underlying object. Check if we need to do
// any wrapping.
if (typeof wrappers[prop] === "function") {
// We have a special-case wrapper for this method.
value = wrapMethod(target, target[prop], wrappers[prop]);
} else if (hasOwnProperty(metadata, prop)) {
// This is an async method that we have metadata for. Create a
// Promise wrapper for it.
let wrapper = wrapAsyncFunction(prop, metadata[prop]);
value = wrapMethod(target, target[prop], wrapper);
} else {
// This is a method that we don't know or care about. Return the
// original method, bound to the underlying object.
value = value.bind(target);
}
} else if (typeof value === "object" && value !== null &&
(hasOwnProperty(wrappers, prop) || hasOwnProperty(metadata, prop))) {
// This is an object that we need to do some wrapping for the
children
// of. Create a sub-object wrapper for it with the appropriate child
// metadata.
value = wrapObject(value, wrappers[prop], metadata[prop]);
} else if (hasOwnProperty(metadata, "*")) {
// Wrap all properties in * namespace.
value = wrapObject(value, wrappers[prop], metadata["*"]);
} else {
// We don't need to do any wrapping for this property,
// so just forward all access to the underlying object.
Object.defineProperty(cache, prop, {
configurable: true,
enumerable: true,
get() {
return target[prop];
},
set(value) {
target[prop] = value;
}
});
return value;
}
cache[prop] = value;
return value;
},
set(proxyTarget, prop, value, receiver) {

if (prop in cache) {
cache[prop] = value;
} else {
target[prop] = value;
}
return true;
},
defineProperty(proxyTarget, prop, desc) {

return Reflect.defineProperty(cache, prop, desc);
},
deleteProperty(proxyTarget, prop) {
return Reflect.deleteProperty(cache, prop);
}
}; // Per contract of the Proxy API, the "get" proxy handler must return
the
// original value of the target if that value is declared read-only and
// non-configurable. For this reason, we create an object with the
// prototype set to `target` instead of using `target` directly.
// Otherwise we cannot return a custom object for APIs that
// are declared read-only and non-configurable, such as `chrome.devtools`.
//
// The proxy handlers themselves will still use the original `target`
// instead of the `proxyTarget`, so that the methods and properties are
// dereferenced via the original targets.
let proxyTarget = Object.create(target);

return new Proxy(proxyTarget, handlers);
};
/**
* Creates a set of wrapper functions for an event object, which handles
* wrapping of listener functions that those messages are passed.
*
* A single wrapper is created for each listener function, and stored in a
* map. Subsequent calls to àddListener`, `hasListener`, or `removeListener`
* retrieve the original wrapper, so that attempts to remove a
* previously-added listener work as expected.
*
* @param {DefaultWeakMap<function, function>} wrapperMap
* A DefaultWeakMap object which will create the appropriate wrapper
* for a given listener function when one does not exist, and retrieve
* an existing one when it does.
*
* @returns {object}
*/
const wrapEvent = wrapperMap => ({

addListener(target, listener, ...args) {
target.addListener(wrapperMap.get(listener), ...args);
},
hasListener(target, listener) {
return target.hasListener(wrapperMap.get(listener));
},
removeListener(target, listener) {
target.removeListener(wrapperMap.get(listener));
}
}); // Keep track if the deprecation warning has been logged at least once.
let loggedSendResponseDeprecationWarning = false;

const onMessageWrappers = new DefaultWeakMap(listener => {
if (typeof listener !== "function") {
return listener;
}
/**
* Wraps a message listener function so that it may send responses based on
* its return value, rather than by returning a sentinel value and calling
a
* callback. If the listener function returns a Promise, the response is
* sent when the promise either resolves or rejects.
*
* @param {*} message
* The message sent by the other end of the channel.
* @param {object} sender
* Details about the sender of the message.
* @param {function(*)} sendResponse
* A callback which, when called with an arbitrary argument, sends
* that value as a response.
* @returns {boolean}
* True if the wrapped listener returned a Promise, which will later
* yield a response. False otherwise.
*/
return function onMessage(message, sender, sendResponse) {

let didCallSendResponse = false;
let wrappedSendResponse;
let sendResponsePromise = new Promise(resolve => {
wrappedSendResponse = function (response) {
if (!loggedSendResponseDeprecationWarning) {
console.warn(SEND_RESPONSE_DEPRECATION_WARNING, new Error().stack);
loggedSendResponseDeprecationWarning = true;
}
didCallSendResponse = true;
resolve(response);
};
});
let result;
try {
result = listener(message, sender, wrappedSendResponse);
} catch (err) {
result = Promise.reject(err);
}
const isResultThenable = result !== true && isThenable(result); // If the

listener didn't returned true or a Promise, or called
// wrappedSendResponse synchronously, we can exit earlier
// because there will be no response sent from this listener.
if (result !== true && !isResultThenable && !didCallSendResponse) {

return false;
} // A small helper to send the message if the promise resolves
// and an error if the promise rejects (a wrapped sendMessage has
// to translate the message into a resolved promise or a rejected
// promise).
const sendPromisedResult = promise => {

promise.then(msg => {
// send the message value.
sendResponse(msg);
}, error => {
// Send a JSON representation of the error if the rejected value
// is an instance of error, or the object itself otherwise.
let message;
if (error && (error instanceof Error || typeof error.message ===

"string")) {
message = error.message;
} else {
message = "An unexpected error occurred";
}
sendResponse({
__mozWebExtensionPolyfillReject__: true,
message
});
}).catch(err => {
// Print an error on the console if unable to send the response.
console.error("Failed to send onMessage rejected reply", err);
});
}; // If the listener returned a Promise, send the resolved value as a
// result, otherwise wait the promise related to the wrappedSendResponse
// callback to resolve and send it as a response.
if (isResultThenable) {
sendPromisedResult(result);
} else {
sendPromisedResult(sendResponsePromise);
} // Let Chrome know that the listener is replying.
return true;
};
});
const wrappedSendMessageCallback = ({
reject,
resolve
}, reply) => {
if (extensionAPIs.runtime.lastError) {
// Detect when none of the listeners replied to the sendMessage call and
resolve
// the promise to undefined as in Firefox.
// See https://github.com/mozilla/webextension-polyfill/issues/130
if (extensionAPIs.runtime.lastError.message ===
CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) {
resolve();
} else {
reject(extensionAPIs.runtime.lastError);
}
} else if (reply && reply.__mozWebExtensionPolyfillReject__) {
// Convert back the JSON representation of the error into
// an Error instance.
reject(new Error(reply.message));
} else {
resolve(reply);
}
};
const wrappedSendMessage = (name, metadata, apiNamespaceObj, ...args) => {

if (args.length < metadata.minArgs) {
throw new Error(Èxpected at least ${metadata.minArgs} $
{pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);
}
if (args.length > metadata.maxArgs) {

throw new Error(Èxpected at most ${metadata.maxArgs} $
{pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);
}
return new Promise((resolve, reject) => {

const wrappedCb = wrappedSendMessageCallback.bind(null, {
resolve,
reject
});
args.push(wrappedCb);
apiNamespaceObj.sendMessage(...args);
});
};
const staticWrappers = {
runtime: {
onMessage: wrapEvent(onMessageWrappers),
onMessageExternal: wrapEvent(onMessageWrappers),
sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
minArgs: 1,
maxArgs: 3
})
},
tabs: {
sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
minArgs: 2,
maxArgs: 3
})
}
};
const settingMetadata = {
clear: {
minArgs: 1,
maxArgs: 1
},
get: {
minArgs: 1,
maxArgs: 1
},
set: {
minArgs: 1,
maxArgs: 1
}
};
apiMetadata.privacy = {
network: {
"*": settingMetadata
},
services: {
},
websites: {
}
};
return wrapObject(extensionAPIs, staticWrappers, apiMetadata);
};
if (typeof chrome != "object" || !chrome || !chrome.runtime || !

chrome.runtime.id) {
throw new Error("This script should only be loaded in a browser extension.");
} // The build process adds a UMD wrapper around this file, which makes the
// `module` variable available.
module.exports = wrapAPIs(chrome);
} else {
module.exports = browser;
}
});
//# sourceMappingURL=browser-polyfill.js.map
/***/ }),
/***/ 43679:
"use strict";
var isString = __webpack_require__(29981);
var isNumber = __webpack_require__(44578);
var isBoolean = __webpack_require__(76814);
var isSymbol = __webpack_require__(12636);
var isBigInt = __webpack_require__(63376);
module.exports = function whichBoxedPrimitive(value) {
if (value == null || (typeof value !== 'object' && typeof value !==
'function')) {
return null;
}
if (isString(value)) {
return 'String';
}
if (isNumber(value)) {
return 'Number';
}
if (isBoolean(value)) {
return 'Boolean';
}
if (isSymbol(value)) {
return 'Symbol';
}
if (isBigInt(value)) {
return 'BigInt';
}
};
/***/ }),
/***/ 86430:
"use strict";
var forEach = __webpack_require__(49804);

var availableTypedArrays = __webpack_require__(63083);


var typedArrays = availableTypedArrays();
var $slice = callBound('String.prototype.slice');

var toStrTags = {};
var gOPD = __webpack_require__(20882);
var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
if (hasToStringTag && gOPD && getPrototypeOf) {
forEach(typedArrays, function (typedArray) {
if (typeof g[typedArray] === 'function') {
var arr = new g[typedArray]();
if (Symbol.toStringTag in arr) {
var proto = getPrototypeOf(arr);
var descriptor = gOPD(proto, Symbol.toStringTag);
if (!descriptor) {
var superProto = getPrototypeOf(proto);
descriptor = gOPD(superProto, Symbol.toStringTag);
}
toStrTags[typedArray] = descriptor.get;
}
}
});
}
var tryTypedArrays = function tryAllTypedArrays(value) {

var foundName = false;
forEach(toStrTags, function (getter, typedArray) {
if (!foundName) {
try {
var name = getter.call(value);
if (name === typedArray) {
foundName = name;
}
} catch (e) {}
}
});
return foundName;
};
var isTypedArray = __webpack_require__(85692);
module.exports = function whichTypedArray(value) {

if (!isTypedArray(value)) { return false; }
if (!hasToStringTag || !(Symbol.toStringTag in value)) { return
$slice($toString(value), 8, -1); }
return tryTypedArrays(value);
};
/***/ }),
/***/ 63083:
"use strict";
var possibleNames = [
'BigInt64Array',
'BigUint64Array',
'Float32Array',
'Float64Array',
'Int16Array',
'Int32Array',
'Int8Array',
'Uint16Array',
'Uint32Array',
'Uint8Array',
'Uint8ClampedArray'
];
module.exports = function availableTypedArrays() {

var out = [];
for (var i = 0; i < possibleNames.length; i++) {
if (typeof g[possibleNames[i]] === 'function') {
out[out.length] = possibleNames[i];
}
}
return out;
};
/***/ }),
/***/ 20882:
"use strict";
var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);

if ($gOPD) {
try {
$gOPD([], 'length');
} catch (e) {
// IE 8 has a broken gOPD
$gOPD = null;
}
}
module.exports = $gOPD;
/***/ }),
/***/ 33216:
"use strict";
/* eslint global-require: 0 */
// the code is structured this way so that bundlers can
// alias out `has-symbols` to `() => true` or `() => false` if your target
// environments' Symbol capabilities are known, and then use
// dead code elimination on the rest of this module.
//
// Similarly, ìsarray` can be aliased to Àrray.isArray` if
// available in all target environments.
var isArguments = __webpack_require__(82584);
if (__webpack_require__(41405)() || __webpack_require__(55419)()) {
var $iterator = Symbol.iterator;
// Symbol is available natively or shammed
// natively:
// - Chrome >= 38
// - Edge 12-14?, Edge >= 15 for sure
// - FF >= 36
// - Safari >= 9
// - node >= 0.12
module.exports = function getIterator(iterable) {
// alternatively, ìterable[$iterator]?.()`
if (iterable != null && typeof iterable[$iterator] !== 'undefined') {
return iterable[$iterator]();
}
if (isArguments(iterable)) {
// arguments objects lack Symbol.iterator
// - node 0.12
return Array.prototype[$iterator].call(iterable);
}
};
} else {
// Symbol is not available, native or shammed
var isArray = __webpack_require__(5826);
var isString = __webpack_require__(29981);
var $Map = GetIntrinsic('%Map%', true);
var $Set = GetIntrinsic('%Set%', true);
var $arrayPush = callBound('Array.prototype.push');
var $charCodeAt = callBound('String.prototype.charCodeAt');
var $stringSlice = callBound('String.prototype.slice');
var advanceStringIndex = function advanceStringIndex(S, index) {

var length = S.length;
if ((index + 1) >= length) {
return index + 1;
}
var first = $charCodeAt(S, index);

if (first < 0xD800 || first > 0xDBFF) {
return index + 1;
}
var second = $charCodeAt(S, index + 1);

if (second < 0xDC00 || second > 0xDFFF) {
return index + 1;
}
return index + 2;
};
var getArrayIterator = function getArrayIterator(arraylike) {

var i = 0;
return {
next: function next() {
var done = i >= arraylike.length;
var value;
if (!done) {
value = arraylike[i];
i += 1;
}
return {
done: done,
value: value
};
}
};
};
var getNonCollectionIterator = function getNonCollectionIterator(iterable,

noPrimordialCollections) {
if (isArray(iterable) || isArguments(iterable)) {
return getArrayIterator(iterable);
}
if (isString(iterable)) {
var i = 0;
return {
var nextIndex = advanceStringIndex(iterable, i);
var value = $stringSlice(iterable, i, nextIndex);
i = nextIndex;
return {
done: nextIndex > iterable.length,
value: value
};
}
};
}
// es6-shim and es-shims' es-map use a string "_es6-shim iterator_"

property on different iterables, such as MapIterator.
if (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !
== 'undefined') {
return iterable['_es6-shim iterator_']();
}
};
if (!$Map && !$Set) {

// the only language iterables are Array, String, arguments
// - Safari <= 6.0
// - Chrome < 38
// - node < 0.12
// - FF < 13
// - IE < 11
// - Edge < 11

if (iterable != null) {
return getNonCollectionIterator(iterable, true);
}
};
} else {
// either Map or Set are available, but Symbol is not
// - es6-shim on an ES5 browser
// - Safari 6.2 (maybe 6.1?)
// - FF v[13, 36)
// - IE 11
// - Edge 11
// - Safari v[6, 9)
var isMap = __webpack_require__(78379);

var isSet = __webpack_require__(19572);
// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older
envs, all have forEach
var $mapForEach = callBound('Map.prototype.forEach', true);
var $setForEach = callBound('Set.prototype.forEach', true);
if (typeof process === 'undefined' || !process.versions || !
process.versions.node) { // "if is not node"
// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()`

either
// returns a value, or throws a StopIteration object. These
browsers
// do not have any other mechanism for iteration.
var $mapIterator = callBound('Map.prototype.iterator', true);
var $setIterator = callBound('Set.prototype.iterator', true);
var getStopIterationIterator = function (iterator) {
var done = false;
return {
try {
return {
done: done,
value: done ? undefined :
iterator.next()
};
} catch (e) {
done = true;
return {
done: true,
value: undefined
};
}
}
};
};
}
// Firefox 27-35, and some older es6-shim versions, use a string
"@@iterator" property
// this returns a proper iterator object, so we should use it instead
of forEach.
// newer es6-shim versions use a string "_es6-shim iterator_" property.
var $mapAtAtIterator = callBound('Map.prototype.@@iterator', true) ||
callBound('Map.prototype._es6-shim iterator_', true);
var $setAtAtIterator = callBound('Set.prototype.@@iterator', true) ||
callBound('Set.prototype._es6-shim iterator_', true);
var getCollectionIterator = function getCollectionIterator(iterable) {

if (isMap(iterable)) {
if ($mapIterator) {
return
getStopIterationIterator($mapIterator(iterable));
}
if ($mapAtAtIterator) {
return $mapAtAtIterator(iterable);
}
if ($mapForEach) {
var entries = [];
$mapForEach(iterable, function (v, k) {
$arrayPush(entries, [k, v]);
});
return getArrayIterator(entries);
}
}
if (isSet(iterable)) {
if ($setIterator) {
return
getStopIterationIterator($setIterator(iterable));
}
if ($setAtAtIterator) {
return $setAtAtIterator(iterable);
}
if ($setForEach) {
var values = [];
$setForEach(iterable, function (v) {
$arrayPush(values, v);
});
return getArrayIterator(values);
}
}
};

return getCollectionIterator(iterable) ||
getNonCollectionIterator(iterable);
};
}
}
/***/ }),
/***/ 43483:
"use strict";
var isMap = __webpack_require__(78379);

var isSet = __webpack_require__(19572);
var isWeakMap = __webpack_require__(11718);
var isWeakSet = __webpack_require__(25899);
module.exports = function whichCollection(value) {

if (value && typeof value === 'object') {
if (isMap(value)) {
return 'Map';
}
if (isSet(value)) {
return 'Set';
}
if (isWeakMap(value)) {
return 'WeakMap';
}
if (isWeakSet(value)) {
return 'WeakSet';
}
}
return false;
};
/***/ }),
/***/ 4942:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__,
__webpack_require__) => {
"use strict";
/* harmony export */ "Z": () => (/* binding */ _defineProperty)
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
/***/ }),
/***/ 87462:
"use strict";
/* harmony export */ "Z": () => (/* binding */ _extends)
function _extends() {
_extends = Object.assign || function (target) {
var source = arguments[i];
for (var key in source) {

if (Object.prototype.hasOwnProperty.call(source, key)) {
}
}
}
return target;
};
return _extends.apply(this, arguments);

}
/***/ }),
/***/ 1413:
"use strict";
/* harmony export */ "Z": () => (/* binding */ _objectSpread2)
/* harmony import */ var _defineProperty_js__WEBPACK_IMPORTED_MODULE_0__ =
}
function ownKeys(object, enumerableOnly) {

var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) {
symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
}
keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
var source = arguments[i] != null ? arguments[i] : {};
if (i % 2) {
ownKeys(Object(source), true).forEach(function (key) {
(0,_defineProperty_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)
(target, key, source[key]);
});
} else if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source,
key));
});
}
}
return target;
}
/***/ }),
/***/ 63366:
"use strict";
/* harmony export */ "Z": () => (/* binding */ _objectWithoutPropertiesLoose)
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {

key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
}
return target;
}
/***/ })
}]);

Vendor

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Vendor

Uploaded by

Copyright:

Available Formats

(self["webpackChunkxcloud_keyboard_mouse"] =

function useStatefulRef(initialVal = null) {

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

var extendStatics = function(d, b) {

var __assign = function() {

function __decorate(decorators, target, key, desc) {

function __param(paramIndex, decorator) {

function __metadata(metadataKey, metadataValue) {

function __awaiter(thisArg, _arguments, P, generator) {

function __generator(thisArg, body) {

var __createBinding = Object.create ? (function(o, m, k, k2) {

function __spreadArray(to, from, pack) {

function __asyncGenerator(thisArg, _arguments, generator) {

function __makeTemplateObject(cooked, raw) {

var __setModuleDefault = Object.create ? (function(o, v) {

function __classPrivateFieldGet(receiver, state, kind, f) {

function __classPrivateFieldSet(receiver, state, value, kind, f) {

function __classPrivateFieldIn(state, receiver) {

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

Object.defineProperty(exports, "__esModule", ({ value: true }));

var extendStatics = function(d, b) {

var __assign = function() {

function __param(paramIndex, decorator) {

function __metadata(metadataKey, metadataValue) {

function __awaiter(thisArg, _arguments, P, generator) {

function __generator(thisArg, body) {

var __createBinding = Object.create ? (function(o, m, k, k2) {

function __spreadArray(to, from, pack) {

function __asyncGenerator(thisArg, _arguments, generator) {

function __makeTemplateObject(cooked, raw) {

var __setModuleDefault = Object.create ? (function(o, v) {

function __classPrivateFieldGet(receiver, state, kind, f) {

function __classPrivateFieldSet(receiver, state, value, kind, f) {

function __classPrivateFieldIn(state, receiver) {