https://www.andresoliveira.com.br/wp-content/plugins/motopress-appointment/assets/js/public.min.js

1(function () {
2	'use strict';
3
4	let namespace = '/motopress/appointment/v1';
5
6	/**
7	 * @param {String} route
8	 * @param {Object} args Optional.
9	 * @param {String} type Optional. 'GET' by default.
10	 * @return {Promise}
11	 *
12	 * @since 1.0
13	 */
14	function mpa_rest_request(route, args = {}, type = 'GET') {
15	  return new Promise((resolve, reject) => {
16		wp.apiRequest({
17		  path: namespace + route,
18		  type: type,
19		  data: args
20		})
21		// Convert jqXHR object into Promise
22		.done(responseData => resolve(responseData)).fail((request, statusText) => {
23		  let message = 'parsererror'; // Default response for PHP error
24
25		  // Get error message
26		  if (request.responseJSON && request.responseJSON.message) {
27			message = request.responseJSON.message;
28		  } else {
29			message = `Status: ${statusText}`;
30		  }
31		  if (message == 'parsererror') {
32			message = 'REST request failed. Maybe PHP error on the server side. Check PHP logs.';
33		  }
34		  reject(new Error(message));
35		});
36	  });
37	}
38
39	/**
40	 * @param {String} route
41	 * @param {Object} args Optional.
42	 * @return {Promise}
43	 *
44	 * @since 1.0
45	 */
46	function mpa_rest_get(route, args = {}) {
47	  return mpa_rest_request(route, args, 'GET');
48	}
49
50	/**
51	 * @param {String} route
52	 * @param {Object} args
53	 * @return {Promise}
54	 *
55	 * @since 1.0
56	 */
57	function mpa_rest_post(route, args) {
58	  return mpa_rest_request(route, args, 'POST');
59	}
60
61	/**
62	 * @since 1.0
63	 */
64	class Settings {
65	  /**
66	   * @since 1.0
67	   */
68	  constructor() {
69		this.settings = this.getDefaults();
70		this.loadingPromise = this.load();
71	  }
72
73	  /**
74	   * @since 1.0
75	   *
76	   * @access protected
77	   *
78	   * @return {Object}
79	   */
80	  getDefaults() {
81		return {
82		  plugin_name: 'Appointment Booking',
83		  // No translation required
84		  today: '2030-01-01',
85		  business_name: '',
86		  default_time_step: 30,
87		  default_booking_status: 'confirmed',
88		  confirmation_mode: 'auto',
89		  terms_page_id_for_acceptance: 0,
90		  allow_multibooking: false,
91		  allow_coupons: false,
92		  allow_customer_account_creation: false,
93		  country: '',
94		  currency: 'EUR',
95		  currency_symbol: '€',
96		  currency_position: 'before',
97		  decimal_separator: '.',
98		  thousand_separator: ',',
99		  number_of_decimals: 2,
100		  date_format: 'F j, Y',
101		  time_format: 'H:i',
102		  week_starts_on: 0,
103		  thumbnail_size: {
104			width: 150,
105			height: 150
106		  },
107		  flatpickr_locale: 'en',
108		  enable_payments: false,
109		  active_gateways: [],
110		  payment_received_page_url: '',
111		  failed_transaction_page_url: '',
112		  default_payment_gateway: ''
113		};
114	  }
115
116	  /**
117	   * @return {Promise}
118	   *
119	   * @access protected
120	   *
121	   * @since 1.0
122	   */
123	  load() {
124		return new Promise((resolve, reject) => {
125		  mpa_rest_get('/settings?nocache').then(responseData => this.settings = responseData, error => console.error('Unable to load public settings.', error)).finally(() => resolve(this.settings));
126		});
127	  }
128
129	  /**
130	   * @return {Promise}
131	   *
132	   * @since 1.0
133	   */
134	  ready() {
135		return this.loadingPromise;
136	  }
137
138	  /**
139	   * @since 1.5.0
140	   *
141	   * @return {String}
142	   */
143	  getPluginName() {
144		return this.settings.plugin_name;
145	  }
146
147	  /**
148	   * @since 1.11.0
149	   *
150	   * @return {String} 'Y-m-d'
151	   */
152	  getBusinessDate() {
153		return this.settings.today;
154	  }
155
156	  /**
157	   * @return {String}
158	   */
159	  getBusinessName() {
160		return this.settings.business_name;
161	  }
162
163	  /**
164	   * @return {Number} Step for time slots (in minutes).
165	   *
166	   * @since 1.0
167	   */
168	  getTimeStep() {
169		return this.settings.default_time_step;
170	  }
171
172	  /**
173	   * @return {String} 'pending' or 'confirmed'.
174	   *
175	   * @since 1.1.0
176	   */
177	  getDefaultBookingStatus() {
178		return this.settings.default_booking_status;
179	  }
180
181	  /**
182	   * @since 1.5.0
183	   * @return {String} auto|manual|payment
184	   */
185	  getConfirmationMode() {
186		return this.settings.confirmation_mode;
187	  }
188
189	  /**
190	   * @since 1.10.2
191	   * @return {Integer} 0 | page id
192	   */
193	  getTermsPageIdForAcceptance() {
194		return this.settings.terms_page_id_for_acceptance;
195	  }
196
197	  /**
198	   * @since 1.4.0
199	   *
200	   * @return {Boolean}
201	   */
202	  isMultibookingEnabled() {
203		return this.settings.allow_multibooking;
204	  }
205
206	  /**
207	   * @since 1.11.0
208	   *
209	   * @return {Boolean}
210	   */
211	  isCouponsEnabled() {
212		return this.settings.allow_coupons;
213	  }
214
215	  /**
216	   * @since 1.18.0
217	   *
218	   * @return {Boolean}
219	   */
220	  isAllowCustomerAccountCreation() {
221		return this.settings.allow_customer_account_creation;
222	  }
223
224	  /**
225	   * @since 1.5.0
226	   *
227	   * @return {String}
228	   */
229	  getCountry() {
230		return this.settings.country;
231	  }
232
233	  /**
234	   * @return {String} Currency code, like "EUR".
235	   *
236	   * @since 1.0
237	   */
238	  getCurrency() {
239		return this.settings.currency;
240	  }
241
242	  /**
243	   * @return {String}
244	   *
245	   * @since 1.0
246	   */
247	  getCurrencySymbol() {
248		return this.settings.currency_symbol;
249	  }
250
251	  /**
252	   * @return {String}
253	   *
254	   * @since 1.0
255	   */
256	  getCurrencyPosition() {
257		return this.settings.currency_position;
258	  }
259
260	  /**
261	   * @return {String}
262	   *
263	   * @since 1.0
264	   */
265	  getDecimalSeparator() {
266		return this.settings.decimal_separator;
267	  }
268
269	  /**
270	   * @return {String}
271	   *
272	   * @since 1.0
273	   */
274	  getThousandSeparator() {
275		return this.settings.thousand_separator;
276	  }
277
278	  /**
279	   * @return {Number}
280	   *
281	   * @since 1.0
282	   */
283	  getDecimalsCount() {
284		return this.settings.number_of_decimals;
285	  }
286
287	  /**
288	   * @return {String}
289	   *
290	   * @since 1.0
291	   */
292	  getDateFormat() {
293		return this.settings.date_format;
294	  }
295
296	  /**
297	   * @return {String}
298	   *
299	   * @since 1.0
300	   */
301	  getTimeFormat() {
302		return this.settings.time_format;
303	  }
304
305	  /**
306	   * @return {Number}
307	   *
308	   * @since 1.0
309	   */
310	  getFirstDayOfWeek() {
311		return this.settings.week_starts_on;
312	  }
313
314	  /**
315	   * @since 1.4.0
316	   *
317	   * @return {Object} {width, height}
318	   */
319	  getThumbnailSize() {
320		return this.settings.thumbnail_size;
321	  }
322
323	  /**
324	   * @return {String}
325	   *
326	   * @since 1.2.1
327	   */
328	  getFlatpickrLocale() {
329		return this.settings.flatpickr_locale;
330	  }
331
332	  /**
333	   * @since 1.5.0
334	   *
335	   * @return {Boolean}
336	   */
337	  isPaymentsEnabled() {
338		return this.settings.enable_payments;
339	  }
340
341	  /**
342	   * @since 1.5.0
343	   *
344	   * @return {String[]}
345	   */
346	  getActiveGateways() {
347		return this.settings.active_gateways;
348	  }
349
350	  /**
351	   * @since 1.5.0
352	   *
353	   * @return {String}
354	   */
355	  getPaymentReceivedPageUrl() {
356		return this.settings.payment_received_page_url;
357	  }
358
359	  /**
360	   * @since 1.5.0
361	   *
362	   * @return {String}
363	   */
364	  getFailedTransactionPageUrl() {
365		return this.settings.failed_transaction_page_url;
366	  }
367
368	  /**
369	   * @since 1.6.2
370	   *
371	   * @return {String}
372	   */
373	  getDefaultPaymentGateway() {
374		return this.settings.default_payment_gateway;
375	  }
376	}
377

378	/**
379	 * @since 1.0
380	 */
381	class Plugin {
382	  /**
383	   * @since 1.0
384	   */
385	  constructor() {
386		this.settingsCtrl = new Settings();
387		this.loadingPromise = this.load();
388	  }
389
390	  /**
391	   * @return {Promise}
392	   *
393	   * @since 1.0
394	   */
395	  load() {
396		return Promise.all([this.settingsCtrl.ready()]).then(() => this);
397	  }
398
399	  /**
400	   * @return {Promise}
401	   *
402	   * @since 1.0
403	   */
404	  ready() {
405		return this.loadingPromise;
406	  }
407
408	  /**
409	   * @since 1.0
410	   */
411	  settings() {
412		return this.settingsCtrl;
413	  }
414
415	  /**
416	   * @since 1.0
417	   */
418	  static getInstance() {
419		if (Plugin.instance == undefined) {
420		  Plugin.instance = new Plugin();
421		}
422		return Plugin.instance;
423	  }
424	}
425
426	/**
427	 * @return {Plugin}
428	 *
429	 * @since 1.0
430	 */
431	function mpapp() {
432	  return Plugin.getInstance();
433	}
434
435	const localTranslate = (text, domain = '') => text;
436	const localTranslateWithContext = (text, context, domain = '') => text;
437	const localSprintf = (format, ...args) => {
438	  let argIndex = 0;
439	  return format.replace(/%([sdf])/g, (match, specifier) => {
440		if (argIndex >= args.length) return match;
441		let value = args[argIndex++];
442		switch (specifier) {
443		  case 's':
444			return String(value);
445		  case 'd':
446			return parseInt(value, 10);
447		  case 'f':
448			return parseFloat(value);
449		  default:
450			return match;
451		}
452	  });
453	};
454	const __ = typeof wp !== 'undefined' && wp.i18n && wp.i18n.__ ? wp.i18n.__ : localTranslate;
455	const _x = typeof wp !== 'undefined' && wp.i18n && wp.i18n._x ? wp.i18n._x : localTranslateWithContext;
456	typeof wp !== 'undefined' && wp.i18n && wp.i18n.sprintf ? wp.i18n.sprintf : localSprintf;
457
458	const locale = {
459	  weekdays: {
460		shorthand: [__('Sun', 'motopress-appointment'), __('Mon', 'motopress-appointment'), __('Tue', 'motopress-appointment'), __('Wed', 'motopress-appointment'), __('Thu', 'motopress-appointment'), __('Fri', 'motopress-appointment'), __('Sat', 'motopress-appointment')],
461		longhand: [__('Sunday', 'motopress-appointment'), __('Monday', 'motopress-appointment'), __('Tuesday', 'motopress-appointment'), __('Wednesday', 'motopress-appointment'), __('Thursday', 'motopress-appointment'), __('Friday', 'motopress-appointment'), __('Saturday', 'motopress-appointment')]
462	  },
463	  months: {
464		shorthand: [__('Jan', 'motopress-appointment'), __('Feb', 'motopress-appointment'), __('Mar', 'motopress-appointment'), __('Apr', 'motopress-appointment'),
465		// Translators: Month name (short variant, like "Apr").
466		_x('May', 'Month (short)', 'motopress-appointment'), __('Jun', 'motopress-appointment'), __('Jul', 'motopress-appointment'), __('Aug', 'motopress-appointment'), __('Sep', 'motopress-appointment'), __('Oct', 'motopress-appointment'), __('Nov', 'motopress-appointment'), __('Dec', 'motopress-appointment')],
467		longhand: [__('January', 'motopress-appointment'), __('February', 'motopress-appointment'), __('March', 'motopress-appointment'), __('April', 'motopress-appointment'), _x('May', 'Month', 'motopress-appointment'), __('June', 'motopress-appointment'), __('July', 'motopress-appointment'), __('August', 'motopress-appointment'), __('September', 'motopress-appointment'), __('October', 'motopress-appointment'), __('November', 'motopress-appointment'), __('December', 'motopress-appointment')]
468	  },
469	  amPM: ['AM', 'PM'],
470	  firstDayOfWeek: mpapp().settings().getFirstDayOfWeek()
471	};
472
473	/**
474	 * @return {String}
475	 *
476	 * @since 1.0
477	 */
478	function mpa_date_format() {
479	  return mpapp().settings().getDateFormat();
480	}
481
482	/**
483	 * Based on Flatpickr's formatDate().
484	 *
485	 * @see Flatpickr.formatDate(): https://github.com/flatpickr/flatpickr/blob/master/src/utils/formatting.ts
486	 * @see PHP date formatting tokens: https://www.php.net/manual/en/datetime.format.php
487	 *
488	 * @param {Date|String} date
489	 * @param {String} Optional. 'public', 'internal' ('Y-m-d') or custom date
490	 *     format. 'public' by default.
491	 * @return {String}
492	 *
493	 * @since 1.0
494	 */
495	function mpa_format_date(date, format = 'public') {
496	  if (typeof date == 'string') {
497		return date; // Already stringified
498	  }
499
500	  if (format == 'internal') {
501		return mpa_format_date(date, 'Y-m-d');
502	  } else if (format == 'public') {
503		return mpa_format_date(date, mpa_date_format());
504	  }
505
506	  // Handle custom date format
507	  let pad = (number, length = 2) => {

508		// Use at least two zeros for a padding to support milliseconds
509		return ('00' + number).slice(-length);
510	  };
511
512	  // Go through the each symbol
513	  let isSlashed = false;
514	  let dateString = format.split('').map(char => {
515		// Handle slashes '\'
516		if (isSlashed) {
517		  isSlashed = false;
518		  return char;
519		}
520
521		// Handle any other symbols
522		switch (char) {
523		  // Handle slashes '\'
524		  case '\\':
525			isSlashed = true;
526			return '';
527		  // Day
528		  case 'j':
529			// 1 to 31
530			return date.getDate();
531		  case 'd':
532			// 01 to 31
533			return pad(date.getDate());
534		  case 'D':
535			// Mon through Sun
536			return locale.weekdays.shorthand[date.getDay()];
537		  case 'l':
538			// Monday through Sunday
539			return locale.weekdays.longhand[date.getDay()];
540		  case 'N':
541			// 1 (Monday) to 7 (Sunday)
542			return date.getDay() || 7;
543		  case 'w':
544			// 0 (Sunday) to 6 (Saturday)
545			return date.getDay();
546		  case 'z':
547			// 0 to 365
548			// Thanks to Alex Turpin https://stackoverflow.com/a/8619946
549			let yearStart = new Date(date.getFullYear(), 0, 1);
550
551			// Compensate daylight savings time
552			let timezoneOffset = yearStart.getTimezoneOffset() - date.getTimezoneOffset();
553			let diffMilliseconds = date - yearStart + timezoneOffset * 60 * 1000;
554			let millisecondsInDay = 1000 * 60 * 60 * 24;
555			return Math.floor(diffMilliseconds / millisecondsInDay);
556
557		  // Week
558		  case 'W':
559			// 1 to 52
560			// Thanks to RobG https://stackoverflow.com/a/6117889
561			// Don't modify the original date
562			let cloneDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
563			// Use 7 as a day number for Sunday
564			let currentDay = cloneDate.getUTCDay() || 7;
565			// Set to nearest Thursday: %current date% + 4 - %current day%
566			cloneDate.setUTCDate(cloneDate.getUTCDate() + 4 - currentDay);
567			// Get the first day of the year
568			let utcYear = new Date(Date.UTC(cloneDate.getUTCFullYear(), 0, 1));
569			// Calculate full weeks to nearest Thursday
570			let oneDayMs = 1000 * 60 * 60 * 24;
571			let weekNo = Math.ceil(((cloneDate - utcYear) / oneDayMs + 1) / 7);
572			return weekNo;
573
574		  // Month
575		  case 'F':
576			// January through December
577			return locale.months.longhand[date.getMonth()];
578		  case 'M':
579			// Jan through Dec
580			return locale.months.shorthand[date.getMonth()];
581		  case 'm':
582			// 01 to 12
583			return pad(date.getMonth() + 1);
584		  case 'n':
585			// 1 to 12
586			return date.getMonth() + 1;
587		  case 't':
588			// 28 to 31
589			// Here is a trick. The days are 1-based. So when we pass 0 as a day number
590			// then JS Date object goes a day before (the last day of the previous month).
591			// So that's how it works: we select the 0-day of the next month and then go
592			// to the last day of the previous (required) month
593			let lastDate = new Date(date.getFullYear(), date.getMonth() + 1, 0);
594			return lastDate.getDate();
595
596		  // Year
597		  case 'Y':
598			// Examples: 1999 or 2003
599			return date.getFullYear();
600		  case 'y':
601			// Examples: 99 or 03
602			return String(date.getFullYear()).substring(2);
603		  case 'L':
604			// 1 (it's a leap year) or 0 (otherwise)
605			return date.getFullYear() % 4 == 0 ? 1 : 0;
606
607		  // Time
608		  case 'A':
609			// AM or PM
610			return locale.amPM[date.getHours() > 11 ? 1 : 0];
611		  case 'a':
612			// am or pm
613			return locale.amPM[date.getHours() > 11 ? 1 : 0].toLowerCase();
614		  case 'H':
615			// Hours, 00 to 23
616			return pad(date.getHours());
617		  case 'h':
618			// Hours, 01 to 12
619			return pad(date.getHours() % 12 || 12);
620		  case 'G':
621			// Hours, 0 to 23
622			return date.getHours();
623		  case 'g':
624			// Hours, 1 to 12
625			return date.getHours() % 12 || 12;
626		  case 'i':
627			// Minutes, 00 to 59
628			return pad(date.getMinutes());
629		  case 's':
630			// Seconds, 00 to 59
631			return pad(date.getSeconds());
632		  case 'v':
633			// Milliseconds, 000 to 999
634			return pad(date.getMilliseconds(), 3);
635		  case 'u':
636			// Microseconds, 000000 to 999999
637			return pad(date.getMilliseconds(), 3) + '000';
638		  // Partial support
639
640		  // Timezone
641		  case 'O': // +0200
642		  case 'P':
643			// +02:00
644			let offset = -date.getTimezoneOffset();
645			let sign = offset >= 0 ? '+' : '-';
646			let hours = Math.floor(Math.abs(offset) / 60);
647			let minutes = Math.abs(offset) % 60;
648			let separator = char == 'O' ? '' : ':';
649			return sign + pad(hours) + separator + pad(minutes);
650		  case 'Z':
651			// Offset in seconds, -43200 to 50400
652			return date.getTimezoneOffset() * 60;
653
654		  // Full date/time
655		  case 'U':
656			// Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
657			return Math.floor(date.getTime() / 1000);
658		  case 'c':

659			// ISO 8601 date, like: 2004-02-12T15:19:21+00:00
660
661			// date.toISOString() will return the string with the suffix
662			// '.065Z' (milliseconds) instead of '+02:00'
663			return mpa_format_date(date, 'Y-m-d\\TH:i:sP');
664		  case 'r':
665			// RFC 2822 date, like: Thu, 21 Dec 2000 16:01:07 +0200
666
667			// date.toUTCString() will return the string with the timezone
668			// identifier suffix (GMT) instead of '+0200'
669			return mpa_format_date(date, 'D, d M Y H:i:s O');
670
671		  // Not supported
672		  case 'S': // Ordinal suffix, like: st, nd, rd or th
673		  case 'o': // ISO-8601 week-numbering year (examples: 1999 or 2003)
674		  case 'B': // Swatch Internet time
675		  case 'e': // Timezone identifier, like: UTC, GMT or Atlantic/Azores
676		  case 'T': // Timezone abbreviation, like: EST, MDT, etc.
677		  case 'I':
678			// Whether or not the date is in daylight saving time
679			return '';
680
681		  // Undefined
682		  default:
683			return char;
684		} // switch (char)
685	  }) // Map each symbol
686	  .join('');
687	  return dateString;
688	}
689
690	/**
691	 * @param {String} dateString Only the internal format is acceptable - 'Y-m-d'.
692	 * @return {Date|null}
693	 *
694	 * @since 1.0
695	 * @since 1.11.0 returns null if the date string is invalid.
696	 */
697	function mpa_parse_date(dateString) {
698	  let date = dateString.match(mpa_validate_date_pattern());
699	  if (date != null) {
700		let year = parseInt(date[1]);
701		let month = parseInt(date[2]);
702		let day = parseInt(date[3]);
703		return new Date(year, month - 1, day);
704	  } else {
705		return null;
706	  }
707	}
708
709	/**
710	 * @return {RegExp}
711	 *
712	 * @since 1.0
713	 */
714	function mpa_validate_date_pattern() {
715	  return /(\d{4})-(\d{2})-(\d{2})/;
716	}
717
718	/**
719	 * @return {Date}
720	 *
721	 * @since 1.0
722	 */
723	function mpa_today() {
724	  let today = new Date();
725	  today.setHours(0, 0, 0, 0);
726	  return today;
727	}
728
729	function getDefaultExportFromCjs (x) {
730		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
731	}
732
733	var md5$1 = {exports: {}};
734
735	var crypt = {exports: {}};
736
737	(function() {
738	  var base64map
739		  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
740
741	  crypt$1 = {
742		// Bit-wise rotation left
743		rotl: function(n, b) {
744		  return (n << b) | (n >>> (32 - b));
745		},
746
747		// Bit-wise rotation right
748		rotr: function(n, b) {
749		  return (n << (32 - b)) | (n >>> b);
750		},
751
752		// Swap big-endian to little-endian and vice versa
753		endian: function(n) {
754		  // If number given, swap endian
755		  if (n.constructor == Number) {
756			return crypt$1.rotl(n, 8) & 0x00FF00FF | crypt$1.rotl(n, 24) & 0xFF00FF00;
757		  }
758
759		  // Else, assume array and swap all items
760		  for (var i = 0; i < n.length; i++)
761			n[i] = crypt$1.endian(n[i]);
762		  return n;
763		},
764
765		// Generate an array of any length of random bytes
766		randomBytes: function(n) {
767		  for (var bytes = []; n > 0; n--)
768			bytes.push(Math.floor(Math.random() * 256));
769		  return bytes;
770		},
771
772		// Convert a byte array to big-endian 32-bit words
773		bytesToWords: function(bytes) {
774		  for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
775			words[b >>> 5] |= bytes[i] << (24 - b % 32);
776		  return words;
777		},
778
779		// Convert big-endian 32-bit words to a byte array
780		wordsToBytes: function(words) {
781		  for (var bytes = [], b = 0; b < words.length * 32; b += 8)
782			bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
783		  return bytes;
784		},
785
786		// Convert a byte array to a hex string
787		bytesToHex: function(bytes) {
788		  for (var hex = [], i = 0; i < bytes.length; i++) {
789			hex.push((bytes[i] >>> 4).toString(16));
790			hex.push((bytes[i] & 0xF).toString(16));
791		  }
792		  return hex.join('');
793		},
794
795		// Convert a hex string to a byte array
796		hexToBytes: function(hex) {
797		  for (var bytes = [], c = 0; c < hex.length; c += 2)
798			bytes.push(parseInt(hex.substr(c, 2), 16));
799		  return bytes;
800		},
801
802		// Convert a byte array to a base-64 string
803		bytesToBase64: function(bytes) {
804		  for (var base64 = [], i = 0; i < bytes.length; i += 3) {
805			var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
806			for (var j = 0; j < 4; j++)
807			  if (i * 8 + j * 6 <= bytes.length * 8)
808				base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
809			  else
810				base64.push('=');
811		  }
812		  return base64.join('');
813		},
814
815		// Convert a base-64 string to a byte array
816		base64ToBytes: function(base64) {
817		  // Remove non-base-64 characters
818		  base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
819
820		  for (var bytes = [], i = 0, imod4 = 0; i < base64.length;
821			  imod4 = ++i % 4) {
822			if (imod4 == 0) continue;
823			bytes.push(((base64map.indexOf(base64.charAt(i - 1))
824				& (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))
825				| (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));
826		  }
827		  return bytes;
828		}
829	  };
830
831	  crypt.exports = crypt$1;
832	})();
833
834	var cryptExports = crypt.exports;
835
836	var charenc = {
837	  // UTF-8 encoding
838	  utf8: {
839		// Convert a string to a byte array
840		stringToBytes: function(str) {
841		  return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
842		},
843
844		// Convert a byte array to a string
845		bytesToString: function(bytes) {
846		  return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
847		}
848	  },
849
850	  // Binary encoding
851	  bin: {
852		// Convert a string to a byte array
853		stringToBytes: function(str) {
854		  for (var bytes = [], i = 0; i < str.length; i++)
855			bytes.push(str.charCodeAt(i) & 0xFF);
856		  return bytes;
857		},
858
859		// Convert a byte array to a string
860		bytesToString: function(bytes) {
861		  for (var str = [], i = 0; i < bytes.length; i++)
862			str.push(String.fromCharCode(bytes[i]));
863		  return str.join('');
864		}
865	  }
866	};
867
868	var charenc_1 = charenc;
869
870	/*!
871	 * Determine if an object is a Buffer
872	 *
873	 * @author   Feross Aboukhadijeh <https://feross.org>
874	 * @license  MIT
875	 */
876
877	// The _isBuffer check is for Safari 5-7 support, because it's missing
878	// Object.prototype.constructor. Remove this eventually
879	var isBuffer_1 = function (obj) {
880	  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
881	};
882
883	function isBuffer (obj) {
884	  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
885	}
886
887	// For Node v0.10 support. Remove this eventually.
888	function isSlowBuffer (obj) {
889	  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
890	}
891
892	(function(){
893	  var crypt = cryptExports,
894		  utf8 = charenc_1.utf8,
895		  isBuffer = isBuffer_1,
896		  bin = charenc_1.bin,
897
898	  // The core
899	  md5 = function (message, options) {
900		// Convert to byte array
901		if (message.constructor == String)
902		  if (options && options.encoding === 'binary')
903			message = bin.stringToBytes(message);
904		  else
905			message = utf8.stringToBytes(message);
906		else if (isBuffer(message))
907		  message = Array.prototype.slice.call(message, 0);
908		else if (!Array.isArray(message) && message.constructor !== Uint8Array)
909		  message = message.toString();
910		// else, assume byte array already
911
912		var m = crypt.bytesToWords(message),
913			l = message.length * 8,
914			a =  1732584193,
915			b = -271733879,
916			c = -1732584194,
917			d =  271733878;
918
919		// Swap endian
920		for (var i = 0; i < m.length; i++) {
921		  m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |
922				 ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;
923		}
924
925		// Padding
926		m[l >>> 5] |= 0x80 << (l % 32);
927		m[(((l + 64) >>> 9) << 4) + 14] = l;
928
929		// Method shortcuts
930		var FF = md5._ff,
931			GG = md5._gg,
932			HH = md5._hh,
933			II = md5._ii;
934
935		for (var i = 0; i < m.length; i += 16) {
936
937		  var aa = a,
938			  bb = b,
939			  cc = c,
940			  dd = d;
941
942		  a = FF(a, b, c, d, m[i+ 0],  7, -680876936);
943		  d = FF(d, a, b, c, m[i+ 1], 12, -389564586);
944		  c = FF(c, d, a, b, m[i+ 2], 17,  606105819);
945		  b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);
946		  a = FF(a, b, c, d, m[i+ 4],  7, -176418897);
947		  d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);
948		  c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);
949		  b = FF(b, c, d, a, m[i+ 7], 22, -45705983);
950		  a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);
951		  d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);
952		  c = FF(c, d, a, b, m[i+10], 17, -42063);
953		  b = FF(b, c, d, a, m[i+11], 22, -1990404162);
954		  a = FF(a, b, c, d, m[i+12],  7,  1804603682);
955		  d = FF(d, a, b, c, m[i+13], 12, -40341101);
956		  c = FF(c, d, a, b, m[i+14], 17, -1502002290);
957		  b = FF(b, c, d, a, m[i+15], 22,  1236535329);
958
959		  a = GG(a, b, c, d, m[i+ 1],  5, -165796510);
960		  d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);
961		  c = GG(c, d, a, b, m[i+11], 14,  643717713);
962		  b = GG(b, c, d, a, m[i+ 0], 20, -373897302);
963		  a = GG(a, b, c, d, m[i+ 5],  5, -701558691);
964		  d = GG(d, a, b, c, m[i+10],  9,  38016083);
965		  c = GG(c, d, a, b, m[i+15], 14, -660478335);
966		  b = GG(b, c, d, a, m[i+ 4], 20, -405537848);
967		  a = GG(a, b, c, d, m[i+ 9],  5,  568446438);
968		  d = GG(d, a, b, c, m[i+14],  9, -1019803690);
969		  c = GG(c, d, a, b, m[i+ 3], 14, -187363961);
970		  b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);
971		  a = GG(a, b, c, d, m[i+13],  5, -1444681467);
972		  d = GG(d, a, b, c, m[i+ 2],  9, -51403784);
973		  c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);
974		  b = GG(b, c, d, a, m[i+12], 20, -1926607734);
975
976		  a = HH(a, b, c, d, m[i+ 5],  4, -378558);
977		  d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);
978		  c = HH(c, d, a, b, m[i+11], 16,  1839030562);
979		  b = HH(b, c, d, a, m[i+14], 23, -35309556);
980		  a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);
981		  d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);
982		  c = HH(c, d, a, b, m[i+ 7], 16, -155497632);
983		  b = HH(b, c, d, a, m[i+10], 23, -1094730640);
984		  a = HH(a, b, c, d, m[i+13],  4,  681279174);
985		  d = HH(d, a, b, c, m[i+ 0], 11, -358537222);
986		  c = HH(c, d, a, b, m[i+ 3], 16, -722521979);
987		  b = HH(b, c, d, a, m[i+ 6], 23,  76029189);
988		  a = HH(a, b, c, d, m[i+ 9],  4, -640364487);
989		  d = HH(d, a, b, c, m[i+12], 11, -421815835);
990		  c = HH(c, d, a, b, m[i+15], 16,  530742520);
991		  b = HH(b, c, d, a, m[i+ 2], 23, -995338651);
992
993		  a = II(a, b, c, d, m[i+ 0],  6, -198630844);
994		  d = II(d, a, b, c, m[i+ 7], 10,  1126891415);
995		  c = II(c, d, a, b, m[i+14], 15, -1416354905);
996		  b = II(b, c, d, a, m[i+ 5], 21, -57434055);
997		  a = II(a, b, c, d, m[i+12],  6,  1700485571);
998		  d = II(d, a, b, c, m[i+ 3], 10, -1894986606);
999		  c = II(c, d, a, b, m[i+10], 15, -1051523);
1000		  b = II(b, c, d, a, m[i+ 1], 21, -2054922799);
1001		  a = II(a, b, c, d, m[i+ 8],  6,  1873313359);
1002		  d = II(d, a, b, c, m[i+15], 10, -30611744);
1003		  c = II(c, d, a, b, m[i+ 6], 15, -1560198380);
1004		  b = II(b, c, d, a, m[i+13], 21,  1309151649);
1005		  a = II(a, b, c, d, m[i+ 4],  6, -145523070);
1006		  d = II(d, a, b, c, m[i+11], 10, -1120210379);
1007		  c = II(c, d, a, b, m[i+ 2], 15,  718787259);
1008		  b = II(b, c, d, a, m[i+ 9], 21, -343485551);
1009
1010		  a = (a + aa) >>> 0;
1011		  b = (b + bb) >>> 0;
1012		  c = (c + cc) >>> 0;
1013		  d = (d + dd) >>> 0;
1014		}
1015
1016		return crypt.endian([a, b, c, d]);
1017	  };
1018
1019	  // Auxiliary functions
1020	  md5._ff  = function (a, b, c, d, x, s, t) {
1021		var n = a + (b & c | ~b & d) + (x >>> 0) + t;
1022		return ((n << s) | (n >>> (32 - s))) + b;
1023	  };
1024	  md5._gg  = function (a, b, c, d, x, s, t) {
1025		var n = a + (b & d | c & ~d) + (x >>> 0) + t;
1026		return ((n << s) | (n >>> (32 - s))) + b;
1027	  };
1028	  md5._hh  = function (a, b, c, d, x, s, t) {
1029		var n = a + (b ^ c ^ d) + (x >>> 0) + t;
1030		return ((n << s) | (n >>> (32 - s))) + b;
1031	  };
1032	  md5._ii  = function (a, b, c, d, x, s, t) {
1033		var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
1034		return ((n << s) | (n >>> (32 - s))) + b;
1035	  };
1036
1037	  // Package private blocksize
1038	  md5._blocksize = 16;
1039	  md5._digestsize = 16;
1040
1041	  md5$1.exports = function (message, options) {
1042		if (message === undefined || message === null)
1043		  throw new Error('Illegal argument ' + message);
1044
1045		var digestbytes = crypt.wordsToBytes(md5(message, options));
1046		return options && options.asBytes ? digestbytes :
1047			options && options.asString ? bin.bytesToString(digestbytes) :
1048			crypt.bytesToHex(digestbytes);
1049	  };
1050
1051	})();
1052
1053	var md5Exports = md5$1.exports;
1054	var md5 = /*@__PURE__*/getDefaultExportFromCjs(md5Exports);
1055
1056	/**
1057	 * Notice: all nullable properties must be set till the checkout.
1058	 *
1059	 * @since 1.0
1060	 */
1061	class CartItem {
1062	  /**
1063	   * @since 1.4.0
1064	   * @access protected
1065	   */
1066	  setupProperties() {
1067		/**
1068		 * @since 1.4.0
1069		 * @var {String}
1070		 * @access protected
1071		 */
1072		this.itemId = '';
1073
1074		/**
1075		 * @since 1.4.0
1076		 * @var {Service|Null}
1077		 */
1078		this.service = null;
1079		this.serviceCategories = {};
1080
1081		/**
1082		 * @since 1.4.0
1083		 * @var {Employee|Null}
1084		 */
1085		this.employee = null;
1086
1087		/**
1088		 * @since 1.4.0
1089		 * @var {Location|Null}
1090		 */
1091		this.location = null;
1092
1093		/**
1094		 * @since 1.0
1095		 * @var {Date|Null}
1096		 */
1097		this.date = null;
1098
1099		/**
1100		 * @since 1.0
1101		 * @var {TimePeriod|Null}
1102		 */
1103		this.time = null;
1104
1105		/**
1106		 * @since 1.0
1107		 * @var {Number}
1108		 */
1109		this.capacity = 1;
1110
1111		/**
1112		 * An array of all available employees. For example, when no exact
1113		 * employee was selected on the previous steps ("- Any -").
1114		 *
1115		 * @since 1.4.0
1116		 * @var {Employee[]}
1117		 */
1118		this.availableEmployees = [];
1119
1120		/**
1121		 * An array of all available locations. For example, when no exact
1122		 * location was selected on the previous steps ("- Any -").
1123		 *
1124		 * @since 1.4.0
1125		 * @var {Location[]}
1126		 */
1127		this.availableLocations = [];
1128	  }
1129
1130	  /**
1131	   * @since 1.0
1132	   *
1133	   * @param {String} itemId
1134	   */
1135	  constructor(itemId) {
1136		this.setupProperties();
1137		this.itemId = itemId;
1138	  }
1139
1140	  /**
1141	   * @since 1.4.0
1142	   *
1143	   * @return {String}
1144	   */
1145	  getItemId() {
1146		return this.itemId;
1147	  }
1148
1149	  /**
1150	   * @since 1.4.0
1151	   *
1152	   * @return {Number[]}
1153	   */
1154	  getAvailableEmployeeIds() {

1155		return this.availableEmployees.map(entity => entity.id);
1156	  }
1157
1158	  /**
1159	   * @since 1.4.0
1160	   *
1161	   * @return {Number[]}
1162	   */
1163	  getAvailableLocationIds() {
1164		return this.availableLocations.map(entity => entity.id);
1165	  }
1166
1167	  /**
1168	   * @since 1.4.0
1169	   *
1170	   * @return {Object}
1171	   */
1172	  getAvailableIds() {
1173		return {
1174		  // service and employee can impact to time slots availability
1175		  service_id: this.service !== null ? this.service.id : 0,
1176		  employee_id: this.employee !== null ? this.employee.id : 0,
1177		  employee_ids: this.getAvailableEmployeeIds(),
1178		  location_ids: this.getAvailableLocationIds()
1179		};
1180	  }
1181
1182	  /**
1183	   * @since 1.0
1184	   *
1185	   * @return {Object}
1186	   */
1187	  getIds() {
1188		return {
1189		  service_id: this.service !== null ? this.service.id : 0,
1190		  employee_id: this.employee !== null ? this.employee.id : 0,
1191		  location_id: this.location !== null ? this.location.id : 0
1192		};
1193	  }
1194
1195	  /**
1196	   * @since 1.0
1197	   * @since 1.4.0 added the <code>fields</code> argument.
1198	   *
1199	   * @param {String} fields Optional. all|ids|period|availability. 'all' by default.
1200	   * @return {Object}
1201	   */
1202	  toArray(fields = 'all') {
1203		if (fields === 'ids') {
1204		  return this.getIds();
1205		} else if (fields === 'availability') {
1206		  return this.getAvailableIds();
1207		} else if (fields === 'period') {
1208		  return {
1209			date: this.date !== null ? mpa_format_date(this.date, 'internal') : '',
1210			time: this.time !== null ? this.time.toString('internal') : ''
1211		  };
1212		} else {
1213		  return jQuery.extend(this.getIds(), {
1214			date: this.date !== null ? mpa_format_date(this.date, 'internal') : '',
1215			time: this.time !== null ? this.time.toString('internal') : '',
1216			capacity: this.capacity
1217		  });
1218		}
1219	  }
1220
1221	  /**
1222	   * @since 1.4.0
1223	   *
1224	   * @param {String} fields Optional. all|ids|period. 'all' by default.
1225	   * @return {Boolean}
1226	   */
1227	  isSet(fields = 'all') {
1228		let isSet = true;
1229		if (fields === 'all' || fields === 'ids') {
1230		  isSet = isSet && this.service !== null && this.employee !== null && this.location !== null;
1231		}
1232		if (fields === 'all' || fields === 'period') {
1233		  isSet = isSet && this.date !== null && this.time !== null;
1234		}
1235		return isSet;
1236	  }
1237
1238	  /**
1239	   * @since 1.11.0
1240	   *
1241	   * @return {Number}
1242	   */
1243	  getPrice() {
1244		if (!this.service) {
1245		  return 0;
1246		}
1247		let employeeId = this.employee ? this.employee.id : 0;
1248		return this.service.getPrice(employeeId, this.capacity);
1249	  }
1250
1251	  /**
1252	   * @since 1.14.0
1253	   *
1254	   * @return {Number}
1255	   * @param {number} priceAfterPossibleDiscount
1256	   */
1257	  getDeposit(priceAfterPossibleDiscount) {
1258		let deposit = 0;
1259		switch (this.service.depositType) {
1260		  case 'disabled':
1261			deposit = priceAfterPossibleDiscount;
1262			break;
1263		  case 'fixed':
1264			deposit = this.service.depositAmount;
1265			break;
1266		  case 'percentage':
1267			deposit = priceAfterPossibleDiscount * this.service.depositAmount / 100;
1268			break;
1269		  default:
1270			deposit = priceAfterPossibleDiscount;
1271		}
1272		if (deposit > priceAfterPossibleDiscount) {
1273		  return priceAfterPossibleDiscount;
1274		}
1275		return deposit;
1276	  }
1277
1278	  /**
1279	   * @since 1.0
1280	   *
1281	   * @param {String} fields Optional. all|ids|availability. 'all' by default.
1282	   * @return {String} Snapshot MD5 hash.
1283	   */
1284	  getHash(fields = 'all') {
1285		return md5(JSON.stringify(this.toArray(fields)));
1286	  }
1287
1288	  /**
1289	   * @since 1.0
1290	   *
1291	   * @param {String} hash Last saved snapshot.
1292	   * @param {String} fields Optional. all|ids|availability. 'all' by default.
1293	   * @return {Boolean}
1294	   */
1295	  didChange(hash, fields = 'all') {
1296		return hash !== this.getHash(fields);
1297	  }
1298
1299	  /**
1300	   * @since 1.4.0
1301	   *
1302	   * @param {Number} employeeId
1303	   * @return {Employee|Null}
1304	   */
1305	  getEmployee(employeeId) {
1306		if (this.employee !== null && this.employee.id == employeeId) {
1307		  return this.employee;
1308		} else {
1309		  for (let employee of this.availableEmployees) {
1310			if (employee.id == employeeId) {
1311			  return employee;
1312			}
1313		  }
1314		}
1315		return null;
1316	  }
1317
1318	  /**
1319	   * @since 1.4.0
1320	   *
1321	   * @param {Number} locationId
1322	   * @return {Location|Null}
1323	   */
1324	  getLocation(locationId) {
1325		if (this.location !== null && this.location.id == locationId) {
1326		  return this.location;
1327		} else {
1328		  for (let location of this.availableLocations) {
1329			if (location.id == locationId) {
1330			  return location;
1331			}
1332		  }
1333		}
1334		return null;
1335	  }
1336
1337	  /**
1338	   * @since 1.4.0
1339	   *
1340	   * @return {Boolean}
1341	   */
1342	  hasMultipleAvailableEmployees() {
1343		return this.availableEmployees.length > 1;
1344	  }
1345
1346	  /**
1347	   * @since 1.4.0
1348	   *
1349	   * @return {Boolean}
1350	   */
1351	  hasMultipleAvailableLocations() {
1352		return this.availableLocations.length > 1;
1353	  }
1354
1355	  /**
1356	   * @since 1.4.0
1357	   *
1358	   * @return {Boolean}
1359	   */
1360	  hasMultipleAvailableVariants() {
1361		return this.hasMultipleAvailableEmployees() || this.hasMultipleAvailableLocations();
1362	  }
1363
1364	  /**
1365	   * @since 1.4.0
1366	   *
1367	   * @param {Service} service
1368	   */
1369	  setService(service) {
1370		this.service = service;
1371	  }
1372
1373	  /**
1374	   * @param {category slug: category name, ...} serviceCategories 
1375	   */
1376	  setServiceCategories(serviceCategories) {
1377		this.serviceCategories = serviceCategories;
1378	  }
1379
1380	  /**
1381	   * @since 1.4.0
1382	   *
1383	   * @param {Employee|Number} employee Employee object or ID.
1384	   * @param {Boolean} resetAvailable Optional. True by default.
1385	   */
1386	  setEmployee(employee, resetAvailable = true) {
1387		if (typeof employee === 'number') {
1388		  employee = this.getEmployee(employee);
1389		}
1390		this.employee = employee;
1391		if (resetAvailable === true) {
1392		  this.availableEmployees = [employee];
1393		}
1394	  }
1395
1396	  /**
1397	   * @since 1.4.0
1398	   *
1399	   * @param {Employee[]} availableEmployees
1400	   * @param {Boolean} resetEmployee Optional. True by default.
1401	   */
1402	  setAvailableEmployees(availableEmployees, resetEmployee = true) {
1403		this.availableEmployees = availableEmployees;
1404		if (resetEmployee === true) {
1405		  this.employee = null;
1406		}
1407	  }
1408
1409	  /**
1410	   * @since 1.4.0
1411	   *
1412	   * @param {Location|Number} location Location object or ID.
1413	   * @param {Boolean} resetAvailable Optional. True by default.
1414	   */
1415	  setLocation(location, resetAvailable = true) {
1416		if (typeof location === 'number') {
1417		  location = this.getLocation(location);
1418		}
1419		this.location = location;
1420		if (resetAvailable === true) {
1421		  this.availableLocations = [location];
1422		}
1423	  }
1424
1425	  /**
1426	   * @since 1.4.0
1427	   *
1428	   * @param {Location[]} availableLocations
1429	   * @param {Boolean} resetLocation Optional. True by default.
1430	   */
1431	  setAvailableLocations(availableLocations, resetLocation = true) {
1432		this.availableLocations = availableLocations;

1433		if (resetLocation === true) {
1434		  this.location = null;
1435		}
1436	  }
1437	}
1438
1439	/**
1440	 * @param {Array} array
1441	 * @return {Array}
1442	 *
1443	 * @since 1.0
1444	 */
1445	function mpa_array_unique(array) {
1446	  let unique = array.filter((value, index, self) => {
1447		return self.indexOf(value) === index;
1448	  });
1449	  return unique;
1450	}
1451
1452	/**
1453	 * @param {Array} array1
1454	 * @param {Array} array2
1455	 * @return {Array}
1456	 *
1457	 * @since 1.2.1
1458	 */
1459	function mpa_array_intersect(array1, array2) {
1460	  return array1.filter(value => array2.indexOf(value) != -1);
1461	}
1462
1463	/**
1464	 * @since 1.4.0
1465	 *
1466	 * @param {Array} keys
1467	 * @param {Array} values
1468	 * @return {Object}
1469	 */
1470	function mpa_array_combine(keys, values) {
1471	  let size = Math.min(keys.length, values.length);
1472	  let object = {};
1473	  for (let i = 0; i < size; i++) {
1474		object[keys[i]] = values[i];
1475	  }
1476	  return object;
1477	}
1478
1479	/**
1480	 * @since 1.4.0
1481	 *
1482	 * @param {Number} start
1483	 * @param {Number} end
1484	 * @param {Number} step Optional. 1 by default.
1485	 * @return {Array} An array of numbers from <code>start</code> to <code>end</code>
1486	 *		with step <code>step</code>.
1487	 */
1488	function mpa_array_range(start, end, step = 1) {
1489	  let validStep = step || 1; // No 0
1490	  let length = Math.abs(Math.floor((end - start) / validStep)) + 1;
1491	  let range = [...Array(length).keys()].map(i => i * step + start);
1492	  return range;
1493	}
1494
1495	/**
1496	 * @since 1.0
1497	 */
1498	class Map {
1499	  /**
1500	   * @param {Object|Null} values Optional. Starting values. Null by default.
1501	   *
1502	   * @since 1.0
1503	   */
1504	  constructor(values = null) {
1505		this.setupProperties();
1506		if (values != null) {
1507		  this.merge(values);
1508		}
1509	  }
1510
1511	  /**
1512	   * @access protected
1513	   *
1514	   * @since 1.0
1515	   */
1516	  setupProperties() {
1517		this.keys = [];
1518		this.values = {};
1519		this.length = 0;
1520	  }
1521
1522	  /**
1523	   * @param {Object} values
1524	   *
1525	   * @since 1.0
1526	   */
1527	  merge(values) {
1528		for (let key in values) {
1529		  this.push(key, values[key]);
1530		}
1531	  }
1532
1533	  /**
1534	   * @param {String|Number|Symbol} key
1535	   * @param {*} value
1536	   * @return {Boolean} Is this a new item (key) or a duplicate.
1537	   *
1538	   * @since 1.0
1539	   */
1540	  push(key, value) {
1541		let isNew = !this.includesKey(key);
1542
1543		// Add value
1544		this.values[key] = value;
1545
1546		// Add key
1547		if (isNew) {
1548		  this.keys.push(key);
1549		  this.length++;
1550		}
1551		return isNew;
1552	  }
1553
1554	  /**
1555	   * @param {String|Number|Symbol} key
1556	   * @param {*} defaultValue Optional. Null by default.
1557	   * @return {*} Item value or default value.
1558	   *
1559	   * @since 1.0
1560	   */
1561	  find(key, defaultValue = null) {
1562		if (this.includesKey(key)) {
1563		  return this.values[key];
1564		} else {
1565		  return defaultValue;
1566		}
1567	  }
1568
1569	  /**
1570	   * @param {String|Number|Symbol} key
1571	   * @param {*} defaultValue Optional. Null by default.
1572	   * @return {*} Next item value or default value.
1573	   *
1574	   * @since 1.9.0
1575	   */
1576	  findNext(key, defaultValue = null) {
1577		let nextKey = this.findNextKey(key);
1578		if (nextKey !== '') {
1579		  return this.values[nextKey];
1580		} else {
1581		  return defaultValue;
1582		}
1583	  }
1584
1585	  /**
1586	   * @param {String|Number|Symbol} key
1587	   * @return {String|Number|Symbol} Next or last key.
1588	   *
1589	   * @since 1.9.0
1590	   */
1591	  findNextKey(key) {
1592		let index = this.keys.indexOf(key);
1593		if (index === -1) {
1594		  return '';
1595		}
1596		let nextIndex = index + 1;
1597		let nextKey = nextIndex < this.length ? this.keys[nextIndex] : this.keys[index];
1598		return nextKey;
1599	  }
1600
1601	  /**
1602	   * @param {String|Number|Symbol} key
1603	   * @param {*} defaultValue Optional. Null by default.
1604	   * @return {*} Previous item value or default value.
1605	   *
1606	   * @since 1.9.0
1607	   */
1608	  findPrevious(key, defaultValue = null) {
1609		let previousKey = this.findPreviousKey(key);
1610		if (previousKey !== '') {
1611		  return this.values[previousKey];
1612		} else {
1613		  return defaultValue;
1614		}
1615	  }
1616
1617	  /**
1618	   * @param {String|Number|Symbol} key
1619	   * @return {String|Number|Symbol} Previous or first key.
1620	   *
1621	   * @since 1.9.0
1622	   */
1623	  findPreviousKey(key) {
1624		let index = this.keys.indexOf(key);
1625		if (index === -1) {
1626		  return '';
1627		}
1628		let previousIndex = index - 1;
1629		let previousKey = previousIndex >= 0 ? this.keys[previousIndex] : this.keys[index];
1630		return previousKey;
1631	  }
1632
1633	  /**
1634	   * Currently it's an alias of push() and has no difference.
1635	   *
1636	   * @param {String|Number|Symbol} key
1637	   * @param {*} value
1638	   * @return {Boolean}

1638 Is this a new item (key) or a duplicate.
1639	   *
1640	   * @since 1.0
1641	   */
1642	  update(key, value) {
1643		return this.push(key, value);
1644	  }
1645
1646	  /**
1647	   * @param {String|Number|Symbol} key
1648	   * @return {*} The removed value or null if there was no item with a such key.
1649	   *
1650	   * @since 1.0
1651	   */
1652	  remove(key) {
1653		if (!this.includesKey(key)) {
1654		  return null;
1655		}
1656		let value = this.values[key];
1657
1658		// Remove value
1659		delete this.values[key];
1660
1661		// Remove key
1662		let index = this.keys.indexOf(key);
1663		this.keys.splice(index, 1);
1664
1665		// Update length
1666		this.length--;
1667		return value;
1668	  }
1669
1670	  /**
1671	   * @return {Map}
1672	   *
1673	   * @since 1.0
1674	   */
1675	  empty() {
1676		this.keys = [];
1677		this.values = {};
1678		this.length = 0;
1679		return this;
1680	  }
1681
1682	  /**
1683	   * @return {Boolean}
1684	   *
1685	   * @since 1.0
1686	   */
1687	  isEmpty() {
1688		return this.length == 0;
1689	  }
1690
1691	  /**
1692	   * @param {String|Number|Symbol} key
1693	   * @return {Boolean}
1694	   *
1695	   * @since 1.0
1696	   */
1697	  includesKey(key) {
1698		return key in this.values;
1699	  }
1700
1701	  /**
1702	   * @since 1.6.2
1703	   *
1704	   * @return {String|null}
1705	   */
1706	  firstKey() {
1707		if (this.keys.length > 0) {
1708		  return this.keys[0];
1709		} else {
1710		  return null;
1711		}
1712	  }
1713
1714	  /**
1715	   * @since 1.6.2
1716	   *
1717	   * @return {*|null}
1718	   */
1719	  firstValue() {
1720		let firstKey = this.firstKey();
1721		if (firstKey !== null) {
1722		  return this.values[firstKey];
1723		} else {
1724		  return null;
1725		}
1726	  }
1727
1728	  /**
1729	   * @return {*}
1730	   *
1731	   * @since 1.0
1732	   */
1733	  lastValue() {
1734		let lastKey = this.lastKey();
1735		if (lastKey != null) {
1736		  return this.values[lastKey];
1737		} else {
1738		  return null;
1739		}
1740	  }
1741
1742	  /**
1743	   * @return {String|Number|Symbol|Null}
1744	   *
1745	   * @since 1.0
1746	   */
1747	  lastKey() {
1748		if (!this.isEmpty()) {
1749		  return this.keys[this.length - 1];
1750		} else {
1751		  return null;
1752		}
1753	  }
1754
1755	  /**
1756	   * @return {Array}
1757	   *
1758	   * @since 1.0
1759	   */
1760	  cloneKeys() {
1761		return [...this.keys];
1762	  }
1763
1764	  /**
1765	   * @param {String|Number|Symbol} column
1766	   * @return {Array} Column values (only unique ones).
1767	   *
1768	   * @since 1.0
1769	   */
1770	  getColumn(column) {
1771		let values = [];
1772		for (let key of this.keys) {
1773		  let value = this.values[key][column];
1774		  if (value != undefined) {
1775			if (Array.isArray(value)) {
1776			  // Merge arrays
1777			  values = values.concat(value);
1778			} else {
1779			  // Add value to array
1780			  values.push(value);
1781			}
1782		  }
1783		}
1784		return mpa_array_unique(values);
1785	  }
1786
1787	  /**
1788	   * @param {Function} callback
1789	   *
1790	   * @since 1.0
1791	   */
1792	  forEach(callback) {
1793		let i = 0;
1794		for (let key of this.keys) {
1795		  let response = callback(this.values[key], i, key, this);
1796		  i++;
1797		  if (response === false) {
1798			break;
1799		  }
1800		}
1801	  }
1802
1803	  /**
1804	   * @param {Function} callback
1805	   * @return {Array} May have duplicates.
1806	   *
1807	   * @since 1.0
1808	   */
1809	  map(callback) {
1810		let values = [];
1811		let i = 0;
1812		for (let key of this.keys) {
1813		  values.push(callback(this.values[key], i, key, this));
1814		  i++;
1815		}
1816		return values;
1817	  }
1818
1819	  /**
1820	   * @return {Array}
1821	   *
1822	   * @since 1.0
1823	   */
1824	  toArray() {
1825		let values = [];
1826		for (let key of this.keys) {
1827		  values.push(this.values[key]);
1828		}
1829		return values;
1830	  }
1831	}
1832
1833	let globals = {};
1834
1835	/**
1836	 * @param {*} value
1837	 * @param {Boolean} strict Optional. Don't count non-iterable types. False by
1838	 *     default.
1839	 * @return {Number}
1840	 *
1841	 * @since 1.0
1842	 */
1843	function mpa_count(value, strict = false) {
1844	  if (typeof value == 'object') {
1845		if (Array.isArray(value)) {
1846		  return value.length;
1847		} else {
1848		  return Object.keys(value).length;
1849		}
1850	  } else {
1851		return strict ? 0 : 1;
1852	  }
1853	}
1854
1855	/**
1856	 * @param {*} value
1857	 * @param {Boolean} strict Optional. False by default.
1858	 * @return {Boolean}
1859	 *
1860	 * @since 1.0
1861	 */
1862	function mpa_empty(value, strict = false) {
1863	  if (typeof value == 'object') {
1864		return mpa_count(value) == 0;
1865	  } else {
1866		return strict ? true : !value;
1867	  }
1868	}
1869
1870	/**
1871	 * @param {String} prefix Optional. '' by default.
1872	 * @param {Boolean} moreEntropy Optional. False by default.
1873	 * @return {String}
1874	 *
1875	 * @see https://locutus.io/php/misc/uniqid/
1876	 *
1877	 * @since 1.0
1878	 */
1879	function mpa_uniqid(prefix = '', moreEntropy = false) {
1880	  let mpa_format_seed = function (seed, requiredWidth) {
1881		seed = parseInt(seed, 10).toString(16); // To hex string
1882
1883		if (requiredWidth < seed.length) {
1884		  // So long we split
1885		  return seed.slice(seed.length - requiredWidth);
1886		} else if (requiredWidth > seed.length) {
1887		  // So short we pad
1888		  return Array(1 + (requiredWidth - seed.length)).join('0') + seed;
1889		} else {
1890		  // Exact width
1891		  return seed;
1892		}
1893	  };
1894	  if (!globals.uniqid_seed) {
1895		// Init seed with big random int
1896		globals.uniqid_seed = Math.floor(Math.random() * 0x75bcd15);
1897	  }
1898	  globals.uniqid_seed++;
1899
1900	  // Start with prefix
1901	  let id = prefix;
1902	  // Add current milliseconds (hex string)
1903	  id += mpa_format_seed(parseInt(new Date().getTime() / 1000, 10), 8);
1904	  // Add seed hex string
1905	  id += mpa_format_seed(globals.uniqid_seed, 5);
1906	  if (moreEntropy) {
1907		// For more entropy we add a float lowe to 10
1908		id += (Math.random() * 10).toFixed(8).toString();
1909	  }
1910	  return id;
1911	}
1912
1913	/**
1914	 * @since 1.0
1915	 */
1916	class Cart {
1917	  /**
1918	   * @since 1.4.0
1919	   * @access protected
1920	   */
1921	  setupProperties() {
1922		/**
1923		 * @since 1.0
1924		 * @var {Map}
1925		 */
1926		this.items = new Map();
1927
1928		/**
1929		 * @since 1.4.0 (Replaced the property <code>selectedItem</code>)
1930		 * @var {CartItem|Null}
1931		 */
1932		this.activeItem = null;
1933
1934		/**
1935		 * @since 1.0
1936		 * @var {Object}
1937		 */
1938		this.customerDetails = {
1939		  name: '',
1940		  email: '',
1941		  phone: ''
1942		};
1943
1944		/**
1945		 * @since 1.5.0
1946		 * @var {Object}
1947		 */
1948		this.paymentDetails = {
1949		  booking_id: 0,
1950		  gateway_id: 'none'
1951		};
1952
1953		/**
1954		 * @since 1.11.0
1955		 * @var {Coupon|Null}
1956		 */
1957		this.coupon = null;
1958	  }
1959
1960	  /**
1961	   * @since 1.0
1962	   */
1963	  constructor() {
1964		this.setupProperties();
1965	  }
1966
1967	  /**
1968	   * @since 1.0
1969	   * @since 1.4.0 added the <code>itemId</code> argument.
1970	   * @since 1.4.0 returns <code>CartItem</code> object instead of item identifier.
1971	   *
1972	   * @param {String} itemId Optional.
1973	   * @return {CartItem} New item.
1974	   */
1975	  createItem(itemId = '') {
1976		if (!itemId) {
1977		  itemId = mpa_uniqid();
1978		}
1979		let item = new CartItem(itemId);
1980		this.items.push(itemId, item);
1981		this.activeItem = item;
1982		return item;
1983	  }
1984
1985	  /**
1986	   * @since 1.0
1987	   *
1988	   * @param {String} itemId
1989	   * @return {CartItem|Null}
1990	   */
1991	  getItem(itemId) {
1992		return this.items.find(itemId);
1993	  }
1994
1995	  /**
1996	   * @since 1.4.0
1997	   *
1998	   * @return {CartItem|Null}
1999	   */
2000	  getActiveItem() {
2001		return this.activeItem;
2002	  }
2003
2004	  /**
2005	   * @since 1.4.0
2006	   *
2007	   * @return {String}
2008	   */
2009	  getActiveItemId() {
2010		if (this.activeItem !== null) {
2011		  return this.activeItem.getItemId();
2012		} else {
2013		  return '';
2014		}
2015	  }
2016
2017	  /**
2018	   * @since 1.4.0
2019	   *
2020	   * @return {Number}
2021	   */
2022	  getItemsCount() {
2023		return this.items.length;
2024	  }
2025
2026	  /**
2027	   * @since 1.4.0
2028	   *
2029	   * @param {String|CartItem} item
2030	   */
2031	  setActiveItem(item) {
2032		if (typeof item === 'string') {
2033		  this.activeItem = this.getItem(item);
2034		} else {
2035		  this.activeItem = item;
2036		}
2037	  }
2038
2039	  /**
2040	   * @since 1.4.0
2041	   *
2042	   * @param {String|CartItem} item
2043	   */
2044	  removeItem(item) {
2045		if (typeof item === 'string') {
2046		  this.items.remove(item);
2047		} else {
2048		  this.items.remove(item.getItemId());
2049		}
2050	  }
2051
2052	  /**
2053	   * @since 1.4.0
2054	   *
2055	   * @return {Boolean}
2056	   */
2057	  isEmpty() {
2058		return this.getItemsCount() === 0;
2059	  }
2060
2061	  /**
2062	   * @since 1.4.0
2063	   *
2064	   * @return {Object} {Product name: Product price}
2065	   */
2066	  getProductPrices() {
2067		let products = [];

2068		this.items.forEach(cartItem => {
2069		  if (cartItem.service != null) {
2070			products.push({
2071			  name: cartItem.service.name,
2072			  price: cartItem.getPrice()
2073			});
2074		  }
2075		});
2076		return products;
2077	  }
2078
2079	  /**
2080	   * @since 1.4.0
2081	   *
2082	   * @param {Array|Null} products Optional. List of products to calculate the
2083	   *		subtotal price. Products of the cart by default.
2084	   * @return {Number}
2085	   */
2086	  getSubtotalPrice(products = null) {
2087		if (products === null) {
2088		  products = this.getProductPrices();
2089		}
2090		let subtotal = 0;
2091		for (let product of products) {
2092		  subtotal += product.price;
2093		}
2094		return subtotal;
2095	  }
2096
2097	  /**
2098	   * @since 1.4.0
2099	   *
2100	   * @param {Object|Null} products Optional. List of products to calculate the
2101	   *		total price. Products of the cart by default.
2102	   * @return {Number}
2103	   */
2104	  getTotalPrice(products = null) {
2105		let subtotalPrice = this.getSubtotalPrice(products);
2106		if (this.hasCoupon()) {
2107		  let discountPrice = this.coupon.calcDiscountAmount(this);
2108		  return Math.max(0, subtotalPrice - discountPrice);
2109		} else {
2110		  return subtotalPrice;
2111		}
2112	  }
2113
2114	  /**
2115	   * @since 1.14.0
2116	   * @return {Number}
2117	   */
2118	  getDeposit() {
2119		let deposit = 0;
2120		this.items.forEach(cartItem => {
2121		  // TODO: ask all prices via ajax call to avoid calculation duplication
2122		  let price = cartItem.getPrice();
2123		  if (this.hasCoupon()) {
2124			price = price - this.coupon.calcDiscountForCartItem(cartItem);
2125		  }
2126		  deposit += cartItem.getDeposit(price);
2127		});
2128		return deposit;
2129	  }
2130
2131	  /**
2132	   * @since 1.5.0
2133	   *
2134	   * @return {Object}
2135	   */
2136	  getCustomer() {
2137		return this.customerDetails;
2138	  }
2139
2140	  /**
2141	   * @since 1.4.0
2142	   *
2143	   * @return {Object}
2144	   */
2145	  getOrder() {
2146		let products = this.getProductPrices();
2147		let order = {
2148		  products: products,
2149		  subtotal: this.getSubtotalPrice(products),
2150		  total: this.getTotalPrice(products),
2151		  customer: this.getCustomer()
2152		};
2153		if (this.hasCoupon()) {
2154		  order['coupon'] = {
2155			code: this.coupon.getCode(),
2156			amount: this.coupon.calcDiscountAmount(this)
2157		  };
2158		}
2159		order['deposit'] = this.getDeposit();
2160		return order;
2161	  }
2162
2163	  /**
2164	   * @since 1.5.0
2165	   *
2166	   * @return {Object}
2167	   */
2168	  getPaymentDetails() {
2169		return this.paymentDetails;
2170	  }
2171
2172	  /**
2173	   * @since 1.0
2174	   * @since 1.4.0 added the <code>fields</code> argument.
2175	   *
2176	   * @param {String} fields Optional. all|items. 'all' by default.
2177	   * @return {Object|Array}
2178	   */
2179	  toArray(fields = 'all') {
2180		let cart = {
2181		  items: [],
2182		  customer: this.customerDetails
2183		};
2184
2185		// Add items
2186		this.items.forEach(cartItem => {
2187		  if (!cartItem.isSet()) {
2188			return;
2189		  }
2190		  cart.items.push(cartItem.toArray());
2191		});
2192
2193		// Add payment details
2194		if (mpapp().settings().isPaymentsEnabled()) {
2195		  cart.payment_details = this.paymentDetails;
2196		}
2197
2198		// Add coupon
2199		if (this.hasCoupon()) {
2200		  cart['coupon'] = this.coupon.getCode();
2201		}
2202		if (fields === 'items') {
2203		  return cart.items;
2204		} else {
2205		  return cart;
2206		}
2207	  }
2208
2209	  /**
2210	   * @since 1.5.0
2211	   *
2212	   * @param {String} fields Optional. all|order|items. 'all' by default.
2213	   * @return {String} Snapshot MD5 hash.
2214	   */
2215	  getHash(fields = 'all') {
2216		if (fields !== 'order') {
2217		  return md5(JSON.stringify(this.toArray(fields)));
2218		} else {
2219		  return md5(JSON.stringify(this.getOrder()));
2220		}
2221	  }
2222
2223	  /**
2224	   * @since 1.5.0
2225	   *
2226	   * @param {String} hash Last saved snapshot.
2227	   * @param {String} fields Optional. all|order|items. 'all' by default.
2228	   * @return {Boolean}
2229	   */
2230	  didChange(hash, fields = 'all') {
2231		return hash !== this.getHash(fields);
2232	  }
2233
2234	  /**
2235	   * @since 1.4.0 (Replaced the method <code>addCustomerDetails()</code>)
2236	   *
2237	   * @param {Object} customerDetails
2238	   */
2239	  setCustomerDetails(customerDetails) {
2240		jQuery.extend(this.customerDetails, customerDetails);
2241	  }
2242
2243	  /**
2244	   * @since 1.5.0
2245	   *
2246	   * @param {Object} paymentDetails
2247	   */
2248	  setPaymentDetails(paymentDetails) {
2249		jQuery.extend(this.paymentDetails, paymentDetails);
2250	  }
2251
2252	  /**
2253	   * @since 1.6.2
2254	   */
2255	  reset() {
2256		this.setupProperties();
2257	  }
2258
2259	  /**
2260	   * @since 1.9.0
2261	   *
2262	   * @return {Date}
2263	   */
2264	  getMinDate() {
2265		let minDate = null;

2266		this.items.forEach(cartItem => {
2267		  if (!cartItem.date) {
2268			return;
2269		  }
2270		  if (!minDate || minDate > cartItem.date) {
2271			minDate = new Date(cartItem.date.getTime());
2272		  }
2273		});
2274		return minDate || mpa_today();
2275	  }
2276
2277	  /**
2278	   * @since 1.9.0
2279	   *
2280	   * @return {Number[]}
2281	   */
2282	  getServiceIds() {
2283		let serviceIds = this.items.map(cartItem => {
2284		  return cartItem.service != null ? cartItem.service.id : 0;
2285		});
2286		serviceIds = mpa_array_unique(serviceIds);
2287		return serviceIds;
2288	  }
2289
2290	  /**
2291	   * @since 1.9.0
2292	   *
2293	   * @param {Service[]} services
2294	   */
2295	  updateServices(services) {
2296		for (let service of services) {
2297		  this.items.forEach(cartItem => {
2298			if (cartItem.service != null && cartItem.service.id === service.id) {
2299			  cartItem.service = service;
2300			}
2301		  });
2302		}
2303	  }
2304
2305	  /**
2306	   * @since 1.11.0
2307	   *
2308	   * @param {Coupon} coupon
2309	   */
2310	  setCoupon(coupon) {
2311		this.coupon = coupon;
2312	  }
2313
2314	  /**
2315	   * @since 1.11.0
2316	   */
2317	  removeCoupon() {
2318		this.coupon = null;
2319	  }
2320
2321	  /**
2322	   * @since 1.11.0
2323	   */
2324	  hasCoupon() {
2325		return this.coupon != null;
2326	  }
2327
2328	  /**
2329	   * @since 1.11.0
2330	   */
2331	  testCoupon() {
2332		if (this.hasCoupon() && !this.coupon.isApplicableForCart(this)) {
2333		  this.removeCoupon();
2334		}
2335	  }
2336	}
2337
2338	/**
2339	 * @abstract
2340	 *
2341	 * @since 1.0
2342	 */
2343	class AbstractEntity {
2344	  /**
2345	   * @param {Number} id
2346	   * @param {Object} properties Optional.
2347	   *
2348	   * @since 1.0
2349	   */
2350	  constructor(id, properties = {}) {
2351		this.id = id;
2352		this.setupProperties();
2353		this.setupValues(properties);
2354	  }
2355
2356	  /**
2357	   * @access protected
2358	   *
2359	   * @since 1.0
2360	   */
2361	  setupProperties() {}
2362
2363	  /**
2364	   * @param {Object} properties
2365	   *
2366	   * @access protected
2367	   *
2368	   * @since 1.0
2369	   */
2370	  setupValues(properties) {
2371		for (let property in properties) {
2372		  this[property] = properties[property];
2373		}
2374	  }
2375
2376	  /**
2377	   * @return {Number}
2378	   *
2379	   * @since 1.11.0
2380	   */
2381	  getId() {
2382		return this.id;
2383	  }
2384	}
2385
2386	/**
2387	 * Draft version just to present employee as an object in some code.
2388	 *
2389	 * @since 1.4.0
2390	 */
2391	class Employee extends AbstractEntity {
2392	  /**
2393	   * @since 1.4.0
2394	   * @access protected
2395	   */
2396	  setupProperties() {
2397		super.setupProperties();
2398		this.name = '';
2399	  }
2400	}
2401
2402	/**
2403	 * Draft version just to present location as an object in some code.
2404	 *
2405	 * @since 1.4.0
2406	 */
2407	class Location extends AbstractEntity {
2408	  /**
2409	   * @since 1.4.0
2410	   * @access protected
2411	   */
2412	  setupProperties() {
2413		super.setupProperties();
2414		this.name = '';
2415	  }
2416	}
2417
2418	/**
2419	 * @since 1.0
2420	 */
2421	class Service extends AbstractEntity {
2422	  /**
2423	   * @since 1.0
2424	   * @access protected
2425	   */
2426	  setupProperties() {
2427		// Declare only the required minimum for methods. Still get all fields
2428		// from REST requests
2429		super.setupProperties();
2430		this.name = '';
2431		this.price = 0;
2432
2433		/**
2434		 *  @since 1.14.0
2435		 *  string disabled|fixed|percentage
2436		 */
2437		this.depositType = 'disabled';
2438		/**
2439		 *  @since 1.14.0
2440		 */
2441		this.depositAmount = 0;
2442		this.duration = 0; // Minutes
2443
2444		this.bufferTimeBefore = 0; // Minutes
2445		this.bufferTimeAfter = 0; // Minutes
2446		this.timeBeforeBooking = 0; // Minutes
2447		this.maxAdvanceTimeBeforeReservation = 0; // Minutes
2448
2449		this.minCapacity = 1;
2450		this.maxCapacity = 1;
2451		this.multiplyPrice = false;
2452		this.variations = {}; // {Employee ID: {employee, price, duration, min_capacity, max_capacity}}
2453
2454		/** @since 1.4.0 */
2455		this.image = '';
2456
2457		/** @since 1.4.0 */
2458		this.thumbnail = '';
2459	  }
2460
2461	  /**
2462	   * @since 1.0
2463	   * @since 1.3.1 added the <code>capacity</code> argument.
2464	   *
2465	   * @param {Number} employeeId Optional. 0 by default.
2466	   * @param {Number} capacity Optional. 0 by default (minimum capacity of the
2467	   *     service).
2468	   * @return {Number}
2469	   */
2470	  getPrice(employeeId = 0, capacity = 0) {
2471		if (!capacity) {
2472		  capacity = this.minCapacity;
2473		}
2474		let price = this.getVariation('price', employeeId, this.price);
2475		if (this.multiplyPrice) {
2476		  price *= capacity;
2477		}
2478		return price;
2479	  }
2480
2481	  /**
2482	   * @since 1.0
2483	   *
2484	   * @param {Number} employeeId Optional.
2485	   * @return {Number}
2486	   */
2487	  getDuration(employeeId = 0) {
2488		return this.getVariation('duration', employeeId, this.duration);
2489	  }
2490
2491	  /**
2492	   * @since 1.3.1
2493	   *
2494	   * @param {Number} employeeId Optional.
2495	   * @return {Number}
2496	   */
2497	  getMinCapacity(employeeId = 0) {
2498		return this.getVariation('min_capacity', employeeId, this.minCapacity);
2499	  }
2500
2501	  /**
2502	   * @since 1.3.1
2503	   *
2504	   * @param {Number} employeeId Optional.
2505	   * @return {Number}
2506	   */
2507	  getMaxCapacity(employeeId = 0) {
2508		return this.getVariation('max_capacity', employeeId, this.maxCapacity);
2509	  }
2510
2511	  /**
2512	   * @since 1.9.0
2513	   *
2514	   * @param {Number} employeeId Optional.
2515	   * @return {Number[]}
2516	   */
2517	  getCapacityRange(employeeId = 0) {
2518		let minCapacity = this.getMinCapacity(employeeId);
2519		let maxCapacity = this.getMaxCapacity(employeeId);
2520		return mpa_array_range(minCapacity, maxCapacity);
2521	  }
2522
2523	  /**
2524	   * @since 1.3.1
2525	   *
2526	   * @param {Number} employeeId Optional.
2527	   * @return {Number} The maximum number of guests in range [0; ∞).
2528	   *
2529	   * @todo Not used. Remove after implementing the Events feature.
2530	   */
2531	  getMaxGuests(employeeId = 0) {
2532		let maxCapacity = this.getMaxCapacity(employeeId);
2533		let minCapacity = this.getMinCapacity(employeeId);
2534		let maxGuests = maxCapacity - minCapacity;
2535		return Math.max(0, maxGuests);
2536	  }
2537
2538	  /**
2539	   * @since 1.3.1
2540	   * @access protected
2541	   *
2542	   * @param {String} field
2543	   * @param {Number} employeeId
2544	   * @param {*} defaultValue
2545	   * @return {*}
2546	   */
2547	  getVariation(field, employeeId, defaultValue) {
2548		if (employeeId in this.variations) {
2549		  return this.variations[employeeId][field];
2550		} else {
2551		  return defaultValue;
2552		}
2553	  }
2554	}
2555

2556	/**
2557	 * @since 1.4.0
2558	 */
2559	class EntityUtils {
2560	  /**
2561	   * @since 1.4.0
2562	   *
2563	   * @param {AbstractEntity} entity
2564	   * @param {AbstractRepository} repository
2565	   * @param {Boolean} forceReload Optional. False by default.
2566	   * @return {Promise}
2567	   */
2568	  static loadInBackground(entity, repository, forceReload = false) {
2569		return repository.findById(entity.id, forceReload).then(loadedEntity => {
2570		  // If got real result (not null)...
2571		  if (loadedEntity !== null) {
2572			// ... then copy all property values to existing entity
2573			for (let property in loadedEntity) {
2574			  entity[property] = loadedEntity[property];
2575			}
2576		  }
2577		  return loadedEntity;
2578		});
2579	  }
2580	}
2581
2582	/**
2583	 * @since 1.11.0
2584	 */
2585	class Coupon extends AbstractEntity {
2586	  setupProperties() {
2587		super.setupProperties();
2588		this.status = 'new';
2589		this.code = '';
2590		this.description = '';
2591		this.type = 'fixed';
2592		this.amount = 0;
2593		this.expirationDate = null;
2594		this.serviceIds = [];
2595		this.minDate = null;
2596		this.maxDate = null;
2597		this.usageLimit = 0;
2598		this.usageCount = 0;
2599	  }
2600
2601	  /**
2602	   * @access protected
2603	   *
2604	   * @param {Object} properties
2605	   */
2606	  setupValues(properties) {
2607		// Parse dates
2608		for (let dateProperty of ['expirationDate', 'minDate', 'maxDate']) {
2609		  let dateValue = properties[dateProperty];
2610		  if (dateValue != null && dateValue !== '') {
2611			this[dateProperty] = mpa_parse_date(dateValue);
2612		  }
2613		  delete properties[dateProperty];
2614		}
2615
2616		// Set up other properties
2617		super.setupValues(properties);
2618	  }
2619
2620	  /**
2621	   * @return {String}
2622	   */
2623	  getCode() {
2624		return this.code;
2625	  }
2626
2627	  /**
2628	   * @param {Cart} cart
2629	   * @return {Boolean}
2630	   */
2631	  isApplicableForCart(cart) {
2632		let isApplicable = false;
2633		cart.items.forEach(cartItem => {
2634		  if (this.isApplicableForCartItem(cartItem)) {
2635			isApplicable = true;
2636			return false; // Stop the cycle
2637		  }
2638		});
2639
2640		return isApplicable;
2641	  }
2642
2643	  /**
2644	   * @param {CartItem} cartItem
2645	   * @return {Boolean}
2646	   */
2647	  isApplicableForCartItem(cartItem) {
2648		if (!cartItem.isSet()) {
2649		  return false;
2650		}
2651		if (this.serviceIds.length > 0 && this.serviceIds.indexOf(cartItem.service.id) == -1) {
2652		  return false;
2653		}
2654		if (this.minDate != null && cartItem.date < this.minDate) {
2655		  return false;
2656		}
2657		if (this.maxDate != null && cartItem.date > this.maxDate) {
2658		  return false;
2659		}
2660
2661		// Applicable
2662		return true;
2663	  }
2664
2665	  /**
2666	   * @param {Cart} cart
2667	   * @return {Number}
2668	   */
2669	  calcDiscountAmount(cart) {
2670		let discountPrice = this.calcDiscountForCart(cart);
2671		return Math.min(discountPrice, cart.getSubtotalPrice());
2672	  }
2673
2674	  /**
2675	   * @access protected
2676	   *
2677	   * @param {Cart} cart
2678	   * @return {Number}
2679	   */
2680	  calcDiscountForCart(cart) {
2681		let discount = 0;
2682		cart.items.forEach(cartItem => {
2683		  discount += this.calcDiscountForCartItem(cartItem);
2684		});
2685		return discount;
2686	  }
2687
2688	  /**
2689	   * @access protected
2690	   *
2691	   * @param {CartItem} cartItem
2692	   * @return {Number}
2693	   */
2694	  calcDiscountForCartItem(cartItem) {
2695		let discountPrice = 0;
2696		if (this.isApplicableForCartItem(cartItem)) {
2697		  let itemPrice = cartItem.getPrice();
2698		  switch (this.type) {
2699			case 'fixed':
2700			  discountPrice = this.amount;
2701			  break;
2702			case 'percentage':
2703			  discountPrice = itemPrice * this.amount / 100;
2704			  break;
2705		  }
2706
2707		  // Don't exceed with amount > 100%
2708		  discountPrice = Math.min(discountPrice, itemPrice);
2709		}
2710		return discountPrice;
2711	  }
2712	}
2713
2714	/**
2715	 * @param {Number} number
2716	 * @param {Number} decimals
2717	 * @param {String} decimalSeparator
2718	 * @param {String} thousandsSeparator
2719	 * @return {String}
2720	 *
2721	 * @since 1.0
2722	 */
2723	function mpa_number_format(number, decimals = 0, decimalSeparator = '.', thousandsSeparator = ',') {
2724	  // + Original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
2725	  // + Improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
2726	  // +   Bugfix by: Michael White (http://crestidg.com)
2727	  let sign = '',
2728		i,
2729		j,
2730		kw,
2731		kd,
2732		km;
2733	  if (number < 0) {
2734		sign = '-';
2735		number *= -1;
2736	  }
2737	  i = parseInt(number = (+number || 0).toFixed(decimals)) + '';
2738	  if ((j = i.length) > 3) {
2739		j = j % 3;
2740	  } else {
2741		j = 0;
2742	  }
2743	  km = j ? i.substr(0, j) + thousandsSeparator : '';
2744	  kw = i.substr(j).replace(/(\d{3})(?=\d)/g, '$1' + thousandsSeparator);
2745	  kd = decimals ? decimalSeparator + Math.abs(number - i).toFixed(decimals).replace(/-/, 0).slice(2) : '';
2746	  return sign + km + kw + kd;
2747	}
2748
2749	/**
2750	 * @param {String} string
2751	 * @return {String}
2752	 *
2753	 * @since 1.0
2754	 */
2755	function mpa_unprefix(string) {
2756	  if (string.indexOf('mpa_') === 0) {
2757		return string.substring(4); // Remove the public prefix
2758	  } else if (string.indexOf('_mpa_') === 0) {
2759		return string.substring(5); // Remove the private prefix
2760	  } else {
2761		return string; // Already without the prefix
2762	  }
2763	}
2764