";
+ return div.innerHTML.indexOf('
') > 0
+}
+
+// #3663: IE encodes newlines inside attribute values while other browsers don't
+var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+// #6828: chrome encodes content in a[href]
+var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
+
+/* */
+
+var idToTemplate = cached(function (id) {
+ var el = query(id);
+ return el && el.innerHTML
+});
+
+var mount = Vue.prototype.$mount;
+Vue.prototype.$mount = function (
+ el,
+ hydrating
+) {
+ el = el && query(el);
+
+ /* istanbul ignore if */
+ if (el === document.body || el === document.documentElement) {
+ "development" !== 'production' && warn(
+ "Do not mount Vue to or - mount to normal elements instead."
+ );
+ return this
+ }
+
+ var options = this.$options;
+ // resolve template/el and convert to render function
+ if (!options.render) {
+ var template = options.template;
+ if (template) {
+ if (typeof template === 'string') {
+ if (template.charAt(0) === '#') {
+ template = idToTemplate(template);
+ /* istanbul ignore if */
+ if ("development" !== 'production' && !template) {
+ warn(
+ ("Template element not found or is empty: " + (options.template)),
+ this
+ );
+ }
+ }
+ } else if (template.nodeType) {
+ template = template.innerHTML;
+ } else {
+ if (true) {
+ warn('invalid template option:' + template, this);
+ }
+ return this
+ }
+ } else if (el) {
+ template = getOuterHTML(el);
+ }
+ if (template) {
+ /* istanbul ignore if */
+ if ("development" !== 'production' && config.performance && mark) {
+ mark('compile');
+ }
+
+ var ref = compileToFunctions(template, {
+ shouldDecodeNewlines: shouldDecodeNewlines,
+ shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+ delimiters: options.delimiters,
+ comments: options.comments
+ }, this);
+ var render = ref.render;
+ var staticRenderFns = ref.staticRenderFns;
+ options.render = render;
+ options.staticRenderFns = staticRenderFns;
+
+ /* istanbul ignore if */
+ if ("development" !== 'production' && config.performance && mark) {
+ mark('compile end');
+ measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+ }
+ }
+ }
+ return mount.call(this, el, hydrating)
+};
+
+/**
+ * Get outerHTML of elements, taking care
+ * of SVG elements in IE as well.
+ */
+function getOuterHTML (el) {
+ if (el.outerHTML) {
+ return el.outerHTML
+ } else {
+ var container = document.createElement('div');
+ container.appendChild(el.cloneNode(true));
+ return container.innerHTML
+ }
+}
+
+Vue.compile = compileToFunctions;
+
+module.exports = Vue;
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2), __webpack_require__(24).setImmediate))
+
+/***/ }),
+/* 7 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return createShortcuts; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return globalShortcuts; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return previewShortcuts; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return updateShortcuts; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return showKeyMap; });
+/**
+ * Global shortcuts.
+ * @type {*[]}
+ */
+var globalShortcuts = [{
+ stroke: 'Ctrl + C',
+ description: 'Trigger creation of a new Pattern.'
+}, {
+ stroke: 'Ctrl + K',
+ description: 'Show/hide the shortcuts on the current page.'
+}];
+
+/**
+ * Keyboard shortcuts on the create component.
+ * @type {*[]}
+ */
+var createShortcuts = [{
+ stroke: 'Ctrl + S',
+ description: 'Save the newly created Pattern.'
+}, {
+ stroke: 'ESC',
+ description: 'Cancel the creation of the new Pattern.'
+}];
+
+/**
+ * Keyboard shortcuts on the preview component.
+ * @type {*[]}
+ */
+var previewShortcuts = [{
+ stroke: 'Ctrl + DEL',
+ description: 'Trigger deletion of the Pattern.'
+}, {
+ stroke: 'ESC',
+ description: 'Cancel deletion of the Pattern.'
+}, {
+ stroke: 'Ctrl + S',
+ description: 'Save the edited description of the Pattern.'
+}, {
+ stroke: 'ESC',
+ description: 'Cancel edit mode of the Pattern\'s description.'
+}];
+
+/**
+ * Keyboard shortcuts on the update component.
+ * @type {*[]}
+ */
+var updateShortcuts = [{
+ stroke: 'Ctrl + S',
+ description: 'Save the new name of the Pattern.'
+}, {
+ stroke: 'ESC',
+ description: 'Cancel the renaming of the Pattern.'
+}];
+
+/**
+ * Exported function that should be used as a computed property.
+ * @returns {getters.showKeyMap|boolean|*}
+ */
+var showKeyMap = function showKeyMap() {
+ return this.$store.getters.showKeyMap;
+};
+
+
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var disposed = false
+var normalizeComponent = __webpack_require__(0)
+/* script */
+var __vue_script__ = __webpack_require__(51)
+/* template */
+var __vue_template__ = __webpack_require__(52)
+/* template functional */
+var __vue_template_functional__ = false
+/* styles */
+var __vue_styles__ = null
+/* scopeId */
+var __vue_scopeId__ = null
+/* moduleIdentifier (server only) */
+var __vue_module_identifier__ = null
+var Component = normalizeComponent(
+ __vue_script__,
+ __vue_template__,
+ __vue_template_functional__,
+ __vue_styles__,
+ __vue_scopeId__,
+ __vue_module_identifier__
+)
+Component.options.__file = "resources/js/components/Shortcuts.vue"
+
+/* hot reload */
+if (false) {(function () {
+ var hotAPI = require("vue-hot-reload-api")
+ hotAPI.install(require("vue"), false)
+ if (!hotAPI.compatible) return
+ module.hot.accept()
+ if (!module.hot.data) {
+ hotAPI.createRecord("data-v-1f5e1892", Component.options)
+ } else {
+ hotAPI.reload("data-v-1f5e1892", Component.options)
+ }
+ module.hot.dispose(function (data) {
+ disposed = true
+ })
+})()}
+
+module.exports = Component.exports
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports) {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things. But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals. It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+ throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+ throw new Error('clearTimeout has not been defined');
+}
+(function () {
+ try {
+ if (typeof setTimeout === 'function') {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === 'function') {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+} ())
+function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ // if setTimeout wasn't available but was latter defined
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+
+
+}
+function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ // if clearTimeout wasn't available but was latter defined
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+}
+
+function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+}
+Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+
+var utils = __webpack_require__(1);
+var normalizeHeaderName = __webpack_require__(36);
+
+var DEFAULT_CONTENT_TYPE = {
+ 'Content-Type': 'application/x-www-form-urlencoded'
+};
+
+function setContentTypeIfUnset(headers, value) {
+ if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
+ headers['Content-Type'] = value;
+ }
+}
+
+function getDefaultAdapter() {
+ var adapter;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ // For browsers use XHR adapter
+ adapter = __webpack_require__(14);
+ } else if (typeof process !== 'undefined') {
+ // For node use HTTP adapter
+ adapter = __webpack_require__(14);
+ }
+ return adapter;
+}
+
+var defaults = {
+ adapter: getDefaultAdapter(),
+
+ transformRequest: [function transformRequest(data, headers) {
+ normalizeHeaderName(headers, 'Content-Type');
+ if (utils.isFormData(data) ||
+ utils.isArrayBuffer(data) ||
+ utils.isBuffer(data) ||
+ utils.isStream(data) ||
+ utils.isFile(data) ||
+ utils.isBlob(data)
+ ) {
+ return data;
+ }
+ if (utils.isArrayBufferView(data)) {
+ return data.buffer;
+ }
+ if (utils.isURLSearchParams(data)) {
+ setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
+ return data.toString();
+ }
+ if (utils.isObject(data)) {
+ setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
+ return JSON.stringify(data);
+ }
+ return data;
+ }],
+
+ transformResponse: [function transformResponse(data) {
+ /*eslint no-param-reassign:0*/
+ if (typeof data === 'string') {
+ try {
+ data = JSON.parse(data);
+ } catch (e) { /* Ignore */ }
+ }
+ return data;
+ }],
+
+ timeout: 0,
+
+ xsrfCookieName: 'XSRF-TOKEN',
+ xsrfHeaderName: 'X-XSRF-TOKEN',
+
+ maxContentLength: -1,
+
+ validateStatus: function validateStatus(status) {
+ return status >= 200 && status < 300;
+ }
+};
+
+defaults.headers = {
+ common: {
+ 'Accept': 'application/json, text/plain, */*'
+ }
+};
+
+utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+ defaults.headers[method] = {};
+});
+
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+});
+
+module.exports = defaults;
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)))
+
+/***/ }),
+/* 11 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony default export */ __webpack_exports__["a"] = ({
+ /*
+ |--------------------------------------------------------------------------
+ | API URI
+ |--------------------------------------------------------------------------
+ | Here you can configure the URI to the backend API.
+ */
+ apiUri: "workshop/api/v1",
+
+ /*
+ |--------------------------------------------------------------------------
+ | Development mode
+ |--------------------------------------------------------------------------
+ | Enable/disable development mode.
+ */
+ devMode: true,
+
+ /*
+ |--------------------------------------------------------------------------
+ | Environment
+ |--------------------------------------------------------------------------
+ | Either it is 'development' or 'production'.
+ */
+ environment: "development"
+});
+
+/***/ }),
+/* 12 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return keyPressed; });
+/**
+ * Deternmine the key that has been pressed in the given event.
+ * @param event
+ * @returns {*}
+ */
+var keyPressed = function keyPressed(event) {
+
+ var key = void 0;
+
+ if (event.keyIdentifier !== undefined) {
+ key = event.keyIdentifier;
+ } else if (event.keyCode !== undefined) {
+ key = event.keyCode;
+ }
+
+ return key;
+};
+
+
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function bind(fn, thisArg) {
+ return function wrap() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ return fn.apply(thisArg, args);
+ };
+};
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var utils = __webpack_require__(1);
+var settle = __webpack_require__(37);
+var buildURL = __webpack_require__(39);
+var parseHeaders = __webpack_require__(40);
+var isURLSameOrigin = __webpack_require__(41);
+var createError = __webpack_require__(15);
+var btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || __webpack_require__(42);
+
+module.exports = function xhrAdapter(config) {
+ return new Promise(function dispatchXhrRequest(resolve, reject) {
+ var requestData = config.data;
+ var requestHeaders = config.headers;
+
+ if (utils.isFormData(requestData)) {
+ delete requestHeaders['Content-Type']; // Let the browser set it
+ }
+
+ var request = new XMLHttpRequest();
+ var loadEvent = 'onreadystatechange';
+ var xDomain = false;
+
+ // For IE 8/9 CORS support
+ // Only supports POST and GET calls and doesn't returns the response headers.
+ // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
+ if ("development" !== 'test' &&
+ typeof window !== 'undefined' &&
+ window.XDomainRequest && !('withCredentials' in request) &&
+ !isURLSameOrigin(config.url)) {
+ request = new window.XDomainRequest();
+ loadEvent = 'onload';
+ xDomain = true;
+ request.onprogress = function handleProgress() {};
+ request.ontimeout = function handleTimeout() {};
+ }
+
+ // HTTP basic authentication
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password || '';
+ requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+ }
+
+ request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);
+
+ // Set the request timeout in MS
+ request.timeout = config.timeout;
+
+ // Listen for ready state
+ request[loadEvent] = function handleLoad() {
+ if (!request || (request.readyState !== 4 && !xDomain)) {
+ return;
+ }
+
+ // The request errored out and we didn't get a response, this will be
+ // handled by onerror instead
+ // With one exception: request that using file: protocol, most browsers
+ // will return status as 0 even though it's a successful request
+ if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+ return;
+ }
+
+ // Prepare the response
+ var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+ var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+ var response = {
+ data: responseData,
+ // IE sends 1223 instead of 204 (https://github.com/axios/axios/issues/201)
+ status: request.status === 1223 ? 204 : request.status,
+ statusText: request.status === 1223 ? 'No Content' : request.statusText,
+ headers: responseHeaders,
+ config: config,
+ request: request
+ };
+
+ settle(resolve, reject, response);
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle low level network errors
+ request.onerror = function handleError() {
+ // Real errors are hidden from us by the browser
+ // onerror should only fire if it's a network error
+ reject(createError('Network Error', config, null, request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle timeout
+ request.ontimeout = function handleTimeout() {
+ reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED',
+ request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Add xsrf header
+ // This is only done if running in a standard browser environment.
+ // Specifically not if we're in a web worker, or react-native.
+ if (utils.isStandardBrowserEnv()) {
+ var cookies = __webpack_require__(43);
+
+ // Add xsrf header
+ var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?
+ cookies.read(config.xsrfCookieName) :
+ undefined;
+
+ if (xsrfValue) {
+ requestHeaders[config.xsrfHeaderName] = xsrfValue;
+ }
+ }
+
+ // Add headers to the request
+ if ('setRequestHeader' in request) {
+ utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+ if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
+ // Remove Content-Type if data is undefined
+ delete requestHeaders[key];
+ } else {
+ // Otherwise add header to the request
+ request.setRequestHeader(key, val);
+ }
+ });
+ }
+
+ // Add withCredentials to request if needed
+ if (config.withCredentials) {
+ request.withCredentials = true;
+ }
+
+ // Add responseType to request if needed
+ if (config.responseType) {
+ try {
+ request.responseType = config.responseType;
+ } catch (e) {
+ // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
+ // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
+ if (config.responseType !== 'json') {
+ throw e;
+ }
+ }
+ }
+
+ // Handle progress if needed
+ if (typeof config.onDownloadProgress === 'function') {
+ request.addEventListener('progress', config.onDownloadProgress);
+ }
+
+ // Not all browsers support upload events
+ if (typeof config.onUploadProgress === 'function' && request.upload) {
+ request.upload.addEventListener('progress', config.onUploadProgress);
+ }
+
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (!request) {
+ return;
+ }
+
+ request.abort();
+ reject(cancel);
+ // Clean up request
+ request = null;
+ });
+ }
+
+ if (requestData === undefined) {
+ requestData = null;
+ }
+
+ // Send the request
+ request.send(requestData);
+ });
+};
+
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var enhanceError = __webpack_require__(38);
+
+/**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {Object} config The config.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ * @returns {Error} The created error.
+ */
+module.exports = function createError(message, config, code, request, response) {
+ var error = new Error(message);
+ return enhanceError(error, config, code, request, response);
+};
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function isCancel(value) {
+ return !!(value && value.__CANCEL__);
+};
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**
+ * A `Cancel` is an object that is thrown when an operation is canceled.
+ *
+ * @class
+ * @param {string=} message The message.
+ */
+function Cancel(message) {
+ this.message = message;
+}
+
+Cancel.prototype.toString = function toString() {
+ return 'Cancel' + (this.message ? ': ' + this.message : '');
+};
+
+Cancel.prototype.__CANCEL__ = true;
+
+module.exports = Cancel;
+
+
+/***/ }),
+/* 18 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* unused harmony export install */
+/* unused harmony export directive */
+/* unused harmony export mixin */
+/* unused harmony export mapFields */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Validator; });
+/* unused harmony export ErrorBag */
+/* unused harmony export Rules */
+/* unused harmony export version */
+/* unused harmony export ValidationProvider */
+/* unused harmony export ValidationObserver */
+/* unused harmony export withValidation */
+/**
+ * vee-validate v2.1.4
+ * (c) 2018 Abdelrahman Awad
+ * @license MIT
+ */
+//
+
+var isTextInput = function (el) {
+ return includes(['text', 'password', 'search', 'email', 'tel', 'url', 'textarea', 'number'], el.type);
+};
+
+var isCheckboxOrRadioInput = function (el) {
+ return includes(['radio', 'checkbox'], el.type);
+};
+
+var isDateInput = function (el) {
+ return includes(['date', 'week', 'month', 'datetime-local', 'time'], el.type);
+};
+
+/**
+ * Gets the data attribute. the name must be kebab-case.
+ */
+var getDataAttribute = function (el, name) { return el.getAttribute(("data-vv-" + name)); };
+
+/**
+ * Checks if the values are either null or undefined.
+ */
+var isNullOrUndefined = function () {
+ var values = [], len = arguments.length;
+ while ( len-- ) values[ len ] = arguments[ len ];
+
+ return values.every(function (value) {
+ return value === null || value === undefined;
+ });
+};
+
+/**
+ * Creates the default flags object.
+ */
+var createFlags = function () { return ({
+ untouched: true,
+ touched: false,
+ dirty: false,
+ pristine: true,
+ valid: null,
+ invalid: null,
+ validated: false,
+ pending: false,
+ required: false,
+ changed: false
+}); };
+
+/**
+ * Shallow object comparison.
+ */
+var isEqual = function (lhs, rhs) {
+ if (lhs instanceof RegExp && rhs instanceof RegExp) {
+ return isEqual(lhs.source, rhs.source) && isEqual(lhs.flags, rhs.flags);
+ }
+
+ if (Array.isArray(lhs) && Array.isArray(rhs)) {
+ if (lhs.length !== rhs.length) { return false; }
+
+ for (var i = 0; i < lhs.length; i++) {
+ if (!isEqual(lhs[i], rhs[i])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ // if both are objects, compare each key recursively.
+ if (isObject(lhs) && isObject(rhs)) {
+ return Object.keys(lhs).every(function (key) {
+ return isEqual(lhs[key], rhs[key]);
+ }) && Object.keys(rhs).every(function (key) {
+ return isEqual(lhs[key], rhs[key]);
+ });
+ }
+
+ return lhs === rhs;
+};
+
+/**
+ * Determines the input field scope.
+ */
+var getScope = function (el) {
+ var scope = getDataAttribute(el, 'scope');
+ if (isNullOrUndefined(scope)) {
+ var form = getForm(el);
+
+ if (form) {
+ scope = getDataAttribute(form, 'scope');
+ }
+ }
+
+ return !isNullOrUndefined(scope) ? scope : null;
+};
+
+/**
+ * Get the closest form element.
+ */
+var getForm = function (el) {
+ if (isNullOrUndefined(el)) { return null; }
+
+ if (el.tagName === 'FORM') { return el; }
+
+ if (!isNullOrUndefined(el.form)) { return el.form; }
+
+ return !isNullOrUndefined(el.parentNode) ? getForm(el.parentNode) : null;
+};
+
+/**
+ * Gets the value in an object safely.
+ */
+var getPath = function (path, target, def) {
+ if ( def === void 0 ) def = undefined;
+
+ if (!path || !target) { return def; }
+
+ var value = target;
+ path.split('.').every(function (prop) {
+ if (prop in value) {
+ value = value[prop];
+
+ return true;
+ }
+
+ value = def;
+
+ return false;
+ });
+
+ return value;
+};
+
+/**
+ * Checks if path exists within an object.
+ */
+var hasPath = function (path, target) {
+ var obj = target;
+ return path.split('.').every(function (prop) {
+ if (prop in obj) {
+ obj = obj[prop];
+
+ return true;
+ }
+
+ return false;
+ });
+};
+
+/**
+ * Parses a rule string expression.
+ */
+var parseRule = function (rule) {
+ var params = [];
+ var name = rule.split(':')[0];
+
+ if (includes(rule, ':')) {
+ params = rule.split(':').slice(1).join(':').split(',');
+ }
+
+ return { name: name, params: params };
+};
+
+/**
+ * Debounces a function.
+ */
+var debounce = function (fn, wait, token) {
+ if ( wait === void 0 ) wait = 0;
+ if ( token === void 0 ) token = { cancelled: false };
+
+ if (wait === 0) {
+ return fn;
+ }
+
+ var timeout;
+
+ return function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ var later = function () {
+ timeout = null;
+
+ // check if the fn call was cancelled.
+ if (!token.cancelled) { fn.apply(void 0, args); }
+ };
+
+ clearTimeout(timeout);
+ timeout = setTimeout(later, wait);
+ if (!timeout) { fn.apply(void 0, args); }
+ };
+};
+
+/**
+ * Appends a rule definition to a list of rules.
+ */
+var appendRule = function (rule, rules) {
+ if (!rules) {
+ return normalizeRules(rule);
+ }
+
+ if (!rule) {
+ return normalizeRules(rules);
+ }
+
+ if (typeof rules === 'string') {
+ rules = normalizeRules(rules);
+ }
+
+ return assign({}, rules, normalizeRules(rule));
+};
+
+/**
+ * Normalizes the given rules expression.
+ */
+var normalizeRules = function (rules) {
+ // if falsy value return an empty object.
+ if (!rules) {
+ return {};
+ }
+
+ if (isObject(rules)) {
+ // $FlowFixMe
+ return Object.keys(rules).reduce(function (prev, curr) {
+ var params = [];
+ // $FlowFixMe
+ if (rules[curr] === true) {
+ params = [];
+ } else if (Array.isArray(rules[curr])) {
+ params = rules[curr];
+ } else if (isObject(rules[curr])) {
+ params = rules[curr];
+ } else {
+ params = [rules[curr]];
+ }
+
+ // $FlowFixMe
+ if (rules[curr] !== false) {
+ prev[curr] = params;
+ }
+
+ return prev;
+ }, {});
+ }
+
+ if (typeof rules !== 'string') {
+ warn('rules must be either a string or an object.');
+ return {};
+ }
+
+ return rules.split('|').reduce(function (prev, rule) {
+ var parsedRule = parseRule(rule);
+ if (!parsedRule.name) {
+ return prev;
+ }
+
+ prev[parsedRule.name] = parsedRule.params;
+ return prev;
+ }, {});
+};
+
+/**
+ * Emits a warning to the console.
+ */
+var warn = function (message) {
+ console.warn(("[vee-validate] " + message)); // eslint-disable-line
+};
+
+/**
+ * Creates a branded error object.
+ */
+var createError = function (message) { return new Error(("[vee-validate] " + message)); };
+
+/**
+ * Checks if the value is an object.
+ */
+var isObject = function (obj) { return obj !== null && obj && typeof obj === 'object' && ! Array.isArray(obj); };
+
+/**
+ * Checks if a function is callable.
+ */
+var isCallable = function (func) { return typeof func === 'function'; };
+
+/**
+ * Check if element has the css class on it.
+ */
+var hasClass = function (el, className) {
+ if (el.classList) {
+ return el.classList.contains(className);
+ }
+
+ return !!el.className.match(new RegExp(("(\\s|^)" + className + "(\\s|$)")));
+};
+
+/**
+ * Adds the provided css className to the element.
+ */
+var addClass = function (el, className) {
+ if (el.classList) {
+ el.classList.add(className);
+ return;
+ }
+
+ if (!hasClass(el, className)) {
+ el.className += " " + className;
+ }
+};
+
+/**
+ * Remove the provided css className from the element.
+ */
+var removeClass = function (el, className) {
+ if (el.classList) {
+ el.classList.remove(className);
+ return;
+ }
+
+ if (hasClass(el, className)) {
+ var reg = new RegExp(("(\\s|^)" + className + "(\\s|$)"));
+ el.className = el.className.replace(reg, ' ');
+ }
+};
+
+/**
+ * Adds or removes a class name on the input depending on the status flag.
+ */
+var toggleClass = function (el, className, status) {
+ if (!el || !className) { return; }
+
+ if (Array.isArray(className)) {
+ className.forEach(function (item) { return toggleClass(el, item, status); });
+ return;
+ }
+
+ if (status) {
+ return addClass(el, className);
+ }
+
+ removeClass(el, className);
+};
+
+/**
+ * Converts an array-like object to array, provides a simple polyfill for Array.from
+ */
+var toArray = function (arrayLike) {
+ if (isCallable(Array.from)) {
+ return Array.from(arrayLike);
+ }
+
+ var array = [];
+ var length = arrayLike.length;
+ /* istanbul ignore next */
+ for (var i = 0; i < length; i++) {
+ array.push(arrayLike[i]);
+ }
+
+ /* istanbul ignore next */
+ return array;
+};
+
+/**
+ * Assign polyfill from the mdn.
+ */
+var assign = function (target) {
+ var others = [], len = arguments.length - 1;
+ while ( len-- > 0 ) others[ len ] = arguments[ len + 1 ];
+
+ /* istanbul ignore else */
+ if (isCallable(Object.assign)) {
+ return Object.assign.apply(Object, [ target ].concat( others ));
+ }
+
+ /* istanbul ignore next */
+ if (target == null) {
+ throw new TypeError('Cannot convert undefined or null to object');
+ }
+
+ /* istanbul ignore next */
+ var to = Object(target);
+ /* istanbul ignore next */
+ others.forEach(function (arg) {
+ // Skip over if undefined or null
+ if (arg != null) {
+ Object.keys(arg).forEach(function (key) {
+ to[key] = arg[key];
+ });
+ }
+ });
+ /* istanbul ignore next */
+ return to;
+};
+
+var id = 0;
+var idTemplate = '{id}';
+
+/**
+ * Generates a unique id.
+ */
+var uniqId = function () {
+ // handle too many uses of uniqId, although unlikely.
+ if (id >= 9999) {
+ id = 0;
+ // shift the template.
+ idTemplate = idTemplate.replace('{id}', '_{id}');
+ }
+
+ id++;
+ var newId = idTemplate.replace('{id}', String(id));
+
+ return newId;
+};
+
+/**
+ * finds the first element that satisfies the predicate callback, polyfills array.find
+ */
+var find = function (arrayLike, predicate) {
+ var array = Array.isArray(arrayLike) ? arrayLike : toArray(arrayLike);
+ for (var i = 0; i < array.length; i++) {
+ if (predicate(array[i])) {
+ return array[i];
+ }
+ }
+
+ return undefined;
+};
+
+var isBuiltInComponent = function (vnode) {
+ if (!vnode) {
+ return false;
+ }
+
+ var tag = vnode.componentOptions.tag;
+
+ return /^(keep-alive|transition|transition-group)$/.test(tag);
+};
+
+var makeDelayObject = function (events, delay, delayConfig) {
+ if (typeof delay === 'number') {
+ return events.reduce(function (prev, e) {
+ prev[e] = delay;
+ return prev;
+ }, {});
+ }
+
+ return events.reduce(function (prev, e) {
+ if (typeof delay === 'object' && e in delay) {
+ prev[e] = delay[e];
+ return prev;
+ }
+
+ if (typeof delayConfig === 'number') {
+ prev[e] = delayConfig;
+ return prev;
+ }
+
+ prev[e] = (delayConfig && delayConfig[e]) || 0;
+
+ return prev;
+ }, {});
+};
+
+var deepParseInt = function (input) {
+ if (typeof input === 'number') { return input; }
+
+ if (typeof input === 'string') { return parseInt(input); }
+
+ var map = {};
+ for (var element in input) {
+ map[element] = parseInt(input[element]);
+ }
+
+ return map;
+};
+
+var merge = function (target, source) {
+ if (! (isObject(target) && isObject(source))) {
+ return target;
+ }
+
+ Object.keys(source).forEach(function (key) {
+ var obj, obj$1;
+
+ if (isObject(source[key])) {
+ if (! target[key]) {
+ assign(target, ( obj = {}, obj[key] = {}, obj ));
+ }
+
+ merge(target[key], source[key]);
+ return;
+ }
+
+ assign(target, ( obj$1 = {}, obj$1[key] = source[key], obj$1 ));
+ });
+
+ return target;
+};
+
+var fillRulesFromElement = function (el, rules) {
+ if (el.required) {
+ rules = appendRule('required', rules);
+ }
+
+ if (isTextInput(el)) {
+ if (el.type === 'email') {
+ rules = appendRule(("email" + (el.multiple ? ':multiple' : '')), rules);
+ }
+
+ if (el.pattern) {
+ rules = appendRule({ regex: el.pattern }, rules);
+ }
+
+ // 524288 is the max on some browsers and test environments.
+ if (el.maxLength >= 0 && el.maxLength < 524288) {
+ rules = appendRule(("max:" + (el.maxLength)), rules);
+ }
+
+ if (el.minLength > 0) {
+ rules = appendRule(("min:" + (el.minLength)), rules);
+ }
+
+ if (el.type === 'number') {
+ rules = appendRule('decimal', rules);
+ if (el.min !== '') {
+ rules = appendRule(("min_value:" + (el.min)), rules);
+ }
+
+ if (el.max !== '') {
+ rules = appendRule(("max_value:" + (el.max)), rules);
+ }
+ }
+
+ return rules;
+ }
+
+ if (isDateInput(el)) {
+ var timeFormat = el.step && Number(el.step) < 60 ? 'HH:mm:ss' : 'HH:mm';
+
+ if (el.type === 'date') {
+ return appendRule('date_format:YYYY-MM-DD', rules);
+ }
+
+ if (el.type === 'datetime-local') {
+ return appendRule(("date_format:YYYY-MM-DDT" + timeFormat), rules);
+ }
+
+ if (el.type === 'month') {
+ return appendRule('date_format:YYYY-MM', rules);
+ }
+
+ if (el.type === 'week') {
+ return appendRule('date_format:YYYY-[W]WW', rules);
+ }
+
+ if (el.type === 'time') {
+ return appendRule(("date_format:" + timeFormat), rules);
+ }
+ }
+
+ return rules;
+};
+
+var values = function (obj) {
+ if (isCallable(Object.values)) {
+ return Object.values(obj);
+ }
+
+ // fallback to keys()
+ /* istanbul ignore next */
+ return Object.keys(obj).map(function (k) { return obj[k]; });
+};
+
+var parseSelector = function (selector) {
+ var rule = null;
+ if (includes(selector, ':')) {
+ rule = selector.split(':').pop();
+ selector = selector.replace((":" + rule), '');
+ }
+
+ if (selector[0] === '#') {
+ return {
+ id: selector.slice(1),
+ rule: rule,
+ name: null,
+ scope: null
+ };
+ }
+
+ var scope = null;
+ var name = selector;
+ if (includes(selector, '.')) {
+ var parts = selector.split('.');
+ scope = parts[0];
+ name = parts.slice(1).join('.');
+ }
+
+ return {
+ id: null,
+ scope: scope,
+ name: name,
+ rule: rule
+ };
+};
+
+var includes = function (collection, item) {
+ return collection.indexOf(item) !== -1;
+};
+
+var isEmptyArray = function (arr) {
+ return Array.isArray(arr) && arr.length === 0;
+};
+
+//
+
+var LOCALE = 'en';
+
+var Dictionary = function Dictionary (dictionary) {
+ if ( dictionary === void 0 ) dictionary = {};
+
+ this.container = {};
+ this.merge(dictionary);
+};
+
+var prototypeAccessors = { locale: { configurable: true } };
+
+prototypeAccessors.locale.get = function () {
+ return LOCALE;
+};
+
+prototypeAccessors.locale.set = function (value) {
+ LOCALE = value || 'en';
+};
+
+Dictionary.prototype.hasLocale = function hasLocale (locale) {
+ return !!this.container[locale];
+};
+
+Dictionary.prototype.setDateFormat = function setDateFormat (locale, format) {
+ if (!this.container[locale]) {
+ this.container[locale] = {};
+ }
+
+ this.container[locale].dateFormat = format;
+};
+
+Dictionary.prototype.getDateFormat = function getDateFormat (locale) {
+ if (!this.container[locale] || !this.container[locale].dateFormat) {
+ return null;
+ }
+
+ return this.container[locale].dateFormat;
+};
+
+Dictionary.prototype.getMessage = function getMessage (locale, key, data) {
+ var message = null;
+ if (!this.hasMessage(locale, key)) {
+ message = this._getDefaultMessage(locale);
+ } else {
+ message = this.container[locale].messages[key];
+ }
+
+ return isCallable(message) ? message.apply(void 0, data) : message;
+};
+
+/**
+ * Gets a specific message for field. falls back to the rule message.
+ */
+Dictionary.prototype.getFieldMessage = function getFieldMessage (locale, field, key, data) {
+ if (!this.hasLocale(locale)) {
+ return this.getMessage(locale, key, data);
+ }
+
+ var dict = this.container[locale].custom && this.container[locale].custom[field];
+ if (!dict || !dict[key]) {
+ return this.getMessage(locale, key, data);
+ }
+
+ var message = dict[key];
+ return isCallable(message) ? message.apply(void 0, data) : message;
+};
+
+Dictionary.prototype._getDefaultMessage = function _getDefaultMessage (locale) {
+ if (this.hasMessage(locale, '_default')) {
+ return this.container[locale].messages._default;
+ }
+
+ return this.container.en.messages._default;
+};
+
+Dictionary.prototype.getAttribute = function getAttribute (locale, key, fallback) {
+ if ( fallback === void 0 ) fallback = '';
+
+ if (!this.hasAttribute(locale, key)) {
+ return fallback;
+ }
+
+ return this.container[locale].attributes[key];
+};
+
+Dictionary.prototype.hasMessage = function hasMessage (locale, key) {
+ return !! (
+ this.hasLocale(locale) &&
+ this.container[locale].messages &&
+ this.container[locale].messages[key]
+ );
+};
+
+Dictionary.prototype.hasAttribute = function hasAttribute (locale, key) {
+ return !! (
+ this.hasLocale(locale) &&
+ this.container[locale].attributes &&
+ this.container[locale].attributes[key]
+ );
+};
+
+Dictionary.prototype.merge = function merge$1 (dictionary) {
+ merge(this.container, dictionary);
+};
+
+Dictionary.prototype.setMessage = function setMessage (locale, key, message) {
+ if (! this.hasLocale(locale)) {
+ this.container[locale] = {
+ messages: {},
+ attributes: {}
+ };
+ }
+
+ this.container[locale].messages[key] = message;
+};
+
+Dictionary.prototype.setAttribute = function setAttribute (locale, key, attribute) {
+ if (! this.hasLocale(locale)) {
+ this.container[locale] = {
+ messages: {},
+ attributes: {}
+ };
+ }
+
+ this.container[locale].attributes[key] = attribute;
+};
+
+Object.defineProperties( Dictionary.prototype, prototypeAccessors );
+
+var drivers = {
+ default: new Dictionary({
+ en: {
+ messages: {},
+ attributes: {},
+ custom: {}
+ }
+ })
+};
+
+var currentDriver = 'default';
+
+var DictionaryResolver = function DictionaryResolver () {};
+
+DictionaryResolver._checkDriverName = function _checkDriverName (driver) {
+ if (!driver) {
+ throw createError('you must provide a name to the dictionary driver');
+ }
+};
+
+DictionaryResolver.setDriver = function setDriver (driver, implementation) {
+ if ( implementation === void 0 ) implementation = null;
+
+ this._checkDriverName(driver);
+ if (implementation) {
+ drivers[driver] = implementation;
+ }
+
+ currentDriver = driver;
+};
+
+DictionaryResolver.getDriver = function getDriver () {
+ return drivers[currentDriver];
+};
+
+//
+
+var ErrorBag = function ErrorBag (errorBag, id) {
+ if ( errorBag === void 0 ) errorBag = null;
+ if ( id === void 0 ) id = null;
+
+ this.vmId = id || null;
+ // make this bag a mirror of the provided one, sharing the same items reference.
+ if (errorBag && errorBag instanceof ErrorBag) {
+ this.items = errorBag.items;
+ } else {
+ this.items = [];
+ }
+};
+
+ErrorBag.prototype[typeof Symbol === 'function' ? Symbol.iterator : '@@iterator'] = function () {
+ var this$1 = this;
+
+ var index = 0;
+ return {
+ next: function () {
+ return { value: this$1.items[index++], done: index > this$1.items.length };
+ }
+ };
+};
+
+/**
+ * Adds an error to the internal array.
+ */
+ErrorBag.prototype.add = function add (error) {
+ var ref;
+
+ (ref = this.items).push.apply(
+ ref, this._normalizeError(error)
+ );
+};
+
+/**
+ * Normalizes passed errors to an error array.
+ */
+ErrorBag.prototype._normalizeError = function _normalizeError (error) {
+ var this$1 = this;
+
+ if (Array.isArray(error)) {
+ return error.map(function (e) {
+ e.scope = !isNullOrUndefined(e.scope) ? e.scope : null;
+ e.vmId = !isNullOrUndefined(e.vmId) ? e.vmId : (this$1.vmId || null);
+
+ return e;
+ });
+ }
+
+ error.scope = !isNullOrUndefined(error.scope) ? error.scope : null;
+ error.vmId = !isNullOrUndefined(error.vmId) ? error.vmId : (this.vmId || null);
+
+ return [error];
+};
+
+/**
+ * Regenrates error messages if they have a generator function.
+ */
+ErrorBag.prototype.regenerate = function regenerate () {
+ this.items.forEach(function (i) {
+ i.msg = isCallable(i.regenerate) ? i.regenerate() : i.msg;
+ });
+};
+
+/**
+ * Updates a field error with the new field scope.
+ */
+ErrorBag.prototype.update = function update (id, error) {
+ var item = find(this.items, function (i) { return i.id === id; });
+ if (!item) {
+ return;
+ }
+
+ var idx = this.items.indexOf(item);
+ this.items.splice(idx, 1);
+ item.scope = error.scope;
+ this.items.push(item);
+};
+
+/**
+ * Gets all error messages from the internal array.
+ */
+ErrorBag.prototype.all = function all (scope) {
+ var this$1 = this;
+
+ var filterFn = function (item) {
+ var matchesScope = true;
+ var matchesVM = true;
+ if (!isNullOrUndefined(scope)) {
+ matchesScope = item.scope === scope;
+ }
+
+ if (!isNullOrUndefined(this$1.vmId)) {
+ matchesVM = item.vmId === this$1.vmId;
+ }
+
+ return matchesVM && matchesScope;
+ };
+
+ return this.items.filter(filterFn).map(function (e) { return e.msg; });
+};
+
+/**
+ * Checks if there are any errors in the internal array.
+ */
+ErrorBag.prototype.any = function any (scope) {
+ var this$1 = this;
+
+ var filterFn = function (item) {
+ var matchesScope = true;
+ var matchesVM = true;
+ if (!isNullOrUndefined(scope)) {
+ matchesScope = item.scope === scope;
+ }
+
+ if (!isNullOrUndefined(this$1.vmId)) {
+ matchesVM = item.vmId === this$1.vmId;
+ }
+
+ return matchesVM && matchesScope;
+ };
+
+ return !!this.items.filter(filterFn).length;
+};
+
+/**
+ * Removes all items from the internal array.
+ */
+ErrorBag.prototype.clear = function clear (scope) {
+ var this$1 = this;
+
+ var matchesVM = isNullOrUndefined(this.vmId) ? function () { return true; } : function (i) { return i.vmId === this$1.vmId; };
+ if (isNullOrUndefined(scope)) {
+ scope = null;
+ }
+
+ for (var i = 0; i < this.items.length; ++i) {
+ if (matchesVM(this.items[i]) && this.items[i].scope === scope) {
+ this.items.splice(i, 1);
+ --i;
+ }
+ }
+};
+
+/**
+ * Collects errors into groups or for a specific field.
+ */
+ErrorBag.prototype.collect = function collect (field, scope, map) {
+ var this$1 = this;
+ if ( map === void 0 ) map = true;
+
+ var isSingleField = !isNullOrUndefined(field) && !field.includes('*');
+ var groupErrors = function (items) {
+ var errors = items.reduce(function (collection, error) {
+ if (!isNullOrUndefined(this$1.vmId) && error.vmId !== this$1.vmId) {
+ return collection;
+ }
+
+ if (!collection[error.field]) {
+ collection[error.field] = [];
+ }
+
+ collection[error.field].push(map ? error.msg : error);
+
+ return collection;
+ }, {});
+
+ // reduce the collection to be a single array.
+ if (isSingleField) {
+ return values(errors)[0] || [];
+ }
+
+ return errors;
+ };
+
+ if (isNullOrUndefined(field)) {
+ return groupErrors(this.items);
+ }
+
+ var selector = isNullOrUndefined(scope) ? String(field) : (scope + "." + field);
+ var ref = this._makeCandidateFilters(selector);
+ var isPrimary = ref.isPrimary;
+ var isAlt = ref.isAlt;
+
+ var collected = this.items.reduce(function (prev, curr) {
+ if (isPrimary(curr)) {
+ prev.primary.push(curr);
+ }
+
+ if (isAlt(curr)) {
+ prev.alt.push(curr);
+ }
+
+ return prev;
+ }, { primary: [], alt: [] });
+
+ collected = collected.primary.length ? collected.primary : collected.alt;
+
+ return groupErrors(collected);
+};
+
+/**
+ * Gets the internal array length.
+ */
+ErrorBag.prototype.count = function count () {
+ var this$1 = this;
+
+ if (this.vmId) {
+ return this.items.filter(function (e) { return e.vmId === this$1.vmId; }).length;
+ }
+
+ return this.items.length;
+};
+
+/**
+ * Finds and fetches the first error message for the specified field id.
+ */
+ErrorBag.prototype.firstById = function firstById (id) {
+ var error = find(this.items, function (i) { return i.id === id; });
+
+ return error ? error.msg : undefined;
+};
+
+/**
+ * Gets the first error message for a specific field.
+ */
+ErrorBag.prototype.first = function first (field, scope) {
+ if ( scope === void 0 ) scope = null;
+
+ var selector = isNullOrUndefined(scope) ? field : (scope + "." + field);
+ var match = this._match(selector);
+
+ return match && match.msg;
+};
+
+/**
+ * Returns the first error rule for the specified field
+ */
+ErrorBag.prototype.firstRule = function firstRule (field, scope) {
+ var errors = this.collect(field, scope, false);
+
+ return (errors.length && errors[0].rule) || undefined;
+};
+
+/**
+ * Checks if the internal array has at least one error for the specified field.
+ */
+ErrorBag.prototype.has = function has (field, scope) {
+ if ( scope === void 0 ) scope = null;
+
+ return !!this.first(field, scope);
+};
+
+/**
+ * Gets the first error message for a specific field and a rule.
+ */
+ErrorBag.prototype.firstByRule = function firstByRule (name, rule, scope) {
+ if ( scope === void 0 ) scope = null;
+
+ var error = this.collect(name, scope, false).filter(function (e) { return e.rule === rule; })[0];
+
+ return (error && error.msg) || undefined;
+};
+
+/**
+ * Gets the first error message for a specific field that not match the rule.
+ */
+ErrorBag.prototype.firstNot = function firstNot (name, rule, scope) {
+ if ( rule === void 0 ) rule = 'required';
+ if ( scope === void 0 ) scope = null;
+
+ var error = this.collect(name, scope, false).filter(function (e) { return e.rule !== rule; })[0];
+
+ return (error && error.msg) || undefined;
+};
+
+/**
+ * Removes errors by matching against the id or ids.
+ */
+ErrorBag.prototype.removeById = function removeById (id) {
+ var condition = function (item) { return item.id === id; };
+ if (Array.isArray(id)) {
+ condition = function (item) { return id.indexOf(item.id) !== -1; };
+ }
+
+ for (var i = 0; i < this.items.length; ++i) {
+ if (condition(this.items[i])) {
+ this.items.splice(i, 1);
+ --i;
+ }
+ }
+};
+
+/**
+ * Removes all error messages associated with a specific field.
+ */
+ErrorBag.prototype.remove = function remove (field, scope, vmId) {
+ if (isNullOrUndefined(field)) {
+ return;
+ }
+
+ var selector = isNullOrUndefined(scope) ? String(field) : (scope + "." + field);
+ var ref = this._makeCandidateFilters(selector);
+ var isPrimary = ref.isPrimary;
+ var shouldRemove = function (item) {
+ if (isNullOrUndefined(vmId)) { return isPrimary(item); }
+
+ return isPrimary(item) && item.vmId === vmId;
+ };
+
+ for (var i = 0; i < this.items.length; ++i) {
+ if (shouldRemove(this.items[i])) {
+ this.items.splice(i, 1);
+ --i;
+ }
+ }
+};
+
+ErrorBag.prototype._makeCandidateFilters = function _makeCandidateFilters (selector) {
+ var this$1 = this;
+
+ var matchesRule = function () { return true; };
+ var matchesScope = function () { return true; };
+ var matchesName = function () { return true; };
+ var matchesVM = function () { return true; };
+
+ var ref = parseSelector(selector);
+ var id = ref.id;
+ var rule = ref.rule;
+ var scope = ref.scope;
+ var name = ref.name;
+
+ if (rule) {
+ matchesRule = function (item) { return item.rule === rule; };
+ }
+
+ // match by id, can be combined with rule selection.
+ if (id) {
+ return {
+ isPrimary: function (item) { return matchesRule(item) && (function (item) { return id === item.id; }); },
+ isAlt: function () { return false; }
+ };
+ }
+
+ if (isNullOrUndefined(scope)) {
+ // if no scope specified, make sure the found error has no scope.
+ matchesScope = function (item) { return isNullOrUndefined(item.scope); };
+ } else {
+ matchesScope = function (item) { return item.scope === scope; };
+ }
+
+ if (!isNullOrUndefined(name) && name !== '*') {
+ matchesName = function (item) { return item.field === name; };
+ }
+
+ if (!isNullOrUndefined(this.vmId)) {
+ matchesVM = function (item) { return item.vmId === this$1.vmId; };
+ }
+
+ // matches the first candidate.
+ var isPrimary = function (item) {
+ return matchesVM(item) && matchesName(item) && matchesRule(item) && matchesScope(item);
+ };
+
+ // matches a second candidate, which is a field with a name containing the '.' character.
+ var isAlt = function (item) {
+ return matchesVM(item) && matchesRule(item) && item.field === (scope + "." + name);
+ };
+
+ return {
+ isPrimary: isPrimary,
+ isAlt: isAlt
+ };
+};
+
+ErrorBag.prototype._match = function _match (selector) {
+ if (isNullOrUndefined(selector)) {
+ return undefined;
+ }
+
+ var ref = this._makeCandidateFilters(selector);
+ var isPrimary = ref.isPrimary;
+ var isAlt = ref.isAlt;
+
+ return this.items.reduce(function (prev, item, idx, arr) {
+ var isLast = idx === arr.length - 1;
+ if (prev.primary) {
+ return isLast ? prev.primary : prev;
+ }
+
+ if (isPrimary(item)) {
+ prev.primary = item;
+ }
+
+ if (isAlt(item)) {
+ prev.alt = item;
+ }
+
+ // keep going.
+ if (!isLast) {
+ return prev;
+ }
+
+ return prev.primary || prev.alt;
+ }, {});
+};
+
+// VNode Utils
+
+// Gets the model object on the vnode.
+function findModel (vnode) {
+ if (!vnode.data) {
+ return null;
+ }
+
+ // Component Model
+ if (vnode.data.model) {
+ return vnode.data.model;
+ }
+
+ return !!(vnode.data.directives) && find(vnode.data.directives, function (d) { return d.name === 'model'; });
+}
+
+function extractVNodes (vnode) {
+ if (findModel(vnode)) {
+ return [vnode];
+ }
+
+ var children = Array.isArray(vnode) ? vnode : vnode.children;
+ if (!Array.isArray(children)) {
+ return [];
+ }
+
+ return children.reduce(function (nodes, node) {
+ var candidates = extractVNodes(node);
+ if (candidates.length) {
+ nodes.push.apply(nodes, candidates);
+ }
+
+ return nodes;
+ }, []);
+}
+
+// Resolves v-model config if exists.
+function findModelConfig (vnode) {
+ if (!vnode.componentOptions) { return null; }
+
+ return vnode.componentOptions.Ctor.options.model;
+}
+// Adds a listener to vnode listener object.
+function mergeVNodeListeners (obj, eventName, handler) {
+ // Has a single listener.
+ if (isCallable(obj[eventName])) {
+ var prevHandler = obj[eventName];
+ obj[eventName] = [prevHandler];
+ }
+
+ // has other listeners.
+ if (Array.isArray(obj[eventName])) {
+ obj[eventName].push(handler);
+ return;
+ }
+
+ // no listener at all.
+ if (isNullOrUndefined(obj[eventName])) {
+ obj[eventName] = [handler];
+ }
+}
+
+// Adds a listener to a native HTML vnode.
+function addNativeNodeListener (node, eventName, handler) {
+ if (isNullOrUndefined(node.data.on)) {
+ node.data.on = {};
+ }
+
+ mergeVNodeListeners(node.data.on, eventName, handler);
+}
+
+// Adds a listener to a Vue component vnode.
+function addComponentNodeListener (node, eventName, handler) {
+ /* istanbul ignore next */
+ if (!node.componentOptions.listeners) {
+ node.componentOptions.listeners = {};
+ }
+
+ mergeVNodeListeners(node.componentOptions.listeners, eventName, handler);
+}
+function addVNodeListener (vnode, eventName, handler) {
+ if (vnode.componentOptions) {
+ addComponentNodeListener(vnode, eventName, handler);
+ }
+
+ addNativeNodeListener(vnode, eventName, handler);
+}
+// Determines if `change` should be used over `input` for listeners.
+function getInputEventName (vnode, model) {
+ // Is a component.
+ if (vnode.componentOptions) {
+ var ref = findModelConfig(vnode) || { event: 'input' };
+ var event = ref.event;
+
+ return event;
+ }
+
+ // Lazy Models typically use change event
+ if (model && model.modifiers && model.modifiers.lazy) {
+ return 'change';
+ }
+
+ // is a textual-type input.
+ if (vnode.data.attrs && isTextInput({ type: vnode.data.attrs.type || 'text' })) {
+ return 'input';
+ }
+
+ return 'change';
+}
+
+function normalizeSlots (slots, ctx) {
+ return Object.keys(slots).reduce(function (arr, key) {
+ slots[key].forEach(function (vnode) {
+ if (!vnode.context) {
+ slots[key].context = ctx;
+ if (!vnode.data) {
+ vnode.data = {};
+ }
+ vnode.data.slot = key;
+ }
+ });
+
+ return arr.concat(slots[key]);
+ }, []);
+}
+
+function createRenderless (h, vnode) {
+ // a single-root slot yay!
+ if (!Array.isArray(vnode)) {
+ return vnode;
+ }
+
+ if (vnode.length === 1) {
+ return vnode[0];
+ }
+
+ if (true) {
+ warn('Your slot should have one root element. Rendering a span as the root.');
+ }
+
+ // Renders a multi-root node, should throw a Vue error.
+ return vnode;
+}
+
+/**
+ * Generates the options required to construct a field.
+ */
+var Resolver = function Resolver () {};
+
+Resolver.generate = function generate (el, binding, vnode) {
+ var model = Resolver.resolveModel(binding, vnode);
+ var options = pluginInstance.resolveConfig(vnode.context);
+
+ return {
+ name: Resolver.resolveName(el, vnode),
+ el: el,
+ listen: !binding.modifiers.disable,
+ bails: binding.modifiers.bails ? true : (binding.modifiers.continues === true ? false : undefined),
+ scope: Resolver.resolveScope(el, binding, vnode),
+ vm: Resolver.makeVM(vnode.context),
+ expression: binding.value,
+ component: vnode.componentInstance,
+ classes: options.classes,
+ classNames: options.classNames,
+ getter: Resolver.resolveGetter(el, vnode, model),
+ events: Resolver.resolveEvents(el, vnode) || options.events,
+ model: model,
+ delay: Resolver.resolveDelay(el, vnode, options),
+ rules: Resolver.resolveRules(el, binding, vnode),
+ immediate: !!binding.modifiers.initial || !!binding.modifiers.immediate,
+ validity: options.validity,
+ aria: options.aria,
+ initialValue: Resolver.resolveInitialValue(vnode)
+ };
+};
+
+Resolver.getCtorConfig = function getCtorConfig (vnode) {
+ if (!vnode.componentInstance) { return null; }
+
+ var config = getPath('componentInstance.$options.$_veeValidate', vnode);
+
+ return config;
+};
+
+/**
+ * Resolves the rules defined on an element.
+ */
+Resolver.resolveRules = function resolveRules (el, binding, vnode) {
+ var rules = '';
+ if (!binding.value && (!binding || !binding.expression)) {
+ rules = getDataAttribute(el, 'rules');
+ }
+
+ if (binding.value && includes(['string', 'object'], typeof binding.value.rules)) {
+ rules = binding.value.rules;
+ } else if (binding.value) {
+ rules = binding.value;
+ }
+
+ if (vnode.componentInstance) {
+ return rules;
+ }
+
+ // If validity is disabled, ignore field rules.
+ var normalized = normalizeRules(rules);
+ if (!pluginInstance.config.validity) {
+ return normalized;
+ }
+
+ return assign({}, fillRulesFromElement(el, {}), normalized);
+};
+
+/**
+ * @param {*} vnode
+ */
+Resolver.resolveInitialValue = function resolveInitialValue (vnode) {
+ var model = vnode.data.model || find(vnode.data.directives, function (d) { return d.name === 'model'; });
+
+ return model && model.value;
+};
+
+/**
+ * Creates a non-circular partial VM instance from a Vue instance.
+ * @param {*} vm
+ */
+Resolver.makeVM = function makeVM (vm) {
+ return {
+ get $el () {
+ return vm.$el;
+ },
+ get $refs () {
+ return vm.$refs;
+ },
+ $watch: vm.$watch ? vm.$watch.bind(vm) : function () {},
+ $validator: vm.$validator ? {
+ errors: vm.$validator.errors,
+ validate: vm.$validator.validate.bind(vm.$validator),
+ update: vm.$validator.update.bind(vm.$validator)
+ } : null
+ };
+};
+
+/**
+ * Resolves the delay value.
+ * @param {*} el
+ * @param {*} vnode
+ * @param {Object} options
+ */
+Resolver.resolveDelay = function resolveDelay (el, vnode, options) {
+ var delay = getDataAttribute(el, 'delay');
+ var globalDelay = (options && 'delay' in options) ? options.delay : 0;
+
+ if (!delay && vnode.componentInstance && vnode.componentInstance.$attrs) {
+ delay = vnode.componentInstance.$attrs['data-vv-delay'];
+ }
+
+ if (!isObject(globalDelay)) {
+ return deepParseInt(delay || globalDelay);
+ }
+
+ if (!isNullOrUndefined(delay)) {
+ globalDelay.input = delay;
+ }
+
+ return deepParseInt(globalDelay);
+};
+
+/**
+ * Resolves the events to validate in response to.
+ * @param {*} el
+ * @param {*} vnode
+ */
+Resolver.resolveEvents = function resolveEvents (el, vnode) {
+ // resolve it from the root element.
+ var events = getDataAttribute(el, 'validate-on');
+
+ // resolve from data-vv-validate-on if its a vue component.
+ if (!events && vnode.componentInstance && vnode.componentInstance.$attrs) {
+ events = vnode.componentInstance.$attrs['data-vv-validate-on'];
+ }
+
+ // resolve it from $_veeValidate options.
+ if (!events && vnode.componentInstance) {
+ var config = Resolver.getCtorConfig(vnode);
+ events = config && config.events;
+ }
+
+ if (!events && pluginInstance.config.events) {
+ events = pluginInstance.config.events;
+ }
+
+ // resolve the model event if its configured for custom components.
+ if (events && vnode.componentInstance && includes(events, 'input')) {
+ var ref = vnode.componentInstance.$options.model || { event: 'input' };
+ var event = ref.event;
+ // if the prop was configured but not the model.
+ if (!event) {
+ return events;
+ }
+
+ events = events.replace('input', event);
+ }
+
+ return events;
+};
+
+/**
+ * Resolves the scope for the field.
+ * @param {*} el
+ * @param {*} binding
+ */
+Resolver.resolveScope = function resolveScope (el, binding, vnode) {
+ if ( vnode === void 0 ) vnode = {};
+
+ var scope = null;
+ if (vnode.componentInstance && isNullOrUndefined(scope)) {
+ scope = vnode.componentInstance.$attrs && vnode.componentInstance.$attrs['data-vv-scope'];
+ }
+
+ return !isNullOrUndefined(scope) ? scope : getScope(el);
+};
+
+/**
+ * Checks if the node directives contains a v-model or a specified arg.
+ * Args take priority over models.
+ *
+ * @return {Object}
+ */
+Resolver.resolveModel = function resolveModel (binding, vnode) {
+ if (binding.arg) {
+ return { expression: binding.arg };
+ }
+
+ var model = findModel(vnode);
+ if (!model) {
+ return null;
+ }
+
+ // https://github.com/vuejs/vue/blob/dev/src/core/util/lang.js#L26
+ var watchable = !/[^\w.$]/.test(model.expression) && hasPath(model.expression, vnode.context);
+ var lazy = !!(model.modifiers && model.modifiers.lazy);
+
+ if (!watchable) {
+ return { expression: null, lazy: lazy };
+ }
+
+ return { expression: model.expression, lazy: lazy };
+};
+
+/**
+ * Resolves the field name to trigger validations.
+ * @return {String} The field name.
+ */
+Resolver.resolveName = function resolveName (el, vnode) {
+ var name = getDataAttribute(el, 'name');
+
+ if (!name && !vnode.componentInstance) {
+ return el.name;
+ }
+
+ if (!name && vnode.componentInstance && vnode.componentInstance.$attrs) {
+ name = vnode.componentInstance.$attrs['data-vv-name'] || vnode.componentInstance.$attrs['name'];
+ }
+
+ if (!name && vnode.componentInstance) {
+ var config = Resolver.getCtorConfig(vnode);
+ if (config && isCallable(config.name)) {
+ var boundGetter = config.name.bind(vnode.componentInstance);
+
+ return boundGetter();
+ }
+
+ return vnode.componentInstance.name;
+ }
+
+ return name;
+};
+
+/**
+ * Returns a value getter input type.
+ */
+Resolver.resolveGetter = function resolveGetter (el, vnode, model) {
+ if (model && model.expression) {
+ return function () {
+ return getPath(model.expression, vnode.context);
+ };
+ }
+
+ if (vnode.componentInstance) {
+ var path = getDataAttribute(el, 'value-path') || (vnode.componentInstance.$attrs && vnode.componentInstance.$attrs['data-vv-value-path']);
+ if (path) {
+ return function () {
+ return getPath(path, vnode.componentInstance);
+ };
+ }
+
+ var config = Resolver.getCtorConfig(vnode);
+ if (config && isCallable(config.value)) {
+ var boundGetter = config.value.bind(vnode.componentInstance);
+
+ return function () {
+ return boundGetter();
+ };
+ }
+
+ var ref = vnode.componentInstance.$options.model || { prop: 'value' };
+ var prop = ref.prop;
+
+ return function () {
+ return vnode.componentInstance[prop];
+ };
+ }
+
+ switch (el.type) {
+ case 'checkbox': return function () {
+ var els = document.querySelectorAll(("input[name=\"" + (el.name) + "\"]"));
+
+ els = toArray(els).filter(function (el) { return el.checked; });
+ if (!els.length) { return undefined; }
+
+ return els.map(function (checkbox) { return checkbox.value; });
+ };
+ case 'radio': return function () {
+ var els = document.querySelectorAll(("input[name=\"" + (el.name) + "\"]"));
+ var elm = find(els, function (el) { return el.checked; });
+
+ return elm && elm.value;
+ };
+ case 'file': return function (context) {
+ return toArray(el.files);
+ };
+ case 'select-multiple': return function () {
+ return toArray(el.options).filter(function (opt) { return opt.selected; }).map(function (opt) { return opt.value; });
+ };
+ default: return function () {
+ return el && el.value;
+ };
+ }
+};
+
+var RULES = {};
+
+var RuleContainer = function RuleContainer () {};
+
+var staticAccessors = { rules: { configurable: true } };
+
+RuleContainer.add = function add (name, ref) {
+ var validate = ref.validate;
+ var options = ref.options;
+ var paramNames = ref.paramNames;
+
+ RULES[name] = {
+ validate: validate,
+ options: options,
+ paramNames: paramNames
+ };
+};
+
+staticAccessors.rules.get = function () {
+ return RULES;
+};
+
+RuleContainer.has = function has (name) {
+ return !!RULES[name];
+};
+
+RuleContainer.isImmediate = function isImmediate (name) {
+ return !!(RULES[name] && RULES[name].options.immediate);
+};
+
+RuleContainer.isTargetRule = function isTargetRule (name) {
+ return !!(RULES[name] && RULES[name].options.hasTarget);
+};
+
+RuleContainer.remove = function remove (ruleName) {
+ delete RULES[ruleName];
+};
+
+RuleContainer.getParamNames = function getParamNames (ruleName) {
+ return RULES[ruleName] && RULES[ruleName].paramNames;
+};
+
+RuleContainer.getOptions = function getOptions (ruleName) {
+ return RULES[ruleName] && RULES[ruleName].options;
+};
+
+RuleContainer.getValidatorMethod = function getValidatorMethod (ruleName) {
+ return RULES[ruleName] ? RULES[ruleName].validate : null;
+};
+
+Object.defineProperties( RuleContainer, staticAccessors );
+
+//
+
+var isEvent = function (evt) {
+ return (typeof Event !== 'undefined' && isCallable(Event) && evt instanceof Event) || (evt && evt.srcElement);
+};
+
+var normalizeEvents = function (evts) {
+ if (!evts) { return []; }
+
+ return (typeof evts === 'string' ? evts.split('|') : evts);
+};
+
+var supportsPassive = true;
+
+var detectPassiveSupport = function () {
+ try {
+ var opts = Object.defineProperty({}, 'passive', {
+ get: function get () {
+ supportsPassive = true;
+ }
+ });
+ window.addEventListener('testPassive', null, opts);
+ window.removeEventListener('testPassive', null, opts);
+ } catch (e) {
+ supportsPassive = false;
+ }
+ return supportsPassive;
+};
+
+var addEventListener = function (el, eventName, cb) {
+ el.addEventListener(eventName, cb, supportsPassive ? { passive: true } : false);
+};
+
+//
+
+var DEFAULT_OPTIONS = {
+ targetOf: null,
+ immediate: false,
+ scope: null,
+ listen: true,
+ name: null,
+ rules: {},
+ vm: null,
+ classes: false,
+ validity: true,
+ aria: true,
+ events: 'input|blur',
+ delay: 0,
+ classNames: {
+ touched: 'touched', // the control has been blurred
+ untouched: 'untouched', // the control hasn't been blurred
+ valid: 'valid', // model is valid
+ invalid: 'invalid', // model is invalid
+ pristine: 'pristine', // control has not been interacted with
+ dirty: 'dirty' // control has been interacted with
+ }
+};
+
+var Field = function Field (options) {
+ if ( options === void 0 ) options = {};
+
+ this.id = uniqId();
+ this.el = options.el;
+ this.updated = false;
+ this.dependencies = [];
+ this.vmId = options.vmId;
+ this.watchers = [];
+ this.events = [];
+ this.delay = 0;
+ this.rules = {};
+ this._cacheId(options);
+ this.classNames = assign({}, DEFAULT_OPTIONS.classNames);
+ options = assign({}, DEFAULT_OPTIONS, options);
+ this._delay = !isNullOrUndefined(options.delay) ? options.delay : 0; // cache initial delay
+ this.validity = options.validity;
+ this.aria = options.aria;
+ this.flags = createFlags();
+ this.vm = options.vm;
+ this.componentInstance = options.component;
+ this.ctorConfig = this.componentInstance ? getPath('$options.$_veeValidate', this.componentInstance) : undefined;
+ this.update(options);
+ // set initial value.
+ this.initialValue = this.value;
+ this.updated = false;
+};
+
+var prototypeAccessors$1 = { validator: { configurable: true },isRequired: { configurable: true },isDisabled: { configurable: true },alias: { configurable: true },value: { configurable: true },bails: { configurable: true },rejectsFalse: { configurable: true } };
+
+prototypeAccessors$1.validator.get = function () {
+ if (!this.vm || !this.vm.$validator) {
+ return { validate: function () {} };
+ }
+
+ return this.vm.$validator;
+};
+
+prototypeAccessors$1.isRequired.get = function () {
+ return !!this.rules.required;
+};
+
+prototypeAccessors$1.isDisabled.get = function () {
+ return !!(this.componentInstance && this.componentInstance.disabled) || !!(this.el && this.el.disabled);
+};
+
+/**
+ * Gets the display name (user-friendly name).
+ */
+prototypeAccessors$1.alias.get = function () {
+ if (this._alias) {
+ return this._alias;
+ }
+
+ var alias = null;
+ if (this.ctorConfig && this.ctorConfig.alias) {
+ alias = isCallable(this.ctorConfig.alias) ? this.ctorConfig.alias.call(this.componentInstance) : this.ctorConfig.alias;
+ }
+
+ if (!alias && this.el) {
+ alias = getDataAttribute(this.el, 'as');
+ }
+
+ if (!alias && this.componentInstance) {
+ return this.componentInstance.$attrs && this.componentInstance.$attrs['data-vv-as'];
+ }
+
+ return alias;
+};
+
+/**
+ * Gets the input value.
+ */
+
+prototypeAccessors$1.value.get = function () {
+ if (!isCallable(this.getter)) {
+ return undefined;
+ }
+
+ return this.getter();
+};
+
+prototypeAccessors$1.bails.get = function () {
+ return this._bails;
+};
+
+/**
+ * If the field rejects false as a valid value for the required rule.
+ */
+
+prototypeAccessors$1.rejectsFalse.get = function () {
+ if (this.componentInstance && this.ctorConfig) {
+ return !!this.ctorConfig.rejectsFalse;
+ }
+
+ if (!this.el) {
+ return false;
+ }
+
+ return this.el.type === 'checkbox';
+};
+
+/**
+ * Determines if the instance matches the options provided.
+ */
+Field.prototype.matches = function matches (options) {
+ var this$1 = this;
+
+ if (!options) {
+ return true;
+ }
+
+ if (options.id) {
+ return this.id === options.id;
+ }
+
+ var matchesComponentId = isNullOrUndefined(options.vmId) ? function () { return true; } : function (id) { return id === this$1.vmId; };
+ if (!matchesComponentId(options.vmId)) {
+ return false;
+ }
+
+ if (options.name === undefined && options.scope === undefined) {
+ return true;
+ }
+
+ if (options.scope === undefined) {
+ return this.name === options.name;
+ }
+
+ if (options.name === undefined) {
+ return this.scope === options.scope;
+ }
+
+ return options.name === this.name && options.scope === this.scope;
+};
+
+/**
+ * Caches the field id.
+ */
+Field.prototype._cacheId = function _cacheId (options) {
+ if (this.el && !options.targetOf) {
+ this.el._veeValidateId = this.id;
+ }
+};
+
+/**
+ * Keeps a reference of the most current validation run.
+ */
+Field.prototype.waitFor = function waitFor (pendingPromise) {
+ this._waitingFor = pendingPromise;
+};
+
+Field.prototype.isWaitingFor = function isWaitingFor (promise) {
+ return this._waitingFor === promise;
+};
+
+/**
+ * Updates the field with changed data.
+ */
+Field.prototype.update = function update (options) {
+ this.targetOf = options.targetOf || null;
+ this.immediate = options.immediate || this.immediate || false;
+
+ // update errors scope if the field scope was changed.
+ if (!isNullOrUndefined(options.scope) && options.scope !== this.scope && isCallable(this.validator.update)) {
+ this.validator.update(this.id, { scope: options.scope });
+ }
+ this.scope = !isNullOrUndefined(options.scope) ? options.scope
+ : !isNullOrUndefined(this.scope) ? this.scope : null;
+ this.name = (!isNullOrUndefined(options.name) ? String(options.name) : options.name) || this.name || null;
+ this.rules = options.rules !== undefined ? normalizeRules(options.rules) : this.rules;
+ this._bails = options.bails !== undefined ? options.bails : this._bails;
+ this.model = options.model || this.model;
+ this.listen = options.listen !== undefined ? options.listen : this.listen;
+ this.classes = (options.classes || this.classes || false) && !this.componentInstance;
+ this.classNames = isObject(options.classNames) ? merge(this.classNames, options.classNames) : this.classNames;
+ this.getter = isCallable(options.getter) ? options.getter : this.getter;
+ this._alias = options.alias || this._alias;
+ this.events = (options.events) ? normalizeEvents(options.events) : this.events;
+ this.delay = makeDelayObject(this.events, options.delay || this.delay, this._delay);
+ this.updateDependencies();
+ this.addActionListeners();
+
+ if ("development" !== 'production' && !this.name && !this.targetOf) {
+ warn('A field is missing a "name" or "data-vv-name" attribute');
+ }
+
+ // update required flag flags
+ if (options.rules !== undefined) {
+ this.flags.required = this.isRequired;
+ }
+
+ // validate if it was validated before and field was updated and there was a rules mutation.
+ if (this.flags.validated && options.rules !== undefined && this.updated) {
+ this.validator.validate(("#" + (this.id)));
+ }
+
+ this.updated = true;
+ this.addValueListeners();
+
+ // no need to continue.
+ if (!this.el) {
+ return;
+ }
+ this.updateClasses();
+ this.updateAriaAttrs();
+};
+
+/**
+ * Resets field flags and errors.
+ */
+Field.prototype.reset = function reset () {
+ var this$1 = this;
+
+ if (this._cancellationToken) {
+ this._cancellationToken.cancelled = true;
+ delete this._cancellationToken;
+ }
+
+ var defaults = createFlags();
+ Object.keys(this.flags).filter(function (flag) { return flag !== 'required'; }).forEach(function (flag) {
+ this$1.flags[flag] = defaults[flag];
+ });
+
+ this.addValueListeners();
+ this.addActionListeners();
+ this.updateClasses();
+ this.updateAriaAttrs();
+ this.updateCustomValidity();
+};
+
+/**
+ * Sets the flags and their negated counterparts, and updates the classes and re-adds action listeners.
+ */
+Field.prototype.setFlags = function setFlags (flags) {
+ var this$1 = this;
+
+ var negated = {
+ pristine: 'dirty',
+ dirty: 'pristine',
+ valid: 'invalid',
+ invalid: 'valid',
+ touched: 'untouched',
+ untouched: 'touched'
+ };
+
+ Object.keys(flags).forEach(function (flag) {
+ this$1.flags[flag] = flags[flag];
+ // if it has a negation and was not specified, set it as well.
+ if (negated[flag] && flags[negated[flag]] === undefined) {
+ this$1.flags[negated[flag]] = !flags[flag];
+ }
+ });
+
+ if (
+ flags.untouched !== undefined ||
+ flags.touched !== undefined ||
+ flags.dirty !== undefined ||
+ flags.pristine !== undefined
+ ) {
+ this.addActionListeners();
+ }
+ this.updateClasses();
+ this.updateAriaAttrs();
+ this.updateCustomValidity();
+};
+
+/**
+ * Determines if the field requires references to target fields.
+*/
+Field.prototype.updateDependencies = function updateDependencies () {
+ var this$1 = this;
+
+ // reset dependencies.
+ this.dependencies.forEach(function (d) { return d.field.destroy(); });
+ this.dependencies = [];
+
+ // we get the selectors for each field.
+ var fields = Object.keys(this.rules).reduce(function (prev, r) {
+ if (RuleContainer.isTargetRule(r)) {
+ prev.push({ selector: this$1.rules[r][0], name: r });
+ }
+
+ return prev;
+ }, []);
+
+ if (!fields.length || !this.vm || !this.vm.$el) { return; }
+
+ // must be contained within the same component, so we use the vm root element constrain our dom search.
+ fields.forEach(function (ref$1) {
+ var selector = ref$1.selector;
+ var name = ref$1.name;
+
+ var ref = this$1.vm.$refs[selector];
+ var el = Array.isArray(ref) ? ref[0] : ref;
+ if (!el) {
+ return;
+ }
+
+ var options = {
+ vm: this$1.vm,
+ classes: this$1.classes,
+ classNames: this$1.classNames,
+ delay: this$1.delay,
+ scope: this$1.scope,
+ events: this$1.events.join('|'),
+ immediate: this$1.immediate,
+ targetOf: this$1.id
+ };
+
+ // probably a component.
+ if (isCallable(el.$watch)) {
+ options.component = el;
+ options.el = el.$el;
+ options.getter = Resolver.resolveGetter(el.$el, el.$vnode);
+ } else {
+ options.el = el;
+ options.getter = Resolver.resolveGetter(el, {});
+ }
+
+ this$1.dependencies.push({ name: name, field: new Field(options) });
+ });
+};
+
+/**
+ * Removes listeners.
+ */
+Field.prototype.unwatch = function unwatch (tag) {
+ if ( tag === void 0 ) tag = null;
+
+ if (!tag) {
+ this.watchers.forEach(function (w) { return w.unwatch(); });
+ this.watchers = [];
+ return;
+ }
+
+ this.watchers.filter(function (w) { return tag.test(w.tag); }).forEach(function (w) { return w.unwatch(); });
+ this.watchers = this.watchers.filter(function (w) { return !tag.test(w.tag); });
+};
+
+/**
+ * Updates the element classes depending on each field flag status.
+ */
+Field.prototype.updateClasses = function updateClasses () {
+ var this$1 = this;
+
+ if (!this.classes || this.isDisabled) { return; }
+ var applyClasses = function (el) {
+ toggleClass(el, this$1.classNames.dirty, this$1.flags.dirty);
+ toggleClass(el, this$1.classNames.pristine, this$1.flags.pristine);
+ toggleClass(el, this$1.classNames.touched, this$1.flags.touched);
+ toggleClass(el, this$1.classNames.untouched, this$1.flags.untouched);
+ // make sure we don't set any classes if the state is undetermined.
+ if (!isNullOrUndefined(this$1.flags.valid) && this$1.flags.validated) {
+ toggleClass(el, this$1.classNames.valid, this$1.flags.valid);
+ }
+
+ if (!isNullOrUndefined(this$1.flags.invalid) && this$1.flags.validated) {
+ toggleClass(el, this$1.classNames.invalid, this$1.flags.invalid);
+ }
+ };
+
+ if (!isCheckboxOrRadioInput(this.el)) {
+ applyClasses(this.el);
+ return;
+ }
+
+ var els = document.querySelectorAll(("input[name=\"" + (this.el.name) + "\"]"));
+ toArray(els).forEach(applyClasses);
+};
+
+/**
+ * Adds the listeners required for automatic classes and some flags.
+ */
+Field.prototype.addActionListeners = function addActionListeners () {
+ var this$1 = this;
+
+ // remove previous listeners.
+ this.unwatch(/class/);
+
+ if (!this.el) { return; }
+
+ var onBlur = function () {
+ this$1.flags.touched = true;
+ this$1.flags.untouched = false;
+ if (this$1.classes) {
+ toggleClass(this$1.el, this$1.classNames.touched, true);
+ toggleClass(this$1.el, this$1.classNames.untouched, false);
+ }
+
+ // only needed once.
+ this$1.unwatch(/^class_blur$/);
+ };
+
+ var inputEvent = isTextInput(this.el) ? 'input' : 'change';
+ var onInput = function () {
+ this$1.flags.dirty = true;
+ this$1.flags.pristine = false;
+ if (this$1.classes) {
+ toggleClass(this$1.el, this$1.classNames.pristine, false);
+ toggleClass(this$1.el, this$1.classNames.dirty, true);
+ }
+
+ // only needed once.
+ this$1.unwatch(/^class_input$/);
+ };
+
+ if (this.componentInstance && isCallable(this.componentInstance.$once)) {
+ this.componentInstance.$once('input', onInput);
+ this.componentInstance.$once('blur', onBlur);
+ this.watchers.push({
+ tag: 'class_input',
+ unwatch: function () {
+ this$1.componentInstance.$off('input', onInput);
+ }
+ });
+ this.watchers.push({
+ tag: 'class_blur',
+ unwatch: function () {
+ this$1.componentInstance.$off('blur', onBlur);
+ }
+ });
+ return;
+ }
+
+ if (!this.el) { return; }
+
+ addEventListener(this.el, inputEvent, onInput);
+ // Checkboxes and radio buttons on Mac don't emit blur naturally, so we listen on click instead.
+ var blurEvent = isCheckboxOrRadioInput(this.el) ? 'change' : 'blur';
+ addEventListener(this.el, blurEvent, onBlur);
+ this.watchers.push({
+ tag: 'class_input',
+ unwatch: function () {
+ this$1.el.removeEventListener(inputEvent, onInput);
+ }
+ });
+
+ this.watchers.push({
+ tag: 'class_blur',
+ unwatch: function () {
+ this$1.el.removeEventListener(blurEvent, onBlur);
+ }
+ });
+};
+
+Field.prototype.checkValueChanged = function checkValueChanged () {
+ // handle some people initialize the value to null, since text inputs have empty string value.
+ if (this.initialValue === null && this.value === '' && isTextInput(this.el)) {
+ return false;
+ }
+
+ return this.value !== this.initialValue;
+};
+
+/**
+ * Determines the suitable primary event to listen for.
+ */
+Field.prototype._determineInputEvent = function _determineInputEvent () {
+ // if its a custom component, use the customized model event or the input event.
+ if (this.componentInstance) {
+ return (this.componentInstance.$options.model && this.componentInstance.$options.model.event) || 'input';
+ }
+
+ if (this.model && this.model.lazy) {
+ return 'change';
+ }
+
+ if (isTextInput(this.el)) {
+ return 'input';
+ }
+
+ return 'change';
+};
+
+/**
+ * Determines the list of events to listen to.
+ */
+Field.prototype._determineEventList = function _determineEventList (defaultInputEvent) {
+ var this$1 = this;
+
+ // if no event is configured, or it is a component or a text input then respect the user choice.
+ if (!this.events.length || this.componentInstance || isTextInput(this.el)) {
+ return [].concat( this.events ).map(function (evt) {
+ if (evt === 'input' && this$1.model && this$1.model.lazy) {
+ return 'change';
+ }
+
+ return evt;
+ });
+ }
+
+ // force suitable event for non-text type fields.
+ return this.events.map(function (e) {
+ if (e === 'input') {
+ return defaultInputEvent;
+ }
+
+ return e;
+ });
+};
+
+/**
+ * Adds the listeners required for validation.
+ */
+Field.prototype.addValueListeners = function addValueListeners () {
+ var this$1 = this;
+
+ this.unwatch(/^input_.+/);
+ if (!this.listen || !this.el) { return; }
+
+ var token = { cancelled: false };
+ var fn = this.targetOf ? function () {
+ this$1.flags.changed = this$1.checkValueChanged(); this$1.validator.validate(("#" + (this$1.targetOf)));
+ } : function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ // if its a DOM event, resolve the value, otherwise use the first parameter as the value.
+ if (args.length === 0 || isEvent(args[0])) {
+ args[0] = this$1.value;
+ }
+
+ this$1.flags.changed = this$1.checkValueChanged();
+ this$1.validator.validate(("#" + (this$1.id)), args[0]);
+ };
+
+ var inputEvent = this._determineInputEvent();
+ var events = this._determineEventList(inputEvent);
+
+ // if there is a model and an on input validation is requested.
+ if (this.model && includes(events, inputEvent)) {
+ var ctx = null;
+ var expression = this.model.expression;
+ // if its watchable from the context vm.
+ if (this.model.expression) {
+ ctx = this.vm;
+ expression = this.model.expression;
+ }
+
+ // watch it from the custom component vm instead.
+ if (!expression && this.componentInstance && this.componentInstance.$options.model) {
+ ctx = this.componentInstance;
+ expression = this.componentInstance.$options.model.prop || 'value';
+ }
+
+ if (ctx && expression) {
+ var debouncedFn = debounce(fn, this.delay[inputEvent], token);
+ var unwatch = ctx.$watch(expression, function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ this$1.flags.pending = true;
+ this$1._cancellationToken = token;
+ debouncedFn.apply(void 0, args);
+ });
+ this.watchers.push({
+ tag: 'input_model',
+ unwatch: unwatch
+ });
+
+ // filter out input event as it is already handled by the watcher API.
+ events = events.filter(function (e) { return e !== inputEvent; });
+ }
+ }
+
+ // Add events.
+ events.forEach(function (e) {
+ var debouncedFn = debounce(fn, this$1.delay[e], token);
+ var validate = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ this$1.flags.pending = true;
+ this$1._cancellationToken = token;
+ debouncedFn.apply(void 0, args);
+ };
+
+ this$1._addComponentEventListener(e, validate);
+ this$1._addHTMLEventListener(e, validate);
+ });
+};
+
+Field.prototype._addComponentEventListener = function _addComponentEventListener (evt, validate) {
+ var this$1 = this;
+
+ if (!this.componentInstance) { return; }
+
+ this.componentInstance.$on(evt, validate);
+ this.watchers.push({
+ tag: 'input_vue',
+ unwatch: function () {
+ this$1.componentInstance.$off(evt, validate);
+ }
+ });
+};
+
+Field.prototype._addHTMLEventListener = function _addHTMLEventListener (evt, validate) {
+ var this$1 = this;
+
+ if (!this.el || this.componentInstance) { return; }
+
+ // listen for the current element.
+ var addListener = function (el) {
+ addEventListener(el, evt, validate);
+ this$1.watchers.push({
+ tag: 'input_native',
+ unwatch: function () {
+ el.removeEventListener(evt, validate);
+ }
+ });
+ };
+
+ addListener(this.el);
+ if (!isCheckboxOrRadioInput(this.el)) {
+ return;
+ }
+
+ var els = document.querySelectorAll(("input[name=\"" + (this.el.name) + "\"]"));
+ toArray(els).forEach(function (el) {
+ // skip if it is added by v-validate and is not the current element.
+ if (el._veeValidateId && el !== this$1.el) {
+ return;
+ }
+
+ addListener(el);
+ });
+};
+
+/**
+ * Updates aria attributes on the element.
+ */
+Field.prototype.updateAriaAttrs = function updateAriaAttrs () {
+ var this$1 = this;
+
+ if (!this.aria || !this.el || !isCallable(this.el.setAttribute)) { return; }
+
+ var applyAriaAttrs = function (el) {
+ el.setAttribute('aria-required', this$1.isRequired ? 'true' : 'false');
+ el.setAttribute('aria-invalid', this$1.flags.invalid ? 'true' : 'false');
+ };
+
+ if (!isCheckboxOrRadioInput(this.el)) {
+ applyAriaAttrs(this.el);
+ return;
+ }
+
+ var els = document.querySelectorAll(("input[name=\"" + (this.el.name) + "\"]"));
+ toArray(els).forEach(applyAriaAttrs);
+};
+
+/**
+ * Updates the custom validity for the field.
+ */
+Field.prototype.updateCustomValidity = function updateCustomValidity () {
+ if (!this.validity || !this.el || !isCallable(this.el.setCustomValidity) || !this.validator.errors) { return; }
+
+ this.el.setCustomValidity(this.flags.valid ? '' : (this.validator.errors.firstById(this.id) || ''));
+};
+
+/**
+ * Removes all listeners.
+ */
+Field.prototype.destroy = function destroy () {
+ // ignore the result of any ongoing validation.
+ if (this._cancellationToken) {
+ this._cancellationToken.cancelled = true;
+ }
+
+ this.unwatch();
+ this.dependencies.forEach(function (d) { return d.field.destroy(); });
+ this.dependencies = [];
+};
+
+Object.defineProperties( Field.prototype, prototypeAccessors$1 );
+
+//
+
+var FieldBag = function FieldBag (items) {
+ if ( items === void 0 ) items = [];
+
+ this.items = items || [];
+};
+
+var prototypeAccessors$2 = { length: { configurable: true } };
+
+FieldBag.prototype[typeof Symbol === 'function' ? Symbol.iterator : '@@iterator'] = function () {
+ var this$1 = this;
+
+ var index = 0;
+ return {
+ next: function () {
+ return { value: this$1.items[index++], done: index > this$1.items.length };
+ }
+ };
+};
+
+/**
+ * Gets the current items length.
+ */
+
+prototypeAccessors$2.length.get = function () {
+ return this.items.length;
+};
+
+/**
+ * Finds the first field that matches the provided matcher object.
+ */
+FieldBag.prototype.find = function find$1 (matcher) {
+ return find(this.items, function (item) { return item.matches(matcher); });
+};
+
+/**
+ * Filters the items down to the matched fields.
+ */
+FieldBag.prototype.filter = function filter (matcher) {
+ // multiple matchers to be tried.
+ if (Array.isArray(matcher)) {
+ return this.items.filter(function (item) { return matcher.some(function (m) { return item.matches(m); }); });
+ }
+
+ return this.items.filter(function (item) { return item.matches(matcher); });
+};
+
+/**
+ * Maps the field items using the mapping function.
+ */
+FieldBag.prototype.map = function map (mapper) {
+ return this.items.map(mapper);
+};
+
+/**
+ * Finds and removes the first field that matches the provided matcher object, returns the removed item.
+ */
+FieldBag.prototype.remove = function remove (matcher) {
+ var item = null;
+ if (matcher instanceof Field) {
+ item = matcher;
+ } else {
+ item = this.find(matcher);
+ }
+
+ if (!item) { return null; }
+
+ var index = this.items.indexOf(item);
+ this.items.splice(index, 1);
+
+ return item;
+};
+
+/**
+ * Adds a field item to the list.
+ */
+FieldBag.prototype.push = function push (item) {
+ if (! (item instanceof Field)) {
+ throw createError('FieldBag only accepts instances of Field that has an id defined.');
+ }
+
+ if (!item.id) {
+ throw createError('Field id must be defined.');
+ }
+
+ if (this.find({ id: item.id })) {
+ throw createError(("Field with id " + (item.id) + " is already added."));
+ }
+
+ this.items.push(item);
+};
+
+Object.defineProperties( FieldBag.prototype, prototypeAccessors$2 );
+
+var ScopedValidator = function ScopedValidator (base, vm) {
+ this.id = vm._uid;
+ this._base = base;
+ this._paused = false;
+
+ // create a mirror bag with limited component scope.
+ this.errors = new ErrorBag(base.errors, this.id);
+};
+
+var prototypeAccessors$3 = { flags: { configurable: true },rules: { configurable: true },fields: { configurable: true },dictionary: { configurable: true },locale: { configurable: true } };
+
+prototypeAccessors$3.flags.get = function () {
+ var this$1 = this;
+
+ return this._base.fields.items.filter(function (f) { return f.vmId === this$1.id; }).reduce(function (acc, field) {
+ if (field.scope) {
+ if (!acc[("$" + (field.scope))]) {
+ acc[("$" + (field.scope))] = {};
+ }
+
+ acc[("$" + (field.scope))][field.name] = field.flags;
+ }
+
+ acc[field.name] = field.flags;
+
+ return acc;
+ }, {});
+};
+
+prototypeAccessors$3.rules.get = function () {
+ return this._base.rules;
+};
+
+prototypeAccessors$3.fields.get = function () {
+ return new FieldBag(this._base.fields.filter({ vmId: this.id }));
+};
+
+prototypeAccessors$3.dictionary.get = function () {
+ return this._base.dictionary;
+};
+
+prototypeAccessors$3.locale.get = function () {
+ return this._base.locale;
+};
+
+prototypeAccessors$3.locale.set = function (val) {
+ this._base.locale = val;
+};
+
+ScopedValidator.prototype.localize = function localize () {
+ var ref;
+
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+ return (ref = this._base).localize.apply(ref, args);
+};
+
+ScopedValidator.prototype.update = function update () {
+ var ref;
+
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+ return (ref = this._base).update.apply(ref, args);
+};
+
+ScopedValidator.prototype.attach = function attach (opts) {
+ var attachOpts = assign({}, opts, { vmId: this.id });
+
+ return this._base.attach(attachOpts);
+};
+
+ScopedValidator.prototype.pause = function pause () {
+ this._paused = true;
+};
+
+ScopedValidator.prototype.resume = function resume () {
+ this._paused = false;
+};
+
+ScopedValidator.prototype.remove = function remove (ruleName) {
+ return this._base.remove(ruleName);
+};
+
+ScopedValidator.prototype.detach = function detach () {
+ var ref;
+
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+ return (ref = this._base).detach.apply(ref, args.concat( [this.id] ));
+};
+
+ScopedValidator.prototype.extend = function extend () {
+ var ref;
+
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+ return (ref = this._base).extend.apply(ref, args);
+};
+
+ScopedValidator.prototype.validate = function validate (descriptor, value, opts) {
+ if ( opts === void 0 ) opts = {};
+
+ if (this._paused) { return Promise.resolve(true); }
+
+ return this._base.validate(descriptor, value, assign({}, { vmId: this.id }, opts || {}));
+};
+
+ScopedValidator.prototype.validateAll = function validateAll (values$$1, opts) {
+ if ( opts === void 0 ) opts = {};
+
+ if (this._paused) { return Promise.resolve(true); }
+
+ return this._base.validateAll(values$$1, assign({}, { vmId: this.id }, opts || {}));
+};
+
+ScopedValidator.prototype.validateScopes = function validateScopes (opts) {
+ if ( opts === void 0 ) opts = {};
+
+ if (this._paused) { return Promise.resolve(true); }
+
+ return this._base.validateScopes(assign({}, { vmId: this.id }, opts || {}));
+};
+
+ScopedValidator.prototype.destroy = function destroy () {
+ delete this.id;
+ delete this._base;
+};
+
+ScopedValidator.prototype.reset = function reset (matcher) {
+ return this._base.reset(Object.assign({}, matcher || {}, { vmId: this.id }));
+};
+
+ScopedValidator.prototype.flag = function flag () {
+ var ref;
+
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+ return (ref = this._base).flag.apply(ref, args.concat( [this.id] ));
+};
+
+Object.defineProperties( ScopedValidator.prototype, prototypeAccessors$3 );
+
+//
+
+/**
+ * Checks if a parent validator instance was requested.
+ */
+var requestsValidator = function (injections) {
+ if (isObject(injections) && injections.$validator) {
+ return true;
+ }
+
+ return false;
+};
+
+var mixin = {
+ provide: function provide () {
+ if (this.$validator && !isBuiltInComponent(this.$vnode)) {
+ return {
+ $validator: this.$validator
+ };
+ }
+
+ return {};
+ },
+ beforeCreate: function beforeCreate () {
+ // if built in do nothing.
+ if (isBuiltInComponent(this.$vnode) || this.$options.$__veeInject === false) {
+ return;
+ }
+
+ // if its a root instance set the config if it exists.
+ if (!this.$parent) {
+ pluginInstance.configure(this.$options.$_veeValidate || {});
+ }
+
+ var options = pluginInstance.resolveConfig(this);
+
+ // if its a root instance, inject anyways, or if it requested a new instance.
+ if (!this.$parent || (this.$options.$_veeValidate && /new/.test(this.$options.$_veeValidate.validator))) {
+ this.$validator = new ScopedValidator(pluginInstance._validator, this);
+ }
+
+ var requested = requestsValidator(this.$options.inject);
+
+ // if automatic injection is enabled and no instance was requested.
+ if (! this.$validator && options.inject && !requested) {
+ this.$validator = new ScopedValidator(pluginInstance._validator, this);
+ }
+
+ // don't inject errors or fieldBag as no validator was resolved.
+ if (! requested && ! this.$validator) {
+ return;
+ }
+
+ // There is a validator but it isn't injected, mark as reactive.
+ if (!requested && this.$validator) {
+ var Vue = this.$options._base; // the vue constructor.
+ Vue.util.defineReactive(this.$validator, 'errors', this.$validator.errors);
+ }
+
+ if (! this.$options.computed) {
+ this.$options.computed = {};
+ }
+
+ this.$options.computed[options.errorBagName || 'errors'] = function errorBagGetter () {
+ return this.$validator.errors;
+ };
+ this.$options.computed[options.fieldsBagName || 'fields'] = function fieldBagGetter () {
+ return this.$validator.fields.items.reduce(function (acc, field) {
+ if (field.scope) {
+ if (!acc[("$" + (field.scope))]) {
+ acc[("$" + (field.scope))] = {};
+ }
+
+ acc[("$" + (field.scope))][field.name] = field.flags;
+
+ return acc;
+ }
+
+ acc[field.name] = field.flags;
+
+ return acc;
+ }, {});
+ };
+ },
+ beforeDestroy: function beforeDestroy () {
+ if (this.$validator && this._uid === this.$validator.id) {
+ this.$validator.errors.clear(); // remove errors generated by this component.
+ }
+ }
+};
+
+//
+
+/**
+ * Finds the requested field by id from the context object.
+ */
+function findField (el, context) {
+ if (!context || !context.$validator) {
+ return null;
+ }
+
+ return context.$validator.fields.find({ id: el._veeValidateId });
+}
+var directive = {
+ bind: function bind (el, binding, vnode) {
+ var validator = vnode.context.$validator;
+ if (!validator) {
+ if (true) {
+ warn("No validator instance is present on vm, did you forget to inject '$validator'?");
+ }
+
+ return;
+ }
+
+ var fieldOptions = Resolver.generate(el, binding, vnode);
+ validator.attach(fieldOptions);
+ },
+ inserted: function inserted (el, binding, vnode) {
+ var field = findField(el, vnode.context);
+ var scope = Resolver.resolveScope(el, binding, vnode);
+
+ // skip if scope hasn't changed.
+ if (!field || scope === field.scope) { return; }
+
+ // only update scope.
+ field.update({ scope: scope });
+
+ // allows the field to re-evaluated once more in the update hook.
+ field.updated = false;
+ },
+ update: function update (el, binding, vnode) {
+ var field = findField(el, vnode.context);
+
+ // make sure we don't do unneccasary work if no important change was done.
+ if (!field || (field.updated && isEqual(binding.value, binding.oldValue))) { return; }
+ var scope = Resolver.resolveScope(el, binding, vnode);
+ var rules = Resolver.resolveRules(el, binding, vnode);
+
+ field.update({
+ scope: scope,
+ rules: rules
+ });
+ },
+ unbind: function unbind (el, binding, ref) {
+ var context = ref.context;
+
+ var field = findField(el, context);
+ if (!field) { return; }
+
+ context.$validator.detach(field);
+ }
+};
+
+//
+
+var Validator = function Validator (validations, options) {
+ if ( options === void 0 ) options = { fastExit: true };
+
+ this.errors = new ErrorBag();
+ this.fields = new FieldBag();
+ this._createFields(validations);
+ this.paused = false;
+ this.fastExit = !isNullOrUndefined(options && options.fastExit) ? options.fastExit : true;
+};
+
+var prototypeAccessors$4 = { rules: { configurable: true },dictionary: { configurable: true },flags: { configurable: true },locale: { configurable: true } };
+var staticAccessors$1 = { rules: { configurable: true },dictionary: { configurable: true },locale: { configurable: true } };
+
+staticAccessors$1.rules.get = function () {
+ return RuleContainer.rules;
+};
+
+prototypeAccessors$4.rules.get = function () {
+ return RuleContainer.rules;
+};
+
+prototypeAccessors$4.dictionary.get = function () {
+ return VeeValidate$1.i18nDriver;
+};
+
+staticAccessors$1.dictionary.get = function () {
+ return VeeValidate$1.i18nDriver;
+};
+
+prototypeAccessors$4.flags.get = function () {
+ return this.fields.items.reduce(function (acc, field) {
+ var obj;
+
+ if (field.scope) {
+ acc[("$" + (field.scope))] = ( obj = {}, obj[field.name] = field.flags, obj );
+
+ return acc;
+ }
+
+ acc[field.name] = field.flags;
+
+ return acc;
+ }, {});
+};
+
+/**
+ * Getter for the current locale.
+ */
+prototypeAccessors$4.locale.get = function () {
+ return Validator.locale;
+};
+
+/**
+ * Setter for the validator locale.
+ */
+prototypeAccessors$4.locale.set = function (value) {
+ Validator.locale = value;
+};
+
+staticAccessors$1.locale.get = function () {
+ return VeeValidate$1.i18nDriver.locale;
+};
+
+/**
+ * Setter for the validator locale.
+ */
+staticAccessors$1.locale.set = function (value) {
+ var hasChanged = value !== VeeValidate$1.i18nDriver.locale;
+ VeeValidate$1.i18nDriver.locale = value;
+ if (hasChanged && VeeValidate$1.instance && VeeValidate$1.instance._vm) {
+ VeeValidate$1.instance._vm.$emit('localeChanged');
+ }
+};
+
+/**
+ * Static constructor.
+ */
+Validator.create = function create (validations, options) {
+ return new Validator(validations, options);
+};
+
+/**
+ * Adds a custom validator to the list of validation rules.
+ */
+Validator.extend = function extend (name, validator, options) {
+ if ( options === void 0 ) options = {};
+
+ Validator._guardExtend(name, validator);
+ Validator._merge(name, {
+ validator: validator,
+ paramNames: options && options.paramNames,
+ options: assign({}, { hasTarget: false, immediate: true }, options || {})
+ });
+};
+
+/**
+ * Removes a rule from the list of validators.
+ */
+Validator.remove = function remove (name) {
+ RuleContainer.remove(name);
+};
+
+/**
+ * Checks if the given rule name is a rule that targets other fields.
+ */
+Validator.isTargetRule = function isTargetRule (name) {
+ return RuleContainer.isTargetRule(name);
+};
+
+/**
+ * Adds and sets the current locale for the validator.
+ */
+Validator.prototype.localize = function localize (lang, dictionary) {
+ Validator.localize(lang, dictionary);
+};
+
+/**
+ * Adds and sets the current locale for the validator.
+ */
+Validator.localize = function localize (lang, dictionary) {
+ var obj;
+
+ if (isObject(lang)) {
+ VeeValidate$1.i18nDriver.merge(lang);
+ return;
+ }
+
+ // merge the dictionary.
+ if (dictionary) {
+ var locale = lang || dictionary.name;
+ dictionary = assign({}, dictionary);
+ VeeValidate$1.i18nDriver.merge(( obj = {}, obj[locale] = dictionary, obj ));
+ }
+
+ if (lang) {
+ // set the locale.
+ Validator.locale = lang;
+ }
+};
+
+/**
+ * Registers a field to be validated.
+ */
+Validator.prototype.attach = function attach (fieldOpts) {
+ var this$1 = this;
+
+ // fixes initial value detection with v-model and select elements.
+ var value = fieldOpts.initialValue;
+ var field = new Field(fieldOpts);
+ this.fields.push(field);
+
+ // validate the field initially
+ if (field.immediate) {
+ VeeValidate$1.instance._vm.$nextTick(function () { return this$1.validate(("#" + (field.id)), value || field.value, { vmId: fieldOpts.vmId }); });
+ } else {
+ this._validate(field, value || field.value, { initial: true }).then(function (result) {
+ field.flags.valid = result.valid;
+ field.flags.invalid = !result.valid;
+ });
+ }
+
+ return field;
+};
+
+/**
+ * Sets the flags on a field.
+ */
+Validator.prototype.flag = function flag (name, flags, uid) {
+ if ( uid === void 0 ) uid = null;
+
+ var field = this._resolveField(name, undefined, uid);
+ if (!field || !flags) {
+ return;
+ }
+
+ field.setFlags(flags);
+};
+
+/**
+ * Removes a field from the validator.
+ */
+Validator.prototype.detach = function detach (name, scope, uid) {
+ var field = isCallable(name.destroy) ? name : this._resolveField(name, scope, uid);
+ if (!field) { return; }
+
+ field.destroy();
+ this.errors.remove(field.name, field.scope, field.vmId);
+ this.fields.remove(field);
+};
+
+/**
+ * Adds a custom validator to the list of validation rules.
+ */
+Validator.prototype.extend = function extend (name, validator, options) {
+ if ( options === void 0 ) options = {};
+
+ Validator.extend(name, validator, options);
+};
+
+Validator.prototype.reset = function reset (matcher) {
+ var this$1 = this;
+
+ // two ticks
+ return VeeValidate$1.instance._vm.$nextTick().then(function () {
+ return VeeValidate$1.instance._vm.$nextTick();
+ }).then(function () {
+ this$1.fields.filter(matcher).forEach(function (field) {
+ field.waitFor(null);
+ field.reset(); // reset field flags.
+ this$1.errors.remove(field.name, field.scope, matcher && matcher.vmId);
+ });
+ });
+};
+
+/**
+ * Updates a field, updating both errors and flags.
+ */
+Validator.prototype.update = function update (id, ref) {
+ var scope = ref.scope;
+
+ var field = this._resolveField(("#" + id));
+ if (!field) { return; }
+
+ // remove old scope.
+ this.errors.update(id, { scope: scope });
+};
+
+/**
+ * Removes a rule from the list of validators.
+ */
+Validator.prototype.remove = function remove (name) {
+ Validator.remove(name);
+};
+
+/**
+ * Validates a value against a registered field validations.
+ */
+Validator.prototype.validate = function validate (fieldDescriptor, value, ref) {
+ var this$1 = this;
+ if ( ref === void 0 ) ref = {};
+ var silent = ref.silent;
+ var vmId = ref.vmId;
+
+ if (this.paused) { return Promise.resolve(true); }
+
+ // overload to validate all.
+ if (isNullOrUndefined(fieldDescriptor)) {
+ return this.validateScopes({ silent: silent, vmId: vmId });
+ }
+
+ // overload to validate scope-less fields.
+ if (fieldDescriptor === '*') {
+ return this.validateAll(undefined, { silent: silent, vmId: vmId });
+ }
+
+ // if scope validation was requested.
+ if (/^(.+)\.\*$/.test(fieldDescriptor)) {
+ var matched = fieldDescriptor.match(/^(.+)\.\*$/)[1];
+ return this.validateAll(matched);
+ }
+
+ var field = this._resolveField(fieldDescriptor);
+ if (!field) {
+ return this._handleFieldNotFound(name);
+ }
+
+ if (!silent) { field.flags.pending = true; }
+ if (value === undefined) {
+ value = field.value;
+ }
+
+ var validationPromise = this._validate(field, value);
+ field.waitFor(validationPromise);
+
+ return validationPromise.then(function (result) {
+ if (!silent && field.isWaitingFor(validationPromise)) {
+ // allow next validation to mutate the state.
+ field.waitFor(null);
+ this$1._handleValidationResults([result], vmId);
+ }
+
+ return result.valid;
+ });
+};
+
+/**
+ * Pauses the validator.
+ */
+Validator.prototype.pause = function pause () {
+ this.paused = true;
+
+ return this;
+};
+
+/**
+ * Resumes the validator.
+ */
+Validator.prototype.resume = function resume () {
+ this.paused = false;
+
+ return this;
+};
+
+/**
+ * Validates each value against the corresponding field validations.
+ */
+Validator.prototype.validateAll = function validateAll (values$$1, ref) {
+ var this$1 = this;
+ if ( ref === void 0 ) ref = {};
+ var silent = ref.silent;
+ var vmId = ref.vmId;
+
+ if (this.paused) { return Promise.resolve(true); }
+
+ var matcher = null;
+ var providedValues = false;
+
+ if (typeof values$$1 === 'string') {
+ matcher = { scope: values$$1, vmId: vmId };
+ } else if (isObject(values$$1)) {
+ matcher = Object.keys(values$$1).map(function (key) {
+ return { name: key, vmId: vmId, scope: null };
+ });
+ providedValues = true;
+ } else if (Array.isArray(values$$1)) {
+ matcher = values$$1.map(function (key) {
+ return { name: key, vmId: vmId };
+ });
+ } else {
+ matcher = { scope: null, vmId: vmId };
+ }
+
+ return Promise.all(
+ this.fields.filter(matcher).map(function (field) { return this$1._validate(field, providedValues ? values$$1[field.name] : field.value); })
+ ).then(function (results) {
+ if (!silent) {
+ this$1._handleValidationResults(results, vmId);
+ }
+
+ return results.every(function (t) { return t.valid; });
+ });
+};
+
+/**
+ * Validates all scopes.
+ */
+Validator.prototype.validateScopes = function validateScopes (ref) {
+ var this$1 = this;
+ if ( ref === void 0 ) ref = {};
+ var silent = ref.silent;
+ var vmId = ref.vmId;
+
+ if (this.paused) { return Promise.resolve(true); }
+
+ return Promise.all(
+ this.fields.filter({ vmId: vmId }).map(function (field) { return this$1._validate(field, field.value); })
+ ).then(function (results) {
+ if (!silent) {
+ this$1._handleValidationResults(results, vmId);
+ }
+
+ return results.every(function (t) { return t.valid; });
+ });
+};
+
+/**
+ * Validates a value against the rules.
+ */
+Validator.prototype.verify = function verify (value, rules, options) {
+ if ( options === void 0 ) options = {};
+
+ var field = {
+ name: (options && options.name) || '{field}',
+ rules: normalizeRules(rules),
+ bails: getPath('bails', options, true)
+ };
+
+ field.isRequired = field.rules.required;
+ var targetRules = Object.keys(field.rules).filter(Validator.isTargetRule);
+ if (targetRules.length && options && isObject(options.values)) {
+ // patch the field params with the targets' values.
+ targetRules.forEach(function (rule) {
+ var ref = field.rules[rule];
+ var first = ref[0];
+ var rest = ref.slice(1);
+ field.rules[rule] = [options.values[first] ].concat( rest);
+ });
+ }
+
+ return this._validate(field, value).then(function (result) {
+ return { valid: result.valid, errors: result.errors.map(function (e) { return e.msg; }) };
+ });
+};
+
+/**
+ * Perform cleanup.
+ */
+Validator.prototype.destroy = function destroy () {
+ VeeValidate$1.instance._vm.$off('localeChanged');
+};
+
+/**
+ * Creates the fields to be validated.
+ */
+Validator.prototype._createFields = function _createFields (validations) {
+ var this$1 = this;
+
+ if (!validations) { return; }
+
+ Object.keys(validations).forEach(function (field) {
+ var options = assign({}, { name: field, rules: validations[field] });
+ this$1.attach(options);
+ });
+};
+
+/**
+ * Date rules need the existence of a format, so date_format must be supplied.
+ */
+Validator.prototype._getDateFormat = function _getDateFormat (validations) {
+ var format = null;
+ if (validations.date_format && Array.isArray(validations.date_format)) {
+ format = validations.date_format[0];
+ }
+
+ return format || VeeValidate$1.i18nDriver.getDateFormat(this.locale);
+};
+
+/**
+ * Formats an error message for field and a rule.
+ */
+Validator.prototype._formatErrorMessage = function _formatErrorMessage (field, rule, data, targetName) {
+ if ( data === void 0 ) data = {};
+ if ( targetName === void 0 ) targetName = null;
+
+ var name = this._getFieldDisplayName(field);
+ var params = this._getLocalizedParams(rule, targetName);
+
+ return VeeValidate$1.i18nDriver.getFieldMessage(this.locale, field.name, rule.name, [name, params, data]);
+};
+
+/**
+ * We need to convert any object param to an array format since the locales do not handle params as objects yet.
+ */
+Validator.prototype._convertParamObjectToArray = function _convertParamObjectToArray (obj, ruleName) {
+ if (Array.isArray(obj)) {
+ return obj;
+ }
+
+ var paramNames = RuleContainer.getParamNames(ruleName);
+ if (!paramNames || !isObject(obj)) {
+ return obj;
+ }
+
+ return paramNames.reduce(function (prev, paramName) {
+ if (paramName in obj) {
+ prev.push(obj[paramName]);
+ }
+
+ return prev;
+ }, []);
+};
+
+/**
+ * Translates the parameters passed to the rule (mainly for target fields).
+ */
+Validator.prototype._getLocalizedParams = function _getLocalizedParams (rule, targetName) {
+ if ( targetName === void 0 ) targetName = null;
+
+ var params = this._convertParamObjectToArray(rule.params, rule.name);
+ if (rule.options.hasTarget && params && params[0]) {
+ var localizedName = targetName || VeeValidate$1.i18nDriver.getAttribute(this.locale, params[0], params[0]);
+ return [localizedName].concat(params.slice(1));
+ }
+
+ return params;
+};
+
+/**
+ * Resolves an appropriate display name, first checking 'data-as' or the registered 'prettyName'
+ */
+Validator.prototype._getFieldDisplayName = function _getFieldDisplayName (field) {
+ return field.alias || VeeValidate$1.i18nDriver.getAttribute(this.locale, field.name, field.name);
+};
+
+/**
+ * Converts an array of params to an object with named properties.
+ * Only works if the rule is configured with a paramNames array.
+ * Returns the same params if it cannot convert it.
+ */
+Validator.prototype._convertParamArrayToObj = function _convertParamArrayToObj (params, ruleName) {
+ var paramNames = RuleContainer.getParamNames(ruleName);
+ if (!paramNames) {
+ return params;
+ }
+
+ if (isObject(params)) {
+ // check if the object is either a config object or a single parameter that is an object.
+ var hasKeys = paramNames.some(function (name) { return Object.keys(params).indexOf(name) !== -1; });
+ // if it has some of the keys, return it as is.
+ if (hasKeys) {
+ return params;
+ }
+ // otherwise wrap the object in an array.
+ params = [params];
+ }
+
+ // Reduce the paramsNames to a param object.
+ return params.reduce(function (prev, value, idx) {
+ prev[paramNames[idx]] = value;
+
+ return prev;
+ }, {});
+};
+
+/**
+ * Tests a single input value against a rule.
+ */
+Validator.prototype._test = function _test (field, value, rule) {
+ var this$1 = this;
+
+ var validator = RuleContainer.getValidatorMethod(rule.name);
+ var params = Array.isArray(rule.params) ? toArray(rule.params) : rule.params;
+ if (!params) {
+ params = [];
+ }
+
+ var targetName = null;
+ if (!validator || typeof validator !== 'function') {
+ return Promise.reject(createError(("No such validator '" + (rule.name) + "' exists.")));
+ }
+
+ // has field dependencies.
+ if (rule.options.hasTarget && field.dependencies) {
+ var target = find(field.dependencies, function (d) { return d.name === rule.name; });
+ if (target) {
+ targetName = target.field.alias;
+ params = [target.field.value].concat(params.slice(1));
+ }
+ } else if (rule.name === 'required' && field.rejectsFalse) {
+ // invalidate false if no args were specified and the field rejects false by default.
+ params = params.length ? params : [true];
+ }
+
+ if (rule.options.isDate) {
+ var dateFormat = this._getDateFormat(field.rules);
+ if (rule.name !== 'date_format') {
+ params.push(dateFormat);
+ }
+ }
+
+ var result = validator(value, this._convertParamArrayToObj(params, rule.name));
+
+ // If it is a promise.
+ if (isCallable(result.then)) {
+ return result.then(function (values$$1) {
+ var allValid = true;
+ var data = {};
+ if (Array.isArray(values$$1)) {
+ allValid = values$$1.every(function (t) { return (isObject(t) ? t.valid : t); });
+ } else { // Is a single object/boolean.
+ allValid = isObject(values$$1) ? values$$1.valid : values$$1;
+ data = values$$1.data;
+ }
+
+ return {
+ valid: allValid,
+ errors: allValid ? [] : [this$1._createFieldError(field, rule, data, targetName)]
+ };
+ });
+ }
+
+ if (!isObject(result)) {
+ result = { valid: result, data: {} };
+ }
+
+ return {
+ valid: result.valid,
+ errors: result.valid ? [] : [this._createFieldError(field, rule, result.data, targetName)]
+ };
+};
+
+/**
+ * Merges a validator object into the RULES and Messages.
+ */
+Validator._merge = function _merge (name, ref) {
+ var validator = ref.validator;
+ var options = ref.options;
+ var paramNames = ref.paramNames;
+
+ var validate = isCallable(validator) ? validator : validator.validate;
+ if (validator.getMessage) {
+ VeeValidate$1.i18nDriver.setMessage(Validator.locale, name, validator.getMessage);
+ }
+
+ RuleContainer.add(name, {
+ validate: validate,
+ options: options,
+ paramNames: paramNames
+ });
+};
+
+/**
+ * Guards from extension violations.
+ */
+Validator._guardExtend = function _guardExtend (name, validator) {
+ if (isCallable(validator)) {
+ return;
+ }
+
+ if (!isCallable(validator.validate)) {
+ throw createError(
+ ("Extension Error: The validator '" + name + "' must be a function or have a 'validate' method.")
+ );
+ }
+};
+
+/**
+ * Creates a Field Error Object.
+ */
+Validator.prototype._createFieldError = function _createFieldError (field, rule, data, targetName) {
+ var this$1 = this;
+
+ return {
+ id: field.id,
+ vmId: field.vmId,
+ field: field.name,
+ msg: this._formatErrorMessage(field, rule, data, targetName),
+ rule: rule.name,
+ scope: field.scope,
+ regenerate: function () {
+ return this$1._formatErrorMessage(field, rule, data, targetName);
+ }
+ };
+};
+
+/**
+ * Tries different strategies to find a field.
+ */
+Validator.prototype._resolveField = function _resolveField (name, scope, uid) {
+ if (name[0] === '#') {
+ return this.fields.find({ id: name.slice(1) });
+ }
+
+ if (!isNullOrUndefined(scope)) {
+ return this.fields.find({ name: name, scope: scope, vmId: uid });
+ }
+
+ if (includes(name, '.')) {
+ var ref = name.split('.');
+ var fieldScope = ref[0];
+ var fieldName = ref.slice(1);
+ var field = this.fields.find({ name: fieldName.join('.'), scope: fieldScope, vmId: uid });
+ if (field) {
+ return field;
+ }
+ }
+
+ return this.fields.find({ name: name, scope: null, vmId: uid });
+};
+
+/**
+ * Handles when a field is not found.
+ */
+Validator.prototype._handleFieldNotFound = function _handleFieldNotFound (name, scope) {
+ var fullName = isNullOrUndefined(scope) ? name : ("" + (!isNullOrUndefined(scope) ? scope + '.' : '') + name);
+
+ return Promise.reject(createError(
+ ("Validating a non-existent field: \"" + fullName + "\". Use \"attach()\" first.")
+ ));
+};
+
+/**
+ * Handles validation results.
+ */
+Validator.prototype._handleValidationResults = function _handleValidationResults (results, vmId) {
+ var this$1 = this;
+
+ var matchers = results.map(function (result) { return ({ id: result.id }); });
+ this.errors.removeById(matchers.map(function (m) { return m.id; }));
+ // remove by name and scope to remove any custom errors added.
+ results.forEach(function (result) {
+ this$1.errors.remove(result.field, result.scope, vmId);
+ });
+ var allErrors = results.reduce(function (prev, curr) {
+ prev.push.apply(prev, curr.errors);
+
+ return prev;
+ }, []);
+
+ this.errors.add(allErrors);
+
+ // handle flags.
+ this.fields.filter(matchers).forEach(function (field) {
+ var result = find(results, function (r) { return r.id === field.id; });
+ field.setFlags({
+ pending: false,
+ valid: result.valid,
+ validated: true
+ });
+ });
+};
+
+Validator.prototype._shouldSkip = function _shouldSkip (field, value) {
+ // field is configured to run through the pipeline regardless
+ if (field.bails === false) {
+ return false;
+ }
+
+ // disabled fields are skipped
+ if (field.isDisabled) {
+ return true;
+ }
+
+ // skip if the field is not required and has an empty value.
+ return !field.isRequired && (isNullOrUndefined(value) || value === '' || isEmptyArray(value));
+};
+
+Validator.prototype._shouldBail = function _shouldBail (field) {
+ // if the field was configured explicitly.
+ if (field.bails !== undefined) {
+ return field.bails;
+ }
+
+ return this.fastExit;
+};
+
+/**
+ * Starts the validation process.
+ */
+Validator.prototype._validate = function _validate (field, value, ref) {
+ var this$1 = this;
+ if ( ref === void 0 ) ref = {};
+ var initial = ref.initial;
+
+ if (this._shouldSkip(field, value)) {
+ return Promise.resolve({ valid: true, id: field.id, field: field.name, scope: field.scope, errors: [] });
+ }
+
+ var promises = [];
+ var errors = [];
+ var isExitEarly = false;
+ // use of '.some()' is to break iteration in middle by returning true
+ Object.keys(field.rules).filter(function (rule) {
+ if (!initial || !RuleContainer.has(rule)) { return true; }
+
+ return RuleContainer.isImmediate(rule);
+ }).some(function (rule) {
+ var ruleOptions = RuleContainer.getOptions(rule);
+ var result = this$1._test(field, value, { name: rule, params: field.rules[rule], options: ruleOptions });
+ if (isCallable(result.then)) {
+ promises.push(result);
+ } else if (!result.valid && this$1._shouldBail(field)) {
+ errors.push.apply(errors, result.errors);
+ isExitEarly = true;
+ } else {
+ // promisify the result.
+ promises.push(new Promise(function (resolve) { return resolve(result); }));
+ }
+
+ return isExitEarly;
+ });
+
+ if (isExitEarly) {
+ return Promise.resolve({ valid: false, errors: errors, id: field.id, field: field.name, scope: field.scope });
+ }
+
+ return Promise.all(promises).then(function (results) {
+ return results.reduce(function (prev, v) {
+ var ref;
+
+ if (!v.valid) {
+ (ref = prev.errors).push.apply(ref, v.errors);
+ }
+
+ prev.valid = prev.valid && v.valid;
+
+ return prev;
+ }, { valid: true, errors: errors, id: field.id, field: field.name, scope: field.scope });
+ });
+};
+
+Object.defineProperties( Validator.prototype, prototypeAccessors$4 );
+Object.defineProperties( Validator, staticAccessors$1 );
+
+//
+
+var normalize = function (fields) {
+ if (Array.isArray(fields)) {
+ return fields.reduce(function (prev, curr) {
+ if (includes(curr, '.')) {
+ prev[curr.split('.')[1]] = curr;
+ } else {
+ prev[curr] = curr;
+ }
+
+ return prev;
+ }, {});
+ }
+
+ return fields;
+};
+
+// Combines two flags using either AND or OR depending on the flag type.
+var combine = function (lhs, rhs) {
+ var mapper = {
+ pristine: function (lhs, rhs) { return lhs && rhs; },
+ dirty: function (lhs, rhs) { return lhs || rhs; },
+ touched: function (lhs, rhs) { return lhs || rhs; },
+ untouched: function (lhs, rhs) { return lhs && rhs; },
+ valid: function (lhs, rhs) { return lhs && rhs; },
+ invalid: function (lhs, rhs) { return lhs || rhs; },
+ pending: function (lhs, rhs) { return lhs || rhs; },
+ required: function (lhs, rhs) { return lhs || rhs; },
+ validated: function (lhs, rhs) { return lhs && rhs; }
+ };
+
+ return Object.keys(mapper).reduce(function (flags, flag) {
+ flags[flag] = mapper[flag](lhs[flag], rhs[flag]);
+
+ return flags;
+ }, {});
+};
+
+var mapScope = function (scope, deep) {
+ if ( deep === void 0 ) deep = true;
+
+ return Object.keys(scope).reduce(function (flags, field) {
+ if (!flags) {
+ flags = assign({}, scope[field]);
+ return flags;
+ }
+
+ // scope.
+ var isScope = field.indexOf('$') === 0;
+ if (deep && isScope) {
+ return combine(mapScope(scope[field]), flags);
+ } else if (!deep && isScope) {
+ return flags;
+ }
+
+ flags = combine(flags, scope[field]);
+
+ return flags;
+ }, null);
+};
+
+/**
+ * Maps fields to computed functions.
+ */
+var mapFields = function (fields) {
+ if (!fields) {
+ return function () {
+ return mapScope(this.$validator.flags);
+ };
+ }
+
+ var normalized = normalize(fields);
+ return Object.keys(normalized).reduce(function (prev, curr) {
+ var field = normalized[curr];
+ prev[curr] = function mappedField () {
+ // if field exists
+ if (this.$validator.flags[field]) {
+ return this.$validator.flags[field];
+ }
+
+ // scopeless fields were selected.
+ if (normalized[curr] === '*') {
+ return mapScope(this.$validator.flags, false);
+ }
+
+ // if it has a scope defined
+ var index = field.indexOf('.');
+ if (index <= 0) {
+ return {};
+ }
+
+ var ref = field.split('.');
+ var scope = ref[0];
+ var name = ref.slice(1);
+
+ scope = this.$validator.flags[("$" + scope)];
+ name = name.join('.');
+
+ // an entire scope was selected: scope.*
+ if (name === '*' && scope) {
+ return mapScope(scope);
+ }
+
+ if (scope && scope[name]) {
+ return scope[name];
+ }
+
+ return {};
+ };
+
+ return prev;
+ }, {});
+};
+
+var $validator = null;
+
+function createValidationCtx (ctx) {
+ return {
+ errors: ctx.messages,
+ flags: ctx.flags,
+ classes: ctx.classes,
+ valid: ctx.isValid,
+ reset: function () { return ctx.reset(); },
+ validate: function (e) {
+ ctx.syncValue(e);
+
+ return ctx.validate().then(ctx.applyResult);
+ },
+ aria: {
+ 'aria-invalid': ctx.flags.invalid ? 'true' : 'false',
+ 'aria-required': ctx.isRequired ? 'true' : 'false'
+ }
+ };
+}
+
+function onRenderUpdate (model) {
+ var this$1 = this;
+
+ var validateNow = this.value !== model.value || this._needsValidation;
+ var shouldRevalidate = this.flags.validated;
+ if (!this.initialized) {
+ this.initialValue = model.value;
+ }
+
+ if (!this.initialized && model.value === undefined) {
+ validateNow = true;
+ }
+
+ if (validateNow) {
+ var silentHandler = function (ref) {
+ var valid = ref.valid;
+
+ // initially assign the valid/invalid flags.
+ this$1.setFlags({
+ valid: valid,
+ invalid: !valid
+ });
+ };
+
+ this.value = model.value;
+ this.validate().then(this.immediate || shouldRevalidate ? this.applyResult : silentHandler);
+ }
+
+ this._needsValidation = false;
+}
+
+// Creates the common handlers for a validatable context.
+function createCommonHandlers (ctx) {
+ var onInput = function (e) {
+ ctx.syncValue(e); // track and keep the value updated.
+ ctx.setFlags({ dirty: true, pristine: false });
+ };
+
+ // Blur event listener.
+ var onBlur = function () {
+ ctx.setFlags({ touched: true, untouched: false });
+ };
+
+ var onValidate = debounce(
+ function () {
+ var pendingPromise = ctx.validate();
+ // avoids race conditions between successive validations.
+ ctx._waiting = pendingPromise;
+ pendingPromise.then(function (result) {
+ if (pendingPromise === ctx._waiting) {
+ ctx.applyResult(result);
+ ctx._waiting = null;
+ }
+ });
+ },
+ ctx.debounce
+ );
+
+ return { onInput: onInput, onBlur: onBlur, onValidate: onValidate };
+}
+
+// Adds all plugin listeners to the vnode.
+function addListeners (node) {
+ var model = findModel(node);
+ // cache the input eventName.
+ this._inputEventName = this._inputEventName || getInputEventName(node, model);
+
+ onRenderUpdate.call(this, model);
+
+ var ref = createCommonHandlers(this);
+ var onInput = ref.onInput;
+ var onBlur = ref.onBlur;
+ var onValidate = ref.onValidate;
+ addVNodeListener(node, this._inputEventName, onInput);
+ addVNodeListener(node, 'blur', onBlur);
+
+ // add the validation listeners.
+ this.normalizedEvents.forEach(function (evt) {
+ addVNodeListener(node, evt, onValidate);
+ });
+
+ this.initialized = true;
+}
+
+function createValuesLookup (ctx) {
+ var providers = ctx.$_veeObserver.refs;
+
+ return ctx.fieldDeps.reduce(function (acc, depName) {
+ if (!providers[depName]) {
+ return acc;
+ }
+
+ acc[depName] = providers[depName].value;
+ var watcherName = "$__" + depName;
+ if (!isCallable(ctx[watcherName])) {
+ ctx[watcherName] = providers[depName].$watch('value', function () {
+ ctx.validate(ctx.value).then(ctx.applyResult);
+ ctx[watcherName]();
+ });
+ }
+
+ return acc;
+ }, {});
+}
+
+function updateRenderingContextRefs (ctx) {
+ var id = ctx.id;
+ var vid = ctx.vid;
+
+ // Nothing has changed.
+ if (id === vid && ctx.$_veeObserver.refs[id]) {
+ return;
+ }
+
+ // vid was changed.
+ if (id !== vid && ctx.$_veeObserver.refs[id] === ctx) {
+ ctx.$_veeObserver.$unsubscribe(ctx);
+ }
+
+ ctx.$_veeObserver.$subscribe(ctx);
+ ctx.id = vid;
+}
+
+function createObserver () {
+ return {
+ refs: {},
+ $subscribe: function $subscribe (ctx) {
+ this.refs[ctx.vid] = ctx;
+ },
+ $unsubscribe: function $unsubscribe (ctx) {
+ delete this.refs[ctx.vid];
+ }
+ };
+}
+
+var id$1 = 0;
+
+var ValidationProvider = {
+ $__veeInject: false,
+ inject: {
+ $_veeObserver: {
+ from: '$_veeObserver',
+ default: function default$1 () {
+ if (!this.$vnode.context.$_veeObserver) {
+ this.$vnode.context.$_veeObserver = createObserver();
+ }
+
+ return this.$vnode.context.$_veeObserver;
+ }
+ }
+ },
+ props: {
+ vid: {
+ type: [String, Number],
+ default: function () {
+ id$1++;
+ return id$1;
+ }
+ },
+ name: {
+ type: String,
+ default: null
+ },
+ events: {
+ type: [Array, String],
+ default: function () { return ['input']; }
+ },
+ rules: {
+ type: [Object, String],
+ default: null
+ },
+ immediate: {
+ type: Boolean,
+ default: false
+ },
+ bails: {
+ type: Boolean,
+ default: function () { return VeeValidate$1.config.fastExit; }
+ },
+ debounce: {
+ type: Number,
+ default: function () { return VeeValidate$1.config.delay || 0; }
+ }
+ },
+ watch: {
+ rules: {
+ deep: true,
+ handler: function handler () {
+ this._needsValidation = true;
+ }
+ }
+ },
+ data: function () { return ({
+ messages: [],
+ value: undefined,
+ initialized: false,
+ initialValue: undefined,
+ flags: createFlags(),
+ id: null
+ }); },
+ methods: {
+ setFlags: function setFlags (flags) {
+ var this$1 = this;
+
+ Object.keys(flags).forEach(function (flag) {
+ this$1.flags[flag] = flags[flag];
+ });
+ },
+ syncValue: function syncValue (e) {
+ var value = isEvent(e) ? e.target.value : e;
+
+ this.value = value;
+ this.flags.changed = this.initialValue === value;
+ },
+ reset: function reset () {
+ this.messages = [];
+ this._waiting = null;
+ this.initialValue = this.value;
+ var flags = createFlags();
+ flags.changed = false;
+ this.setFlags(flags);
+ },
+ validate: function validate () {
+ var this$1 = this;
+
+ this.setFlags({ pending: true });
+
+ return $validator.verify(this.value, this.rules, {
+ name: this.name,
+ values: createValuesLookup(this),
+ bails: this.bails
+ }).then(function (result) {
+ this$1.setFlags({ pending: false });
+
+ return result;
+ });
+ },
+ applyResult: function applyResult (ref) {
+ var errors = ref.errors;
+
+ this.messages = errors;
+ this.setFlags({
+ valid: !errors.length,
+ changed: this.value !== this.initialValue,
+ invalid: !!errors.length,
+ validated: true
+ });
+ },
+ registerField: function registerField () {
+ if (!$validator) {
+ /* istanbul ignore next */
+ if (true) {
+ if (!VeeValidate$1.instance) {
+ warn('You must install vee-validate first before using this component.');
+ }
+ }
+
+ $validator = VeeValidate$1.instance._validator;
+ }
+
+ updateRenderingContextRefs(this);
+ }
+ },
+ computed: {
+ isValid: function isValid () {
+ return this.flags.valid;
+ },
+ fieldDeps: function fieldDeps () {
+ var rules = normalizeRules(this.rules);
+
+ return Object.keys(rules).filter(RuleContainer.isTargetRule).map(function (rule) {
+ return rules[rule][0];
+ });
+ },
+ normalizedEvents: function normalizedEvents () {
+ var this$1 = this;
+
+ return normalizeEvents(this.events).map(function (e) {
+ if (e === 'input') {
+ return this$1._inputEventName;
+ }
+
+ return e;
+ });
+ },
+ isRequired: function isRequired () {
+ var rules = normalizeRules(this.rules);
+
+ return !!rules.required;
+ },
+ classes: function classes () {
+ var this$1 = this;
+
+ var names = VeeValidate$1.config.classNames;
+ return Object.keys(this.flags).reduce(function (classes, flag) {
+ var className = (names && names[flag]) || flag;
+ if (className) {
+ classes[className] = this$1.flags[flag];
+ }
+
+ return classes;
+ }, {});
+ }
+ },
+ render: function render (h) {
+ var this$1 = this;
+
+ this.registerField();
+ var ctx = createValidationCtx(this);
+
+ // Gracefully handle non-existent scoped slots.
+ var slot = this.$scopedSlots.default;
+ if (!isCallable(slot)) {
+ if (true) {
+ warn('ValidationProvider expects a scoped slot. Did you forget to add "slot-scope" to your slot?');
+ }
+
+ return createRenderless(h, this.$slots.default);
+ }
+
+ var nodes = slot(ctx);
+ // Handle single-root slot.
+ extractVNodes(nodes).forEach(function (input) {
+ addListeners.call(this$1, input);
+ });
+
+ return createRenderless(h, nodes);
+ },
+ beforeDestroy: function beforeDestroy () {
+ // cleanup reference.
+ this.$_veeObserver.$unsubscribe(this);
+ }
+};
+
+var flagMergingStrategy = {
+ pristine: 'every',
+ dirty: 'some',
+ touched: 'some',
+ untouched: 'every',
+ valid: 'every',
+ invalid: 'some',
+ pending: 'some',
+ validated: 'every'
+};
+
+function mergeFlags (lhs, rhs, strategy) {
+ var stratName = flagMergingStrategy[strategy];
+
+ return [lhs, rhs][stratName](function (f) { return f; });
+}
+
+var ValidationObserver = {
+ name: 'ValidationObserver',
+ provide: function provide () {
+ return {
+ $_veeObserver: this
+ };
+ },
+ data: function () { return ({
+ refs: {}
+ }); },
+ methods: {
+ $subscribe: function $subscribe (provider) {
+ var obj;
+
+ this.refs = Object.assign({}, this.refs, ( obj = {}, obj[provider.vid] = provider, obj ));
+ },
+ $unsubscribe: function $unsubscribe (ref) {
+ var vid = ref.vid;
+
+ delete this.refs[vid];
+ this.refs = Object.assign({}, this.refs);
+ },
+ validate: function validate () {
+ return Promise.all(values(this.refs).map(function (ref) {
+ return ref.validate().then(function (result) {
+ ref.applyResult(result);
+
+ return result;
+ });
+ })).then(function (results) { return results.every(function (r) { return r.valid; }); });
+ },
+ reset: function reset () {
+ return values(this.refs).forEach(function (ref) {
+ ref.reset();
+ });
+ }
+ },
+ computed: {
+ ctx: function ctx () {
+ var this$1 = this;
+
+ var ctx = {
+ errors: {},
+ validate: function () {
+ var promise = this$1.validate();
+
+ return {
+ then: function then (thenable) {
+ promise.then(function (success) {
+ if (success && isCallable(thenable)) {
+ return Promise.resolve(thenable());
+ }
+
+ return Promise.resolve(success);
+ });
+ }
+ };
+ },
+ reset: function () { return this$1.reset(); }
+ };
+
+ return values(this.refs).reduce(function (acc, provider) {
+ Object.keys(flagMergingStrategy).forEach(function (flag) {
+ if (!(flag in acc)) {
+ acc[flag] = provider.flags[flag];
+ return;
+ }
+
+ acc[flag] = mergeFlags(acc[flag], provider.flags[flag], flag);
+ });
+
+ acc.errors[provider.vid] = provider.messages;
+
+ return acc;
+ }, ctx);
+ }
+ },
+ render: function render (h) {
+ var slots = this.$scopedSlots.default;
+ if (!isCallable(slots)) {
+ return createRenderless(h, this.$slots.default);
+ }
+
+ return createRenderless(h, slots(this.ctx));
+ }
+};
+
+function withValidation (component, ctxToProps) {
+ if ( ctxToProps === void 0 ) ctxToProps = null;
+
+ var options = isCallable(component) ? component.options : component;
+ options.$__veeInject = false;
+ var hoc = {
+ name: ((options.name || 'AnonymousHoc') + "WithValidation"),
+ props: assign({}, ValidationProvider.props),
+ data: ValidationProvider.data,
+ computed: assign({}, ValidationProvider.computed),
+ methods: assign({}, ValidationProvider.methods),
+ $__veeInject: false,
+ beforeDestroy: ValidationProvider.beforeDestroy,
+ inject: ValidationProvider.inject
+ };
+
+ // Default ctx converts ctx props to component props.
+ if (!ctxToProps) {
+ ctxToProps = function (ctx) { return ctx; };
+ }
+
+ var eventName = (options.model && options.model.event) || 'input';
+
+ hoc.render = function (h) {
+ var obj;
+
+ this.registerField();
+ var vctx = createValidationCtx(this);
+ var listeners = assign({}, this.$listeners);
+
+ var model = findModel(this.$vnode);
+ this._inputEventName = this._inputEventName || getInputEventName(this.$vnode, model);
+ onRenderUpdate.call(this, model);
+
+ var ref = createCommonHandlers(this);
+ var onInput = ref.onInput;
+ var onBlur = ref.onBlur;
+ var onValidate = ref.onValidate;
+
+ mergeVNodeListeners(listeners, eventName, onInput);
+ mergeVNodeListeners(listeners, 'blur', onBlur);
+ this.normalizedEvents.forEach(function (evt, idx) {
+ mergeVNodeListeners(listeners, evt, onValidate);
+ });
+
+ // Props are any attrs not associated with ValidationProvider Plus the model prop.
+ // WARNING: Accidental prop overwrite will probably happen.
+ var ref$1 = findModelConfig(this.$vnode) || { prop: 'value' };
+ var prop = ref$1.prop;
+ var props = assign({}, this.$attrs, ( obj = {}, obj[prop] = model.value, obj ), ctxToProps(vctx));
+
+ return h(options, {
+ attrs: this.$attrs,
+ props: props,
+ on: listeners
+ }, normalizeSlots(this.$slots, this.$vnode.context));
+ };
+
+ return hoc;
+}
+
+//
+
+var normalizeValue = function (value) {
+ if (isObject(value)) {
+ return Object.keys(value).reduce(function (prev, key) {
+ prev[key] = normalizeValue(value[key]);
+
+ return prev;
+ }, {});
+ }
+
+ if (isCallable(value)) {
+ return value('{0}', ['{1}', '{2}', '{3}']);
+ }
+
+ return value;
+};
+
+var normalizeFormat = function (locale) {
+ // normalize messages
+ var dictionary = {};
+ if (locale.messages) {
+ dictionary.messages = normalizeValue(locale.messages);
+ }
+
+ if (locale.custom) {
+ dictionary.custom = normalizeValue(locale.custom);
+ }
+
+ if (locale.attributes) {
+ dictionary.attributes = locale.attributes;
+ }
+
+ if (!isNullOrUndefined(locale.dateFormat)) {
+ dictionary.dateFormat = locale.dateFormat;
+ }
+
+ return dictionary;
+};
+
+var I18nDictionary = function I18nDictionary (i18n, rootKey) {
+ this.i18n = i18n;
+ this.rootKey = rootKey;
+};
+
+var prototypeAccessors$5 = { locale: { configurable: true } };
+
+prototypeAccessors$5.locale.get = function () {
+ return this.i18n.locale;
+};
+
+prototypeAccessors$5.locale.set = function (value) {
+ warn('Cannot set locale from the validator when using vue-i18n, use i18n.locale setter instead');
+};
+
+I18nDictionary.prototype.getDateFormat = function getDateFormat (locale) {
+ return this.i18n.getDateTimeFormat(locale || this.locale);
+};
+
+I18nDictionary.prototype.setDateFormat = function setDateFormat (locale, value) {
+ this.i18n.setDateTimeFormat(locale || this.locale, value);
+};
+
+I18nDictionary.prototype.getMessage = function getMessage (_, key, data) {
+ var path = (this.rootKey) + ".messages." + key;
+ var result = this.i18n.t(path, data);
+ if (result !== path) {
+ return result;
+ }
+
+ return this.i18n.t(((this.rootKey) + ".messages._default"), data);
+};
+
+I18nDictionary.prototype.getAttribute = function getAttribute (_, key, fallback) {
+ if ( fallback === void 0 ) fallback = '';
+
+ var path = (this.rootKey) + ".attributes." + key;
+ var result = this.i18n.t(path);
+ if (result !== path) {
+ return result;
+ }
+
+ return fallback;
+};
+
+I18nDictionary.prototype.getFieldMessage = function getFieldMessage (_, field, key, data) {
+ var path = (this.rootKey) + ".custom." + field + "." + key;
+ var result = this.i18n.t(path, data);
+ if (result !== path) {
+ return result;
+ }
+
+ return this.getMessage(_, key, data);
+};
+
+I18nDictionary.prototype.merge = function merge$1 (dictionary) {
+ var this$1 = this;
+
+ Object.keys(dictionary).forEach(function (localeKey) {
+ var obj;
+
+ // i18n doesn't deep merge
+ // first clone the existing locale (avoid mutations to locale)
+ var clone = merge({}, getPath((localeKey + "." + (this$1.rootKey)), this$1.i18n.messages, {}));
+ // Merge cloned locale with new one
+ var locale = merge(clone, normalizeFormat(dictionary[localeKey]));
+ this$1.i18n.mergeLocaleMessage(localeKey, ( obj = {}, obj[this$1.rootKey] = locale, obj ));
+ if (locale.dateFormat) {
+ this$1.i18n.setDateTimeFormat(localeKey, locale.dateFormat);
+ }
+ });
+};
+
+I18nDictionary.prototype.setMessage = function setMessage (locale, key, value) {
+ var obj, obj$1;
+
+ this.merge(( obj$1 = {}, obj$1[locale] = {
+ messages: ( obj = {}, obj[key] = value, obj )
+ }, obj$1 ));
+};
+
+I18nDictionary.prototype.setAttribute = function setAttribute (locale, key, value) {
+ var obj, obj$1;
+
+ this.merge(( obj$1 = {}, obj$1[locale] = {
+ attributes: ( obj = {}, obj[key] = value, obj )
+ }, obj$1 ));
+};
+
+Object.defineProperties( I18nDictionary.prototype, prototypeAccessors$5 );
+
+//
+
+var defaultConfig = {
+ locale: 'en',
+ delay: 0,
+ errorBagName: 'errors',
+ dictionary: null,
+ fieldsBagName: 'fields',
+ classes: false,
+ classNames: null,
+ events: 'input',
+ inject: true,
+ fastExit: true,
+ aria: true,
+ validity: false,
+ i18n: null,
+ i18nRootKey: 'validation'
+};
+
+var Vue;
+var pendingPlugins;
+var currentConfig = assign({}, defaultConfig);
+var pluginInstance;
+
+var VeeValidate$1 = function VeeValidate (config, _Vue) {
+ this.configure(config);
+ pluginInstance = this;
+ if (_Vue) {
+ Vue = _Vue;
+ }
+ this._validator = new Validator(null, { fastExit: config && config.fastExit });
+ this._initVM(this.config);
+ this._initI18n(this.config);
+};
+
+var prototypeAccessors$6 = { i18nDriver: { configurable: true },config: { configurable: true } };
+var staticAccessors$2 = { instance: { configurable: true },i18nDriver: { configurable: true },config: { configurable: true } };
+
+VeeValidate$1.setI18nDriver = function setI18nDriver (driver, instance) {
+ DictionaryResolver.setDriver(driver, instance);
+};
+
+VeeValidate$1.configure = function configure (cfg) {
+ currentConfig = assign({}, currentConfig, cfg);
+};
+
+VeeValidate$1.use = function use (plugin, options) {
+ if ( options === void 0 ) options = {};
+
+ if (!isCallable(plugin)) {
+ return warn('The plugin must be a callable function');
+ }
+
+ // Don't install plugins until vee-validate is installed.
+ if (!pluginInstance) {
+ if (!pendingPlugins) {
+ pendingPlugins = [];
+ }
+ pendingPlugins.push({ plugin: plugin, options: options });
+ return;
+ }
+
+ plugin({ Validator: Validator, ErrorBag: ErrorBag, Rules: Validator.rules }, options);
+};
+VeeValidate$1.install = function install (_Vue, opts) {
+ if (Vue && _Vue === Vue) {
+ if (true) {
+ warn('already installed, Vue.use(VeeValidate) should only be called once.');
+ }
+ return;
+ }
+
+ Vue = _Vue;
+ pluginInstance = new VeeValidate$1(opts);
+
+ detectPassiveSupport();
+
+ Vue.mixin(mixin);
+ Vue.directive('validate', directive);
+ if (pendingPlugins) {
+ pendingPlugins.forEach(function (ref) {
+ var plugin = ref.plugin;
+ var options = ref.options;
+
+ VeeValidate$1.use(plugin, options);
+ });
+ pendingPlugins = null;
+ }
+};
+
+staticAccessors$2.instance.get = function () {
+ return pluginInstance;
+};
+
+prototypeAccessors$6.i18nDriver.get = function () {
+ return DictionaryResolver.getDriver();
+};
+
+staticAccessors$2.i18nDriver.get = function () {
+ return DictionaryResolver.getDriver();
+};
+
+prototypeAccessors$6.config.get = function () {
+ return currentConfig;
+};
+
+staticAccessors$2.config.get = function () {
+ return currentConfig;
+};
+
+VeeValidate$1.prototype._initVM = function _initVM (config) {
+ var this$1 = this;
+
+ this._vm = new Vue({
+ data: function () { return ({
+ errors: this$1._validator.errors,
+ fields: this$1._validator.fields
+ }); }
+ });
+};
+
+VeeValidate$1.prototype._initI18n = function _initI18n (config) {
+ var this$1 = this;
+
+ var dictionary = config.dictionary;
+ var i18n = config.i18n;
+ var i18nRootKey = config.i18nRootKey;
+ var locale = config.locale;
+ var onLocaleChanged = function () {
+ this$1._validator.errors.regenerate();
+ };
+
+ // i18 is being used for localization.
+ if (i18n) {
+ VeeValidate$1.setI18nDriver('i18n', new I18nDictionary(i18n, i18nRootKey));
+ i18n._vm.$watch('locale', onLocaleChanged);
+ } else if (typeof window !== 'undefined') {
+ this._vm.$on('localeChanged', onLocaleChanged);
+ }
+
+ if (dictionary) {
+ this.i18nDriver.merge(dictionary);
+ }
+
+ if (locale && !i18n) {
+ this._validator.localize(locale);
+ }
+};
+
+VeeValidate$1.prototype.configure = function configure (cfg) {
+ VeeValidate$1.configure(cfg);
+};
+
+VeeValidate$1.prototype.resolveConfig = function resolveConfig (ctx) {
+ var selfConfig = getPath('$options.$_veeValidate', ctx, {});
+
+ return assign({}, this.config, selfConfig);
+};
+
+Object.defineProperties( VeeValidate$1.prototype, prototypeAccessors$6 );
+Object.defineProperties( VeeValidate$1, staticAccessors$2 );
+
+VeeValidate$1.version = '2.1.4';
+VeeValidate$1.mixin = mixin;
+VeeValidate$1.directive = directive;
+VeeValidate$1.Validator = Validator;
+VeeValidate$1.ErrorBag = ErrorBag;
+VeeValidate$1.mapFields = mapFields;
+VeeValidate$1.ValidationProvider = ValidationProvider;
+VeeValidate$1.ValidationObserver = ValidationObserver;
+VeeValidate$1.withValidation = withValidation;
+
+/**
+ * Formates file size.
+ *
+ * @param {Number|String} size
+ */
+var formatFileSize = function (size) {
+ var units = ['Byte', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+ var threshold = 1024;
+ size = Number(size) * threshold;
+ var i = size === 0 ? 0 : Math.floor(Math.log(size) / Math.log(threshold));
+ return (((size / Math.pow(threshold, i)).toFixed(2) * 1) + " " + (units[i]));
+};
+
+/**
+ * Checks if vee-validate is defined globally.
+ */
+var isDefinedGlobally = function () {
+ return typeof VeeValidate !== 'undefined';
+};
+
+var obj;
+
+var messages = {
+ _default: function (field) { return ("The " + field + " value is not valid."); },
+ after: function (field, ref) {
+ var target = ref[0];
+ var inclusion = ref[1];
+
+ return ("The " + field + " must be after " + (inclusion ? 'or equal to ' : '') + target + ".");
+},
+ alpha: function (field) { return ("The " + field + " field may only contain alphabetic characters."); },
+ alpha_dash: function (field) { return ("The " + field + " field may contain alpha-numeric characters as well as dashes and underscores."); },
+ alpha_num: function (field) { return ("The " + field + " field may only contain alpha-numeric characters."); },
+ alpha_spaces: function (field) { return ("The " + field + " field may only contain alphabetic characters as well as spaces."); },
+ before: function (field, ref) {
+ var target = ref[0];
+ var inclusion = ref[1];
+
+ return ("The " + field + " must be before " + (inclusion ? 'or equal to ' : '') + target + ".");
+},
+ between: function (field, ref) {
+ var min = ref[0];
+ var max = ref[1];
+
+ return ("The " + field + " field must be between " + min + " and " + max + ".");
+},
+ confirmed: function (field) { return ("The " + field + " confirmation does not match."); },
+ credit_card: function (field) { return ("The " + field + " field is invalid."); },
+ date_between: function (field, ref) {
+ var min = ref[0];
+ var max = ref[1];
+
+ return ("The " + field + " must be between " + min + " and " + max + ".");
+},
+ date_format: function (field, ref) {
+ var format = ref[0];
+
+ return ("The " + field + " must be in the format " + format + ".");
+},
+ decimal: function (field, ref) {
+ if ( ref === void 0 ) ref = [];
+ var decimals = ref[0]; if ( decimals === void 0 ) decimals = '*';
+
+ return ("The " + field + " field must be numeric and may contain " + (!decimals || decimals === '*' ? '' : decimals) + " decimal points.");
+},
+ digits: function (field, ref) {
+ var length = ref[0];
+
+ return ("The " + field + " field must be numeric and exactly contain " + length + " digits.");
+},
+ dimensions: function (field, ref) {
+ var width = ref[0];
+ var height = ref[1];
+
+ return ("The " + field + " field must be " + width + " pixels by " + height + " pixels.");
+},
+ email: function (field) { return ("The " + field + " field must be a valid email."); },
+ excluded: function (field) { return ("The " + field + " field must be a valid value."); },
+ ext: function (field) { return ("The " + field + " field must be a valid file."); },
+ image: function (field) { return ("The " + field + " field must be an image."); },
+ included: function (field) { return ("The " + field + " field must be a valid value."); },
+ integer: function (field) { return ("The " + field + " field must be an integer."); },
+ ip: function (field) { return ("The " + field + " field must be a valid ip address."); },
+ length: function (field, ref) {
+ var length = ref[0];
+ var max = ref[1];
+
+ if (max) {
+ return ("The " + field + " length must be between " + length + " and " + max + ".");
+ }
+
+ return ("The " + field + " length must be " + length + ".");
+ },
+ max: function (field, ref) {
+ var length = ref[0];
+
+ return ("The " + field + " field may not be greater than " + length + " characters.");
+},
+ max_value: function (field, ref) {
+ var max = ref[0];
+
+ return ("The " + field + " field must be " + max + " or less.");
+},
+ mimes: function (field) { return ("The " + field + " field must have a valid file type."); },
+ min: function (field, ref) {
+ var length = ref[0];
+
+ return ("The " + field + " field must be at least " + length + " characters.");
+},
+ min_value: function (field, ref) {
+ var min = ref[0];
+
+ return ("The " + field + " field must be " + min + " or more.");
+},
+ numeric: function (field) { return ("The " + field + " field may only contain numeric characters."); },
+ regex: function (field) { return ("The " + field + " field format is invalid."); },
+ required: function (field) { return ("The " + field + " field is required."); },
+ size: function (field, ref) {
+ var size = ref[0];
+
+ return ("The " + field + " size must be less than " + (formatFileSize(size)) + ".");
+},
+ url: function (field) { return ("The " + field + " field is not a valid URL."); }
+};
+
+var locale = {
+ name: 'en',
+ messages: messages,
+ attributes: {}
+};
+
+if (isDefinedGlobally()) {
+ // eslint-disable-next-line
+ VeeValidate.Validator.localize(( obj = {}, obj[locale.name] = locale, obj ));
+}
+
+var MILLISECONDS_IN_HOUR = 3600000;
+var MILLISECONDS_IN_MINUTE = 60000;
+var DEFAULT_ADDITIONAL_DIGITS = 2;
+
+var patterns = {
+ dateTimeDelimeter: /[T ]/,
+ plainTime: /:/,
+
+ // year tokens
+ YY: /^(\d{2})$/,
+ YYY: [
+ /^([+-]\d{2})$/, // 0 additional digits
+ /^([+-]\d{3})$/, // 1 additional digit
+ /^([+-]\d{4})$/ // 2 additional digits
+ ],
+ YYYY: /^(\d{4})/,
+ YYYYY: [
+ /^([+-]\d{4})/, // 0 additional digits
+ /^([+-]\d{5})/, // 1 additional digit
+ /^([+-]\d{6})/ // 2 additional digits
+ ],
+
+ // date tokens
+ MM: /^-(\d{2})$/,
+ DDD: /^-?(\d{3})$/,
+ MMDD: /^-?(\d{2})-?(\d{2})$/,
+ Www: /^-?W(\d{2})$/,
+ WwwD: /^-?W(\d{2})-?(\d{1})$/,
+
+ HH: /^(\d{2}([.,]\d*)?)$/,
+ HHMM: /^(\d{2}):?(\d{2}([.,]\d*)?)$/,
+ HHMMSS: /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/,
+
+ // timezone tokens
+ timezone: /([Z+-].*)$/,
+ timezoneZ: /^(Z)$/,
+ timezoneHH: /^([+-])(\d{2})$/,
+ timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
+};
+
+/**
+ * @name toDate
+ * @category Common Helpers
+ * @summary Convert the given argument to an instance of Date.
+ *
+ * @description
+ * Convert the given argument to an instance of Date.
+ *
+ * If the argument is an instance of Date, the function returns its clone.
+ *
+ * If the argument is a number, it is treated as a timestamp.
+ *
+ * If an argument is a string, the function tries to parse it.
+ * Function accepts complete ISO 8601 formats as well as partial implementations.
+ * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+ *
+ * If the argument is null, it is treated as an invalid date.
+ *
+ * If all above fails, the function passes the given argument to Date constructor.
+ *
+ * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+ * All *date-fns* functions will throw `RangeError` if `options.additionalDigits` is not 0, 1, 2 or undefined.
+ *
+ * @param {*} argument - the value to convert
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
+ * @returns {Date} the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Convert string '2014-02-11T11:30:30' to date:
+ * var result = toDate('2014-02-11T11:30:30')
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert string '+02014101' to date,
+ * // if the additional number of digits in the extended year format is 1:
+ * var result = toDate('+02014101', {additionalDigits: 1})
+ * //=> Fri Apr 11 2014 00:00:00
+ */
+function toDate (argument, dirtyOptions) {
+ if (arguments.length < 1) {
+ throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
+ }
+
+ if (argument === null) {
+ return new Date(NaN)
+ }
+
+ var options = dirtyOptions || {};
+
+ var additionalDigits = options.additionalDigits === undefined ? DEFAULT_ADDITIONAL_DIGITS : Number(options.additionalDigits);
+ if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
+ throw new RangeError('additionalDigits must be 0, 1 or 2')
+ }
+
+ // Clone the date
+ if (argument instanceof Date) {
+ // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+ return new Date(argument.getTime())
+ } else if (typeof argument !== 'string') {
+ return new Date(argument)
+ }
+
+ var dateStrings = splitDateString(argument);
+
+ var parseYearResult = parseYear(dateStrings.date, additionalDigits);
+ var year = parseYearResult.year;
+ var restDateString = parseYearResult.restDateString;
+
+ var date = parseDate(restDateString, year);
+
+ if (date) {
+ var timestamp = date.getTime();
+ var time = 0;
+ var offset;
+
+ if (dateStrings.time) {
+ time = parseTime(dateStrings.time);
+ }
+
+ if (dateStrings.timezone) {
+ offset = parseTimezone(dateStrings.timezone);
+ } else {
+ // get offset accurate to hour in timezones that change offset
+ offset = new Date(timestamp + time).getTimezoneOffset();
+ offset = new Date(timestamp + time + offset * MILLISECONDS_IN_MINUTE).getTimezoneOffset();
+ }
+
+ return new Date(timestamp + time + offset * MILLISECONDS_IN_MINUTE)
+ } else {
+ return new Date(argument)
+ }
+}
+
+function splitDateString (dateString) {
+ var dateStrings = {};
+ var array = dateString.split(patterns.dateTimeDelimeter);
+ var timeString;
+
+ if (patterns.plainTime.test(array[0])) {
+ dateStrings.date = null;
+ timeString = array[0];
+ } else {
+ dateStrings.date = array[0];
+ timeString = array[1];
+ }
+
+ if (timeString) {
+ var token = patterns.timezone.exec(timeString);
+ if (token) {
+ dateStrings.time = timeString.replace(token[1], '');
+ dateStrings.timezone = token[1];
+ } else {
+ dateStrings.time = timeString;
+ }
+ }
+
+ return dateStrings
+}
+
+function parseYear (dateString, additionalDigits) {
+ var patternYYY = patterns.YYY[additionalDigits];
+ var patternYYYYY = patterns.YYYYY[additionalDigits];
+
+ var token;
+
+ // YYYY or ±YYYYY
+ token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
+ if (token) {
+ var yearString = token[1];
+ return {
+ year: parseInt(yearString, 10),
+ restDateString: dateString.slice(yearString.length)
+ }
+ }
+
+ // YY or ±YYY
+ token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
+ if (token) {
+ var centuryString = token[1];
+ return {
+ year: parseInt(centuryString, 10) * 100,
+ restDateString: dateString.slice(centuryString.length)
+ }
+ }
+
+ // Invalid ISO-formatted year
+ return {
+ year: null
+ }
+}
+
+function parseDate (dateString, year) {
+ // Invalid ISO-formatted year
+ if (year === null) {
+ return null
+ }
+
+ var token;
+ var date;
+ var month;
+ var week;
+
+ // YYYY
+ if (dateString.length === 0) {
+ date = new Date(0);
+ date.setUTCFullYear(year);
+ return date
+ }
+
+ // YYYY-MM
+ token = patterns.MM.exec(dateString);
+ if (token) {
+ date = new Date(0);
+ month = parseInt(token[1], 10) - 1;
+ date.setUTCFullYear(year, month);
+ return date
+ }
+
+ // YYYY-DDD or YYYYDDD
+ token = patterns.DDD.exec(dateString);
+ if (token) {
+ date = new Date(0);
+ var dayOfYear = parseInt(token[1], 10);
+ date.setUTCFullYear(year, 0, dayOfYear);
+ return date
+ }
+
+ // YYYY-MM-DD or YYYYMMDD
+ token = patterns.MMDD.exec(dateString);
+ if (token) {
+ date = new Date(0);
+ month = parseInt(token[1], 10) - 1;
+ var day = parseInt(token[2], 10);
+ date.setUTCFullYear(year, month, day);
+ return date
+ }
+
+ // YYYY-Www or YYYYWww
+ token = patterns.Www.exec(dateString);
+ if (token) {
+ week = parseInt(token[1], 10) - 1;
+ return dayOfISOYear(year, week)
+ }
+
+ // YYYY-Www-D or YYYYWwwD
+ token = patterns.WwwD.exec(dateString);
+ if (token) {
+ week = parseInt(token[1], 10) - 1;
+ var dayOfWeek = parseInt(token[2], 10) - 1;
+ return dayOfISOYear(year, week, dayOfWeek)
+ }
+
+ // Invalid ISO-formatted date
+ return null
+}
+
+function parseTime (timeString) {
+ var token;
+ var hours;
+ var minutes;
+
+ // hh
+ token = patterns.HH.exec(timeString);
+ if (token) {
+ hours = parseFloat(token[1].replace(',', '.'));
+ return (hours % 24) * MILLISECONDS_IN_HOUR
+ }
+
+ // hh:mm or hhmm
+ token = patterns.HHMM.exec(timeString);
+ if (token) {
+ hours = parseInt(token[1], 10);
+ minutes = parseFloat(token[2].replace(',', '.'));
+ return (hours % 24) * MILLISECONDS_IN_HOUR +
+ minutes * MILLISECONDS_IN_MINUTE
+ }
+
+ // hh:mm:ss or hhmmss
+ token = patterns.HHMMSS.exec(timeString);
+ if (token) {
+ hours = parseInt(token[1], 10);
+ minutes = parseInt(token[2], 10);
+ var seconds = parseFloat(token[3].replace(',', '.'));
+ return (hours % 24) * MILLISECONDS_IN_HOUR +
+ minutes * MILLISECONDS_IN_MINUTE +
+ seconds * 1000
+ }
+
+ // Invalid ISO-formatted time
+ return null
+}
+
+function parseTimezone (timezoneString) {
+ var token;
+ var absoluteOffset;
+
+ // Z
+ token = patterns.timezoneZ.exec(timezoneString);
+ if (token) {
+ return 0
+ }
+
+ // ±hh
+ token = patterns.timezoneHH.exec(timezoneString);
+ if (token) {
+ absoluteOffset = parseInt(token[2], 10) * 60;
+ return (token[1] === '+') ? -absoluteOffset : absoluteOffset
+ }
+
+ // ±hh:mm or ±hhmm
+ token = patterns.timezoneHHMM.exec(timezoneString);
+ if (token) {
+ absoluteOffset = parseInt(token[2], 10) * 60 + parseInt(token[3], 10);
+ return (token[1] === '+') ? -absoluteOffset : absoluteOffset
+ }
+
+ return 0
+}
+
+function dayOfISOYear (isoYear, week, day) {
+ week = week || 0;
+ day = day || 0;
+ var date = new Date(0);
+ date.setUTCFullYear(isoYear, 0, 4);
+ var fourthOfJanuaryDay = date.getUTCDay() || 7;
+ var diff = week * 7 + day + 1 - fourthOfJanuaryDay;
+ date.setUTCDate(date.getUTCDate() + diff);
+ return date
+}
+
+/**
+ * @name addMilliseconds
+ * @category Millisecond Helpers
+ * @summary Add the specified number of milliseconds to the given date.
+ *
+ * @description
+ * Add the specified number of milliseconds to the given date.
+ *
+ * @param {Date|String|Number} date - the date to be changed
+ * @param {Number} amount - the amount of milliseconds to be added
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Date} the new date with the milliseconds added
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+ * var result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:30.750
+ */
+function addMilliseconds (dirtyDate, dirtyAmount, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var timestamp = toDate(dirtyDate, dirtyOptions).getTime();
+ var amount = Number(dirtyAmount);
+ return new Date(timestamp + amount)
+}
+
+function cloneObject (dirtyObject) {
+ dirtyObject = dirtyObject || {};
+ var object = {};
+
+ for (var property in dirtyObject) {
+ if (dirtyObject.hasOwnProperty(property)) {
+ object[property] = dirtyObject[property];
+ }
+ }
+
+ return object
+}
+
+var MILLISECONDS_IN_MINUTE$2 = 60000;
+
+/**
+ * @name addMinutes
+ * @category Minute Helpers
+ * @summary Add the specified number of minutes to the given date.
+ *
+ * @description
+ * Add the specified number of minutes to the given date.
+ *
+ * @param {Date|String|Number} date - the date to be changed
+ * @param {Number} amount - the amount of minutes to be added
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Date} the new date with the minutes added
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Add 30 minutes to 10 July 2014 12:00:00:
+ * var result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 12:30:00
+ */
+function addMinutes (dirtyDate, dirtyAmount, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var amount = Number(dirtyAmount);
+ return addMilliseconds(dirtyDate, amount * MILLISECONDS_IN_MINUTE$2, dirtyOptions)
+}
+
+/**
+ * @name isValid
+ * @category Common Helpers
+ * @summary Is the given date valid?
+ *
+ * @description
+ * Returns false if argument is Invalid Date and true otherwise.
+ * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * Invalid Date is a Date, whose time value is NaN.
+ *
+ * Time value of Date: http://es5.github.io/#x15.9.1.1
+ *
+ * @param {*} date - the date to check
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Boolean} the date is valid
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // For the valid date:
+ * var result = isValid(new Date(2014, 1, 31))
+ * //=> true
+ *
+ * @example
+ * // For the value, convertable into a date:
+ * var result = isValid('2014-02-31')
+ * //=> true
+ *
+ * @example
+ * // For the invalid date:
+ * var result = isValid(new Date(''))
+ * //=> false
+ */
+function isValid (dirtyDate, dirtyOptions) {
+ if (arguments.length < 1) {
+ throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
+ }
+
+ var date = toDate(dirtyDate, dirtyOptions);
+ return !isNaN(date)
+}
+
+var formatDistanceLocale = {
+ lessThanXSeconds: {
+ one: 'less than a second',
+ other: 'less than {{count}} seconds'
+ },
+
+ xSeconds: {
+ one: '1 second',
+ other: '{{count}} seconds'
+ },
+
+ halfAMinute: 'half a minute',
+
+ lessThanXMinutes: {
+ one: 'less than a minute',
+ other: 'less than {{count}} minutes'
+ },
+
+ xMinutes: {
+ one: '1 minute',
+ other: '{{count}} minutes'
+ },
+
+ aboutXHours: {
+ one: 'about 1 hour',
+ other: 'about {{count}} hours'
+ },
+
+ xHours: {
+ one: '1 hour',
+ other: '{{count}} hours'
+ },
+
+ xDays: {
+ one: '1 day',
+ other: '{{count}} days'
+ },
+
+ aboutXMonths: {
+ one: 'about 1 month',
+ other: 'about {{count}} months'
+ },
+
+ xMonths: {
+ one: '1 month',
+ other: '{{count}} months'
+ },
+
+ aboutXYears: {
+ one: 'about 1 year',
+ other: 'about {{count}} years'
+ },
+
+ xYears: {
+ one: '1 year',
+ other: '{{count}} years'
+ },
+
+ overXYears: {
+ one: 'over 1 year',
+ other: 'over {{count}} years'
+ },
+
+ almostXYears: {
+ one: 'almost 1 year',
+ other: 'almost {{count}} years'
+ }
+};
+
+function formatDistance (token, count, options) {
+ options = options || {};
+
+ var result;
+ if (typeof formatDistanceLocale[token] === 'string') {
+ result = formatDistanceLocale[token];
+ } else if (count === 1) {
+ result = formatDistanceLocale[token].one;
+ } else {
+ result = formatDistanceLocale[token].other.replace('{{count}}', count);
+ }
+
+ if (options.addSuffix) {
+ if (options.comparison > 0) {
+ return 'in ' + result
+ } else {
+ return result + ' ago'
+ }
+ }
+
+ return result
+}
+
+var tokensToBeShortedPattern = /MMMM|MM|DD|dddd/g;
+
+function buildShortLongFormat (format) {
+ return format.replace(tokensToBeShortedPattern, function (token) {
+ return token.slice(1)
+ })
+}
+
+/**
+ * @name buildFormatLongFn
+ * @category Locale Helpers
+ * @summary Build `formatLong` property for locale used by `format`, `formatRelative` and `parse` functions.
+ *
+ * @description
+ * Build `formatLong` property for locale used by `format`, `formatRelative` and `parse` functions.
+ * Returns a function which takes one of the following tokens as the argument:
+ * `'LTS'`, `'LT'`, `'L'`, `'LL'`, `'LLL'`, `'l'`, `'ll'`, `'lll'`, `'llll'`
+ * and returns a long format string written as `format` token strings.
+ * See [format]{@link https://date-fns.org/docs/format}
+ *
+ * `'l'`, `'ll'`, `'lll'` and `'llll'` formats are built automatically
+ * by shortening some of the tokens from corresponding unshortened formats
+ * (e.g., if `LL` is `'MMMM DD YYYY'` then `ll` will be `MMM D YYYY`)
+ *
+ * @param {Object} obj - the object with long formats written as `format` token strings
+ * @param {String} obj.LT - time format: hours and minutes
+ * @param {String} obj.LTS - time format: hours, minutes and seconds
+ * @param {String} obj.L - short date format: numeric day, month and year
+ * @param {String} [obj.l] - short date format: numeric day, month and year (shortened)
+ * @param {String} obj.LL - long date format: day, month in words, and year
+ * @param {String} [obj.ll] - long date format: day, month in words, and year (shortened)
+ * @param {String} obj.LLL - long date and time format
+ * @param {String} [obj.lll] - long date and time format (shortened)
+ * @param {String} obj.LLLL - long date, time and weekday format
+ * @param {String} [obj.llll] - long date, time and weekday format (shortened)
+ * @returns {Function} `formatLong` property of the locale
+ *
+ * @example
+ * // For `en-US` locale:
+ * locale.formatLong = buildFormatLongFn({
+ * LT: 'h:mm aa',
+ * LTS: 'h:mm:ss aa',
+ * L: 'MM/DD/YYYY',
+ * LL: 'MMMM D YYYY',
+ * LLL: 'MMMM D YYYY h:mm aa',
+ * LLLL: 'dddd, MMMM D YYYY h:mm aa'
+ * })
+ */
+function buildFormatLongFn (obj) {
+ var formatLongLocale = {
+ LTS: obj.LTS,
+ LT: obj.LT,
+ L: obj.L,
+ LL: obj.LL,
+ LLL: obj.LLL,
+ LLLL: obj.LLLL,
+ l: obj.l || buildShortLongFormat(obj.L),
+ ll: obj.ll || buildShortLongFormat(obj.LL),
+ lll: obj.lll || buildShortLongFormat(obj.LLL),
+ llll: obj.llll || buildShortLongFormat(obj.LLLL)
+ };
+
+ return function (token) {
+ return formatLongLocale[token]
+ }
+}
+
+var formatLong = buildFormatLongFn({
+ LT: 'h:mm aa',
+ LTS: 'h:mm:ss aa',
+ L: 'MM/DD/YYYY',
+ LL: 'MMMM D YYYY',
+ LLL: 'MMMM D YYYY h:mm aa',
+ LLLL: 'dddd, MMMM D YYYY h:mm aa'
+});
+
+var formatRelativeLocale = {
+ lastWeek: '[last] dddd [at] LT',
+ yesterday: '[yesterday at] LT',
+ today: '[today at] LT',
+ tomorrow: '[tomorrow at] LT',
+ nextWeek: 'dddd [at] LT',
+ other: 'L'
+};
+
+function formatRelative (token, date, baseDate, options) {
+ return formatRelativeLocale[token]
+}
+
+/**
+ * @name buildLocalizeFn
+ * @category Locale Helpers
+ * @summary Build `localize.weekday`, `localize.month` and `localize.timeOfDay` properties for the locale.
+ *
+ * @description
+ * Build `localize.weekday`, `localize.month` and `localize.timeOfDay` properties for the locale
+ * used by `format` function.
+ * If no `type` is supplied to the options of the resulting function, `defaultType` will be used (see example).
+ *
+ * `localize.weekday` function takes the weekday index as argument (0 - Sunday).
+ * `localize.month` takes the month index (0 - January).
+ * `localize.timeOfDay` takes the hours. Use `indexCallback` to convert them to an array index (see example).
+ *
+ * @param {Object} values - the object with arrays of values
+ * @param {String} defaultType - the default type for the localize function
+ * @param {Function} [indexCallback] - the callback which takes the resulting function argument
+ * and converts it into value array index
+ * @returns {Function} the resulting function
+ *
+ * @example
+ * var timeOfDayValues = {
+ * uppercase: ['AM', 'PM'],
+ * lowercase: ['am', 'pm'],
+ * long: ['a.m.', 'p.m.']
+ * }
+ * locale.localize.timeOfDay = buildLocalizeFn(timeOfDayValues, 'long', function (hours) {
+ * // 0 is a.m. array index, 1 is p.m. array index
+ * return (hours / 12) >= 1 ? 1 : 0
+ * })
+ * locale.localize.timeOfDay(16, {type: 'uppercase'}) //=> 'PM'
+ * locale.localize.timeOfDay(5) //=> 'a.m.'
+ */
+function buildLocalizeFn (values, defaultType, indexCallback) {
+ return function (dirtyIndex, dirtyOptions) {
+ var options = dirtyOptions || {};
+ var type = options.type ? String(options.type) : defaultType;
+ var valuesArray = values[type] || values[defaultType];
+ var index = indexCallback ? indexCallback(Number(dirtyIndex)) : Number(dirtyIndex);
+ return valuesArray[index]
+ }
+}
+
+/**
+ * @name buildLocalizeArrayFn
+ * @category Locale Helpers
+ * @summary Build `localize.weekdays`, `localize.months` and `localize.timesOfDay` properties for the locale.
+ *
+ * @description
+ * Build `localize.weekdays`, `localize.months` and `localize.timesOfDay` properties for the locale.
+ * If no `type` is supplied to the options of the resulting function, `defaultType` will be used (see example).
+ *
+ * @param {Object} values - the object with arrays of values
+ * @param {String} defaultType - the default type for the localize function
+ * @returns {Function} the resulting function
+ *
+ * @example
+ * var weekdayValues = {
+ * narrow: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+ * short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+ * long: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+ * }
+ * locale.localize.weekdays = buildLocalizeArrayFn(weekdayValues, 'long')
+ * locale.localize.weekdays({type: 'narrow'}) //=> ['Su', 'Mo', ...]
+ * locale.localize.weekdays() //=> ['Sunday', 'Monday', ...]
+ */
+function buildLocalizeArrayFn (values, defaultType) {
+ return function (dirtyOptions) {
+ var options = dirtyOptions || {};
+ var type = options.type ? String(options.type) : defaultType;
+ return values[type] || values[defaultType]
+ }
+}
+
+// Note: in English, the names of days of the week and months are capitalized.
+// If you are making a new locale based on this one, check if the same is true for the language you're working on.
+// Generally, formatted dates should look like they are in the middle of a sentence,
+// e.g. in Spanish language the weekdays and months should be in the lowercase.
+var weekdayValues = {
+ narrow: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+ short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+ long: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+};
+
+var monthValues = {
+ short: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+ long: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+};
+
+// `timeOfDay` is used to designate which part of the day it is, when used with 12-hour clock.
+// Use the system which is used the most commonly in the locale.
+// For example, if the country doesn't use a.m./p.m., you can use `night`/`morning`/`afternoon`/`evening`:
+//
+// var timeOfDayValues = {
+// any: ['in the night', 'in the morning', 'in the afternoon', 'in the evening']
+// }
+//
+// And later:
+//
+// var localize = {
+// // The callback takes the hours as the argument and returns the array index
+// timeOfDay: buildLocalizeFn(timeOfDayValues, 'any', function (hours) {
+// if (hours >= 17) {
+// return 3
+// } else if (hours >= 12) {
+// return 2
+// } else if (hours >= 4) {
+// return 1
+// } else {
+// return 0
+// }
+// }),
+// timesOfDay: buildLocalizeArrayFn(timeOfDayValues, 'any')
+// }
+var timeOfDayValues = {
+ uppercase: ['AM', 'PM'],
+ lowercase: ['am', 'pm'],
+ long: ['a.m.', 'p.m.']
+};
+
+function ordinalNumber (dirtyNumber, dirtyOptions) {
+ var number = Number(dirtyNumber);
+
+ // If ordinal numbers depend on context, for example,
+ // if they are different for different grammatical genders,
+ // use `options.unit`:
+ //
+ // var options = dirtyOptions || {}
+ // var unit = String(options.unit)
+ //
+ // where `unit` can be 'month', 'quarter', 'week', 'isoWeek', 'dayOfYear',
+ // 'dayOfMonth' or 'dayOfWeek'
+
+ var rem100 = number % 100;
+ if (rem100 > 20 || rem100 < 10) {
+ switch (rem100 % 10) {
+ case 1:
+ return number + 'st'
+ case 2:
+ return number + 'nd'
+ case 3:
+ return number + 'rd'
+ }
+ }
+ return number + 'th'
+}
+
+var localize = {
+ ordinalNumber: ordinalNumber,
+ weekday: buildLocalizeFn(weekdayValues, 'long'),
+ weekdays: buildLocalizeArrayFn(weekdayValues, 'long'),
+ month: buildLocalizeFn(monthValues, 'long'),
+ months: buildLocalizeArrayFn(monthValues, 'long'),
+ timeOfDay: buildLocalizeFn(timeOfDayValues, 'long', function (hours) {
+ return (hours / 12) >= 1 ? 1 : 0
+ }),
+ timesOfDay: buildLocalizeArrayFn(timeOfDayValues, 'long')
+};
+
+/**
+ * @name buildMatchFn
+ * @category Locale Helpers
+ * @summary Build `match.weekdays`, `match.months` and `match.timesOfDay` properties for the locale.
+ *
+ * @description
+ * Build `match.weekdays`, `match.months` and `match.timesOfDay` properties for the locale used by `parse` function.
+ * If no `type` is supplied to the options of the resulting function, `defaultType` will be used (see example).
+ * The result of the match function will be passed into corresponding parser function
+ * (`match.weekday`, `match.month` or `match.timeOfDay` respectively. See `buildParseFn`).
+ *
+ * @param {Object} values - the object with RegExps
+ * @param {String} defaultType - the default type for the match function
+ * @returns {Function} the resulting function
+ *
+ * @example
+ * var matchWeekdaysPatterns = {
+ * narrow: /^(su|mo|tu|we|th|fr|sa)/i,
+ * short: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+ * long: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+ * }
+ * locale.match.weekdays = buildMatchFn(matchWeekdaysPatterns, 'long')
+ * locale.match.weekdays('Sunday', {type: 'narrow'}) //=> ['Su', 'Su', ...]
+ * locale.match.weekdays('Sunday') //=> ['Sunday', 'Sunday', ...]
+ */
+function buildMatchFn (patterns, defaultType) {
+ return function (dirtyString, dirtyOptions) {
+ var options = dirtyOptions || {};
+ var type = options.type ? String(options.type) : defaultType;
+ var pattern = patterns[type] || patterns[defaultType];
+ var string = String(dirtyString);
+ return string.match(pattern)
+ }
+}
+
+/**
+ * @name buildParseFn
+ * @category Locale Helpers
+ * @summary Build `match.weekday`, `match.month` and `match.timeOfDay` properties for the locale.
+ *
+ * @description
+ * Build `match.weekday`, `match.month` and `match.timeOfDay` properties for the locale used by `parse` function.
+ * The argument of the resulting function is the result of the corresponding match function
+ * (`match.weekdays`, `match.months` or `match.timesOfDay` respectively. See `buildMatchFn`).
+ *
+ * @param {Object} values - the object with arrays of RegExps
+ * @param {String} defaultType - the default type for the parser function
+ * @returns {Function} the resulting function
+ *
+ * @example
+ * var parseWeekdayPatterns = {
+ * any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+ * }
+ * locale.match.weekday = buildParseFn(matchWeekdaysPatterns, 'long')
+ * var matchResult = locale.match.weekdays('Friday')
+ * locale.match.weekday(matchResult) //=> 5
+ */
+function buildParseFn (patterns, defaultType) {
+ return function (matchResult, dirtyOptions) {
+ var options = dirtyOptions || {};
+ var type = options.type ? String(options.type) : defaultType;
+ var patternsArray = patterns[type] || patterns[defaultType];
+ var string = matchResult[1];
+
+ return patternsArray.findIndex(function (pattern) {
+ return pattern.test(string)
+ })
+ }
+}
+
+/**
+ * @name buildMatchPatternFn
+ * @category Locale Helpers
+ * @summary Build match function from a single RegExp.
+ *
+ * @description
+ * Build match function from a single RegExp.
+ * Usually used for building `match.ordinalNumbers` property of the locale.
+ *
+ * @param {Object} pattern - the RegExp
+ * @returns {Function} the resulting function
+ *
+ * @example
+ * locale.match.ordinalNumbers = buildMatchPatternFn(/^(\d+)(th|st|nd|rd)?/i)
+ * locale.match.ordinalNumbers('3rd') //=> ['3rd', '3', 'rd', ...]
+ */
+function buildMatchPatternFn (pattern) {
+ return function (dirtyString) {
+ var string = String(dirtyString);
+ return string.match(pattern)
+ }
+}
+
+/**
+ * @name parseDecimal
+ * @category Locale Helpers
+ * @summary Parses the match result into decimal number.
+ *
+ * @description
+ * Parses the match result into decimal number.
+ * Uses the string matched with the first set of parentheses of match RegExp.
+ *
+ * @param {Array} matchResult - the object returned by matching function
+ * @returns {Number} the parsed value
+ *
+ * @example
+ * locale.match = {
+ * ordinalNumbers: (dirtyString) {
+ * return String(dirtyString).match(/^(\d+)(th|st|nd|rd)?/i)
+ * },
+ * ordinalNumber: parseDecimal
+ * }
+ */
+function parseDecimal (matchResult) {
+ return parseInt(matchResult[1], 10)
+}
+
+var matchOrdinalNumbersPattern = /^(\d+)(th|st|nd|rd)?/i;
+
+var matchWeekdaysPatterns = {
+ narrow: /^(su|mo|tu|we|th|fr|sa)/i,
+ short: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+ long: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+};
+
+var parseWeekdayPatterns = {
+ any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+};
+
+var matchMonthsPatterns = {
+ short: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+ long: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+};
+
+var parseMonthPatterns = {
+ any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
+};
+
+// `timeOfDay` is used to designate which part of the day it is, when used with 12-hour clock.
+// Use the system which is used the most commonly in the locale.
+// For example, if the country doesn't use a.m./p.m., you can use `night`/`morning`/`afternoon`/`evening`:
+//
+// var matchTimesOfDayPatterns = {
+// long: /^((in the)? (night|morning|afternoon|evening?))/i
+// }
+//
+// var parseTimeOfDayPatterns = {
+// any: [/(night|morning)/i, /(afternoon|evening)/i]
+// }
+var matchTimesOfDayPatterns = {
+ short: /^(am|pm)/i,
+ long: /^([ap]\.?\s?m\.?)/i
+};
+
+var parseTimeOfDayPatterns = {
+ any: [/^a/i, /^p/i]
+};
+
+var match = {
+ ordinalNumbers: buildMatchPatternFn(matchOrdinalNumbersPattern),
+ ordinalNumber: parseDecimal,
+ weekdays: buildMatchFn(matchWeekdaysPatterns, 'long'),
+ weekday: buildParseFn(parseWeekdayPatterns, 'any'),
+ months: buildMatchFn(matchMonthsPatterns, 'long'),
+ month: buildParseFn(parseMonthPatterns, 'any'),
+ timesOfDay: buildMatchFn(matchTimesOfDayPatterns, 'long'),
+ timeOfDay: buildParseFn(parseTimeOfDayPatterns, 'any')
+};
+
+/**
+ * @type {Locale}
+ * @category Locales
+ * @summary English locale (United States).
+ * @language English
+ * @iso-639-2 eng
+ */
+var locale$1 = {
+ formatDistance: formatDistance,
+ formatLong: formatLong,
+ formatRelative: formatRelative,
+ localize: localize,
+ match: match,
+ options: {
+ weekStartsOn: 0 /* Sunday */,
+ firstWeekContainsDate: 1
+ }
+};
+
+var MILLISECONDS_IN_DAY$1 = 86400000;
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function getUTCDayOfYear (dirtyDate, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var timestamp = date.getTime();
+ date.setUTCMonth(0, 1);
+ date.setUTCHours(0, 0, 0, 0);
+ var startOfYearTimestamp = date.getTime();
+ var difference = timestamp - startOfYearTimestamp;
+ return Math.floor(difference / MILLISECONDS_IN_DAY$1) + 1
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function startOfUTCISOWeek (dirtyDate, dirtyOptions) {
+ var weekStartsOn = 1;
+
+ var date = toDate(dirtyDate, dirtyOptions);
+ var day = date.getUTCDay();
+ var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+
+ date.setUTCDate(date.getUTCDate() - diff);
+ date.setUTCHours(0, 0, 0, 0);
+ return date
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function getUTCISOWeekYear (dirtyDate, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var year = date.getUTCFullYear();
+
+ var fourthOfJanuaryOfNextYear = new Date(0);
+ fourthOfJanuaryOfNextYear.setUTCFullYear(year + 1, 0, 4);
+ fourthOfJanuaryOfNextYear.setUTCHours(0, 0, 0, 0);
+ var startOfNextYear = startOfUTCISOWeek(fourthOfJanuaryOfNextYear, dirtyOptions);
+
+ var fourthOfJanuaryOfThisYear = new Date(0);
+ fourthOfJanuaryOfThisYear.setUTCFullYear(year, 0, 4);
+ fourthOfJanuaryOfThisYear.setUTCHours(0, 0, 0, 0);
+ var startOfThisYear = startOfUTCISOWeek(fourthOfJanuaryOfThisYear, dirtyOptions);
+
+ if (date.getTime() >= startOfNextYear.getTime()) {
+ return year + 1
+ } else if (date.getTime() >= startOfThisYear.getTime()) {
+ return year
+ } else {
+ return year - 1
+ }
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function startOfUTCISOWeekYear (dirtyDate, dirtyOptions) {
+ var year = getUTCISOWeekYear(dirtyDate, dirtyOptions);
+ var fourthOfJanuary = new Date(0);
+ fourthOfJanuary.setUTCFullYear(year, 0, 4);
+ fourthOfJanuary.setUTCHours(0, 0, 0, 0);
+ var date = startOfUTCISOWeek(fourthOfJanuary, dirtyOptions);
+ return date
+}
+
+var MILLISECONDS_IN_WEEK$2 = 604800000;
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function getUTCISOWeek (dirtyDate, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var diff = startOfUTCISOWeek(date, dirtyOptions).getTime() - startOfUTCISOWeekYear(date, dirtyOptions).getTime();
+
+ // Round the number of days to the nearest integer
+ // because the number of milliseconds in a week is not constant
+ // (e.g. it's different in the week of the daylight saving time clock shift)
+ return Math.round(diff / MILLISECONDS_IN_WEEK$2) + 1
+}
+
+var formatters = {
+ // Month: 1, 2, ..., 12
+ 'M': function (date) {
+ return date.getUTCMonth() + 1
+ },
+
+ // Month: 1st, 2nd, ..., 12th
+ 'Mo': function (date, options) {
+ var month = date.getUTCMonth() + 1;
+ return options.locale.localize.ordinalNumber(month, {unit: 'month'})
+ },
+
+ // Month: 01, 02, ..., 12
+ 'MM': function (date) {
+ return addLeadingZeros(date.getUTCMonth() + 1, 2)
+ },
+
+ // Month: Jan, Feb, ..., Dec
+ 'MMM': function (date, options) {
+ return options.locale.localize.month(date.getUTCMonth(), {type: 'short'})
+ },
+
+ // Month: January, February, ..., December
+ 'MMMM': function (date, options) {
+ return options.locale.localize.month(date.getUTCMonth(), {type: 'long'})
+ },
+
+ // Quarter: 1, 2, 3, 4
+ 'Q': function (date) {
+ return Math.ceil((date.getUTCMonth() + 1) / 3)
+ },
+
+ // Quarter: 1st, 2nd, 3rd, 4th
+ 'Qo': function (date, options) {
+ var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+ return options.locale.localize.ordinalNumber(quarter, {unit: 'quarter'})
+ },
+
+ // Day of month: 1, 2, ..., 31
+ 'D': function (date) {
+ return date.getUTCDate()
+ },
+
+ // Day of month: 1st, 2nd, ..., 31st
+ 'Do': function (date, options) {
+ return options.locale.localize.ordinalNumber(date.getUTCDate(), {unit: 'dayOfMonth'})
+ },
+
+ // Day of month: 01, 02, ..., 31
+ 'DD': function (date) {
+ return addLeadingZeros(date.getUTCDate(), 2)
+ },
+
+ // Day of year: 1, 2, ..., 366
+ 'DDD': function (date) {
+ return getUTCDayOfYear(date)
+ },
+
+ // Day of year: 1st, 2nd, ..., 366th
+ 'DDDo': function (date, options) {
+ return options.locale.localize.ordinalNumber(getUTCDayOfYear(date), {unit: 'dayOfYear'})
+ },
+
+ // Day of year: 001, 002, ..., 366
+ 'DDDD': function (date) {
+ return addLeadingZeros(getUTCDayOfYear(date), 3)
+ },
+
+ // Day of week: Su, Mo, ..., Sa
+ 'dd': function (date, options) {
+ return options.locale.localize.weekday(date.getUTCDay(), {type: 'narrow'})
+ },
+
+ // Day of week: Sun, Mon, ..., Sat
+ 'ddd': function (date, options) {
+ return options.locale.localize.weekday(date.getUTCDay(), {type: 'short'})
+ },
+
+ // Day of week: Sunday, Monday, ..., Saturday
+ 'dddd': function (date, options) {
+ return options.locale.localize.weekday(date.getUTCDay(), {type: 'long'})
+ },
+
+ // Day of week: 0, 1, ..., 6
+ 'd': function (date) {
+ return date.getUTCDay()
+ },
+
+ // Day of week: 0th, 1st, 2nd, ..., 6th
+ 'do': function (date, options) {
+ return options.locale.localize.ordinalNumber(date.getUTCDay(), {unit: 'dayOfWeek'})
+ },
+
+ // Day of ISO week: 1, 2, ..., 7
+ 'E': function (date) {
+ return date.getUTCDay() || 7
+ },
+
+ // ISO week: 1, 2, ..., 53
+ 'W': function (date) {
+ return getUTCISOWeek(date)
+ },
+
+ // ISO week: 1st, 2nd, ..., 53th
+ 'Wo': function (date, options) {
+ return options.locale.localize.ordinalNumber(getUTCISOWeek(date), {unit: 'isoWeek'})
+ },
+
+ // ISO week: 01, 02, ..., 53
+ 'WW': function (date) {
+ return addLeadingZeros(getUTCISOWeek(date), 2)
+ },
+
+ // Year: 00, 01, ..., 99
+ 'YY': function (date) {
+ return addLeadingZeros(date.getUTCFullYear(), 4).substr(2)
+ },
+
+ // Year: 1900, 1901, ..., 2099
+ 'YYYY': function (date) {
+ return addLeadingZeros(date.getUTCFullYear(), 4)
+ },
+
+ // ISO week-numbering year: 00, 01, ..., 99
+ 'GG': function (date) {
+ return String(getUTCISOWeekYear(date)).substr(2)
+ },
+
+ // ISO week-numbering year: 1900, 1901, ..., 2099
+ 'GGGG': function (date) {
+ return getUTCISOWeekYear(date)
+ },
+
+ // Hour: 0, 1, ... 23
+ 'H': function (date) {
+ return date.getUTCHours()
+ },
+
+ // Hour: 00, 01, ..., 23
+ 'HH': function (date) {
+ return addLeadingZeros(date.getUTCHours(), 2)
+ },
+
+ // Hour: 1, 2, ..., 12
+ 'h': function (date) {
+ var hours = date.getUTCHours();
+ if (hours === 0) {
+ return 12
+ } else if (hours > 12) {
+ return hours % 12
+ } else {
+ return hours
+ }
+ },
+
+ // Hour: 01, 02, ..., 12
+ 'hh': function (date) {
+ return addLeadingZeros(formatters['h'](date), 2)
+ },
+
+ // Minute: 0, 1, ..., 59
+ 'm': function (date) {
+ return date.getUTCMinutes()
+ },
+
+ // Minute: 00, 01, ..., 59
+ 'mm': function (date) {
+ return addLeadingZeros(date.getUTCMinutes(), 2)
+ },
+
+ // Second: 0, 1, ..., 59
+ 's': function (date) {
+ return date.getUTCSeconds()
+ },
+
+ // Second: 00, 01, ..., 59
+ 'ss': function (date) {
+ return addLeadingZeros(date.getUTCSeconds(), 2)
+ },
+
+ // 1/10 of second: 0, 1, ..., 9
+ 'S': function (date) {
+ return Math.floor(date.getUTCMilliseconds() / 100)
+ },
+
+ // 1/100 of second: 00, 01, ..., 99
+ 'SS': function (date) {
+ return addLeadingZeros(Math.floor(date.getUTCMilliseconds() / 10), 2)
+ },
+
+ // Millisecond: 000, 001, ..., 999
+ 'SSS': function (date) {
+ return addLeadingZeros(date.getUTCMilliseconds(), 3)
+ },
+
+ // Timezone: -01:00, +00:00, ... +12:00
+ 'Z': function (date, options) {
+ var originalDate = options._originalDate || date;
+ return formatTimezone(originalDate.getTimezoneOffset(), ':')
+ },
+
+ // Timezone: -0100, +0000, ... +1200
+ 'ZZ': function (date, options) {
+ var originalDate = options._originalDate || date;
+ return formatTimezone(originalDate.getTimezoneOffset())
+ },
+
+ // Seconds timestamp: 512969520
+ 'X': function (date, options) {
+ var originalDate = options._originalDate || date;
+ return Math.floor(originalDate.getTime() / 1000)
+ },
+
+ // Milliseconds timestamp: 512969520900
+ 'x': function (date, options) {
+ var originalDate = options._originalDate || date;
+ return originalDate.getTime()
+ },
+
+ // AM, PM
+ 'A': function (date, options) {
+ return options.locale.localize.timeOfDay(date.getUTCHours(), {type: 'uppercase'})
+ },
+
+ // am, pm
+ 'a': function (date, options) {
+ return options.locale.localize.timeOfDay(date.getUTCHours(), {type: 'lowercase'})
+ },
+
+ // a.m., p.m.
+ 'aa': function (date, options) {
+ return options.locale.localize.timeOfDay(date.getUTCHours(), {type: 'long'})
+ }
+};
+
+function formatTimezone (offset, delimeter) {
+ delimeter = delimeter || '';
+ var sign = offset > 0 ? '-' : '+';
+ var absOffset = Math.abs(offset);
+ var hours = Math.floor(absOffset / 60);
+ var minutes = absOffset % 60;
+ return sign + addLeadingZeros(hours, 2) + delimeter + addLeadingZeros(minutes, 2)
+}
+
+function addLeadingZeros (number, targetLength) {
+ var output = Math.abs(number).toString();
+ while (output.length < targetLength) {
+ output = '0' + output;
+ }
+ return output
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function addUTCMinutes (dirtyDate, dirtyAmount, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var amount = Number(dirtyAmount);
+ date.setUTCMinutes(date.getUTCMinutes() + amount);
+ return date
+}
+
+var longFormattingTokensRegExp = /(\[[^[]*])|(\\)?(LTS|LT|LLLL|LLL|LL|L|llll|lll|ll|l)/g;
+var defaultFormattingTokensRegExp = /(\[[^[]*])|(\\)?(x|ss|s|mm|m|hh|h|do|dddd|ddd|dd|d|aa|a|ZZ|Z|YYYY|YY|X|Wo|WW|W|SSS|SS|S|Qo|Q|Mo|MMMM|MMM|MM|M|HH|H|GGGG|GG|E|Do|DDDo|DDDD|DDD|DD|D|A|.)/g;
+
+/**
+ * @name format
+ * @category Common Helpers
+ * @summary Format the date.
+ *
+ * @description
+ * Return the formatted date string in the given format.
+ *
+ * Accepted tokens:
+ * | Unit | Token | Result examples |
+ * |-------------------------|-------|----------------------------------|
+ * | Month | M | 1, 2, ..., 12 |
+ * | | Mo | 1st, 2nd, ..., 12th |
+ * | | MM | 01, 02, ..., 12 |
+ * | | MMM | Jan, Feb, ..., Dec |
+ * | | MMMM | January, February, ..., December |
+ * | Quarter | Q | 1, 2, 3, 4 |
+ * | | Qo | 1st, 2nd, 3rd, 4th |
+ * | Day of month | D | 1, 2, ..., 31 |
+ * | | Do | 1st, 2nd, ..., 31st |
+ * | | DD | 01, 02, ..., 31 |
+ * | Day of year | DDD | 1, 2, ..., 366 |
+ * | | DDDo | 1st, 2nd, ..., 366th |
+ * | | DDDD | 001, 002, ..., 366 |
+ * | Day of week | d | 0, 1, ..., 6 |
+ * | | do | 0th, 1st, ..., 6th |
+ * | | dd | Su, Mo, ..., Sa |
+ * | | ddd | Sun, Mon, ..., Sat |
+ * | | dddd | Sunday, Monday, ..., Saturday |
+ * | Day of ISO week | E | 1, 2, ..., 7 |
+ * | ISO week | W | 1, 2, ..., 53 |
+ * | | Wo | 1st, 2nd, ..., 53rd |
+ * | | WW | 01, 02, ..., 53 |
+ * | Year | YY | 00, 01, ..., 99 |
+ * | | YYYY | 1900, 1901, ..., 2099 |
+ * | ISO week-numbering year | GG | 00, 01, ..., 99 |
+ * | | GGGG | 1900, 1901, ..., 2099 |
+ * | AM/PM | A | AM, PM |
+ * | | a | am, pm |
+ * | | aa | a.m., p.m. |
+ * | Hour | H | 0, 1, ... 23 |
+ * | | HH | 00, 01, ... 23 |
+ * | | h | 1, 2, ..., 12 |
+ * | | hh | 01, 02, ..., 12 |
+ * | Minute | m | 0, 1, ..., 59 |
+ * | | mm | 00, 01, ..., 59 |
+ * | Second | s | 0, 1, ..., 59 |
+ * | | ss | 00, 01, ..., 59 |
+ * | 1/10 of second | S | 0, 1, ..., 9 |
+ * | 1/100 of second | SS | 00, 01, ..., 99 |
+ * | Millisecond | SSS | 000, 001, ..., 999 |
+ * | Timezone | Z | -01:00, +00:00, ... +12:00 |
+ * | | ZZ | -0100, +0000, ..., +1200 |
+ * | Seconds timestamp | X | 512969520 |
+ * | Milliseconds timestamp | x | 512969520900 |
+ * | Long format | LT | 05:30 a.m. |
+ * | | LTS | 05:30:15 a.m. |
+ * | | L | 07/02/1995 |
+ * | | l | 7/2/1995 |
+ * | | LL | July 2 1995 |
+ * | | ll | Jul 2 1995 |
+ * | | LLL | July 2 1995 05:30 a.m. |
+ * | | lll | Jul 2 1995 05:30 a.m. |
+ * | | LLLL | Sunday, July 2 1995 05:30 a.m. |
+ * | | llll | Sun, Jul 2 1995 05:30 a.m. |
+ *
+ * The characters wrapped in square brackets are escaped.
+ *
+ * The result may vary by locale.
+ *
+ * @param {Date|String|Number} date - the original date
+ * @param {String} format - the string of tokens
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+ * @returns {String} the formatted date string
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ * @throws {RangeError} `options.locale` must contain `localize` property
+ * @throws {RangeError} `options.locale` must contain `formatLong` property
+ *
+ * @example
+ * // Represent 11 February 2014 in middle-endian format:
+ * var result = format(
+ * new Date(2014, 1, 11),
+ * 'MM/DD/YYYY'
+ * )
+ * //=> '02/11/2014'
+ *
+ * @example
+ * // Represent 2 July 2014 in Esperanto:
+ * import { eoLocale } from 'date-fns/locale/eo'
+ * var result = format(
+ * new Date(2014, 6, 2),
+ * 'Do [de] MMMM YYYY',
+ * {locale: eoLocale}
+ * )
+ * //=> '2-a de julio 2014'
+ */
+function format (dirtyDate, dirtyFormatStr, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var formatStr = String(dirtyFormatStr);
+ var options = dirtyOptions || {};
+
+ var locale = options.locale || locale$1;
+
+ if (!locale.localize) {
+ throw new RangeError('locale must contain localize property')
+ }
+
+ if (!locale.formatLong) {
+ throw new RangeError('locale must contain formatLong property')
+ }
+
+ var localeFormatters = locale.formatters || {};
+ var formattingTokensRegExp = locale.formattingTokensRegExp || defaultFormattingTokensRegExp;
+ var formatLong = locale.formatLong;
+
+ var originalDate = toDate(dirtyDate, options);
+
+ if (!isValid(originalDate, options)) {
+ return 'Invalid Date'
+ }
+
+ // Convert the date in system timezone to the same date in UTC+00:00 timezone.
+ // This ensures that when UTC functions will be implemented, locales will be compatible with them.
+ // See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/376
+ var timezoneOffset = originalDate.getTimezoneOffset();
+ var utcDate = addUTCMinutes(originalDate, -timezoneOffset, options);
+
+ var formatterOptions = cloneObject(options);
+ formatterOptions.locale = locale;
+ formatterOptions.formatters = formatters;
+
+ // When UTC functions will be implemented, options._originalDate will likely be a part of public API.
+ // Right now, please don't use it in locales. If you have to use an original date,
+ // please restore it from `date`, adding a timezone offset to it.
+ formatterOptions._originalDate = originalDate;
+
+ var result = formatStr
+ .replace(longFormattingTokensRegExp, function (substring) {
+ if (substring[0] === '[') {
+ return substring
+ }
+
+ if (substring[0] === '\\') {
+ return cleanEscapedString(substring)
+ }
+
+ return formatLong(substring)
+ })
+ .replace(formattingTokensRegExp, function (substring) {
+ var formatter = localeFormatters[substring] || formatters[substring];
+
+ if (formatter) {
+ return formatter(utcDate, formatterOptions)
+ } else {
+ return cleanEscapedString(substring)
+ }
+ });
+
+ return result
+}
+
+function cleanEscapedString (input) {
+ if (input.match(/\[[\s\S]/)) {
+ return input.replace(/^\[|]$/g, '')
+ }
+ return input.replace(/\\/g, '')
+}
+
+/**
+ * @name subMinutes
+ * @category Minute Helpers
+ * @summary Subtract the specified number of minutes from the given date.
+ *
+ * @description
+ * Subtract the specified number of minutes from the given date.
+ *
+ * @param {Date|String|Number} date - the date to be changed
+ * @param {Number} amount - the amount of minutes to be subtracted
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Date} the new date with the mintues subtracted
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Subtract 30 minutes from 10 July 2014 12:00:00:
+ * var result = subMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 11:30:00
+ */
+function subMinutes (dirtyDate, dirtyAmount, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var amount = Number(dirtyAmount);
+ return addMinutes(dirtyDate, -amount, dirtyOptions)
+}
+
+/**
+ * @name isAfter
+ * @category Common Helpers
+ * @summary Is the first date after the second one?
+ *
+ * @description
+ * Is the first date after the second one?
+ *
+ * @param {Date|String|Number} date - the date that should be after the other one to return true
+ * @param {Date|String|Number} dateToCompare - the date to compare with
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Boolean} the first date is after the second date
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Is 10 July 1989 after 11 February 1987?
+ * var result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> true
+ */
+function isAfter (dirtyDate, dirtyDateToCompare, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var date = toDate(dirtyDate, dirtyOptions);
+ var dateToCompare = toDate(dirtyDateToCompare, dirtyOptions);
+ return date.getTime() > dateToCompare.getTime()
+}
+
+/**
+ * @name isBefore
+ * @category Common Helpers
+ * @summary Is the first date before the second one?
+ *
+ * @description
+ * Is the first date before the second one?
+ *
+ * @param {Date|String|Number} date - the date that should be before the other one to return true
+ * @param {Date|String|Number} dateToCompare - the date to compare with
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Boolean} the first date is before the second date
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Is 10 July 1989 before 11 February 1987?
+ * var result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> false
+ */
+function isBefore (dirtyDate, dirtyDateToCompare, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var date = toDate(dirtyDate, dirtyOptions);
+ var dateToCompare = toDate(dirtyDateToCompare, dirtyOptions);
+ return date.getTime() < dateToCompare.getTime()
+}
+
+/**
+ * @name isEqual
+ * @category Common Helpers
+ * @summary Are the given dates equal?
+ *
+ * @description
+ * Are the given dates equal?
+ *
+ * @param {Date|String|Number} dateLeft - the first date to compare
+ * @param {Date|String|Number} dateRight - the second date to compare
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @returns {Boolean} the dates are equal
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal?
+ * var result = isEqual(
+ * new Date(2014, 6, 2, 6, 30, 45, 0)
+ * new Date(2014, 6, 2, 6, 30, 45, 500)
+ * )
+ * //=> false
+ */
+function isEqual$1 (dirtyLeftDate, dirtyRightDate, dirtyOptions) {
+ if (arguments.length < 2) {
+ throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var dateLeft = toDate(dirtyLeftDate, dirtyOptions);
+ var dateRight = toDate(dirtyRightDate, dirtyOptions);
+ return dateLeft.getTime() === dateRight.getTime()
+}
+
+var patterns$1 = {
+ 'M': /^(1[0-2]|0?\d)/, // 0 to 12
+ 'D': /^(3[0-1]|[0-2]?\d)/, // 0 to 31
+ 'DDD': /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
+ 'W': /^(5[0-3]|[0-4]?\d)/, // 0 to 53
+ 'YYYY': /^(\d{1,4})/, // 0 to 9999
+ 'H': /^(2[0-3]|[0-1]?\d)/, // 0 to 23
+ 'm': /^([0-5]?\d)/, // 0 to 59
+ 'Z': /^([+-])(\d{2}):(\d{2})/,
+ 'ZZ': /^([+-])(\d{2})(\d{2})/,
+ singleDigit: /^(\d)/,
+ twoDigits: /^(\d{2})/,
+ threeDigits: /^(\d{3})/,
+ fourDigits: /^(\d{4})/,
+ anyDigits: /^(\d+)/
+};
+
+function parseDecimal$1 (matchResult) {
+ return parseInt(matchResult[1], 10)
+}
+
+var parsers = {
+ // Year: 00, 01, ..., 99
+ 'YY': {
+ unit: 'twoDigitYear',
+ match: patterns$1.twoDigits,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult)
+ }
+ },
+
+ // Year: 1900, 1901, ..., 2099
+ 'YYYY': {
+ unit: 'year',
+ match: patterns$1.YYYY,
+ parse: parseDecimal$1
+ },
+
+ // ISO week-numbering year: 00, 01, ..., 99
+ 'GG': {
+ unit: 'isoYear',
+ match: patterns$1.twoDigits,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) + 1900
+ }
+ },
+
+ // ISO week-numbering year: 1900, 1901, ..., 2099
+ 'GGGG': {
+ unit: 'isoYear',
+ match: patterns$1.YYYY,
+ parse: parseDecimal$1
+ },
+
+ // Quarter: 1, 2, 3, 4
+ 'Q': {
+ unit: 'quarter',
+ match: patterns$1.singleDigit,
+ parse: parseDecimal$1
+ },
+
+ // Ordinal quarter
+ 'Qo': {
+ unit: 'quarter',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'quarter'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'quarter'})
+ }
+ },
+
+ // Month: 1, 2, ..., 12
+ 'M': {
+ unit: 'month',
+ match: patterns$1.M,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) - 1
+ }
+ },
+
+ // Ordinal month
+ 'Mo': {
+ unit: 'month',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'month'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'month'}) - 1
+ }
+ },
+
+ // Month: 01, 02, ..., 12
+ 'MM': {
+ unit: 'month',
+ match: patterns$1.twoDigits,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) - 1
+ }
+ },
+
+ // Month: Jan, Feb, ..., Dec
+ 'MMM': {
+ unit: 'month',
+ match: function (string, options) {
+ return options.locale.match.months(string, {type: 'short'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.month(matchResult, {type: 'short'})
+ }
+ },
+
+ // Month: January, February, ..., December
+ 'MMMM': {
+ unit: 'month',
+ match: function (string, options) {
+ return options.locale.match.months(string, {type: 'long'}) ||
+ options.locale.match.months(string, {type: 'short'})
+ },
+ parse: function (matchResult, options) {
+ var parseResult = options.locale.match.month(matchResult, {type: 'long'});
+
+ if (parseResult == null) {
+ parseResult = options.locale.match.month(matchResult, {type: 'short'});
+ }
+
+ return parseResult
+ }
+ },
+
+ // ISO week: 1, 2, ..., 53
+ 'W': {
+ unit: 'isoWeek',
+ match: patterns$1.W,
+ parse: parseDecimal$1
+ },
+
+ // Ordinal ISO week
+ 'Wo': {
+ unit: 'isoWeek',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'isoWeek'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'isoWeek'})
+ }
+ },
+
+ // ISO week: 01, 02, ..., 53
+ 'WW': {
+ unit: 'isoWeek',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // Day of week: 0, 1, ..., 6
+ 'd': {
+ unit: 'dayOfWeek',
+ match: patterns$1.singleDigit,
+ parse: parseDecimal$1
+ },
+
+ // Ordinal day of week
+ 'do': {
+ unit: 'dayOfWeek',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'dayOfWeek'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'dayOfWeek'})
+ }
+ },
+
+ // Day of week: Su, Mo, ..., Sa
+ 'dd': {
+ unit: 'dayOfWeek',
+ match: function (string, options) {
+ return options.locale.match.weekdays(string, {type: 'narrow'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.weekday(matchResult, {type: 'narrow'})
+ }
+ },
+
+ // Day of week: Sun, Mon, ..., Sat
+ 'ddd': {
+ unit: 'dayOfWeek',
+ match: function (string, options) {
+ return options.locale.match.weekdays(string, {type: 'short'}) ||
+ options.locale.match.weekdays(string, {type: 'narrow'})
+ },
+ parse: function (matchResult, options) {
+ var parseResult = options.locale.match.weekday(matchResult, {type: 'short'});
+
+ if (parseResult == null) {
+ parseResult = options.locale.match.weekday(matchResult, {type: 'narrow'});
+ }
+
+ return parseResult
+ }
+ },
+
+ // Day of week: Sunday, Monday, ..., Saturday
+ 'dddd': {
+ unit: 'dayOfWeek',
+ match: function (string, options) {
+ return options.locale.match.weekdays(string, {type: 'long'}) ||
+ options.locale.match.weekdays(string, {type: 'short'}) ||
+ options.locale.match.weekdays(string, {type: 'narrow'})
+ },
+ parse: function (matchResult, options) {
+ var parseResult = options.locale.match.weekday(matchResult, {type: 'long'});
+
+ if (parseResult == null) {
+ parseResult = options.locale.match.weekday(matchResult, {type: 'short'});
+
+ if (parseResult == null) {
+ parseResult = options.locale.match.weekday(matchResult, {type: 'narrow'});
+ }
+ }
+
+ return parseResult
+ }
+ },
+
+ // Day of ISO week: 1, 2, ..., 7
+ 'E': {
+ unit: 'dayOfISOWeek',
+ match: patterns$1.singleDigit,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult)
+ }
+ },
+
+ // Day of month: 1, 2, ..., 31
+ 'D': {
+ unit: 'dayOfMonth',
+ match: patterns$1.D,
+ parse: parseDecimal$1
+ },
+
+ // Ordinal day of month
+ 'Do': {
+ unit: 'dayOfMonth',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'dayOfMonth'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'dayOfMonth'})
+ }
+ },
+
+ // Day of month: 01, 02, ..., 31
+ 'DD': {
+ unit: 'dayOfMonth',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // Day of year: 1, 2, ..., 366
+ 'DDD': {
+ unit: 'dayOfYear',
+ match: patterns$1.DDD,
+ parse: parseDecimal$1
+ },
+
+ // Ordinal day of year
+ 'DDDo': {
+ unit: 'dayOfYear',
+ match: function (string, options) {
+ return options.locale.match.ordinalNumbers(string, {unit: 'dayOfYear'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.ordinalNumber(matchResult, {unit: 'dayOfYear'})
+ }
+ },
+
+ // Day of year: 001, 002, ..., 366
+ 'DDDD': {
+ unit: 'dayOfYear',
+ match: patterns$1.threeDigits,
+ parse: parseDecimal$1
+ },
+
+ // AM, PM
+ 'A': {
+ unit: 'timeOfDay',
+ match: function (string, options) {
+ return options.locale.match.timesOfDay(string, {type: 'short'})
+ },
+ parse: function (matchResult, options) {
+ return options.locale.match.timeOfDay(matchResult, {type: 'short'})
+ }
+ },
+
+ // a.m., p.m.
+ 'aa': {
+ unit: 'timeOfDay',
+ match: function (string, options) {
+ return options.locale.match.timesOfDay(string, {type: 'long'}) ||
+ options.locale.match.timesOfDay(string, {type: 'short'})
+ },
+ parse: function (matchResult, options) {
+ var parseResult = options.locale.match.timeOfDay(matchResult, {type: 'long'});
+
+ if (parseResult == null) {
+ parseResult = options.locale.match.timeOfDay(matchResult, {type: 'short'});
+ }
+
+ return parseResult
+ }
+ },
+
+ // Hour: 0, 1, ... 23
+ 'H': {
+ unit: 'hours',
+ match: patterns$1.H,
+ parse: parseDecimal$1
+ },
+
+ // Hour: 00, 01, ..., 23
+ 'HH': {
+ unit: 'hours',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // Hour: 1, 2, ..., 12
+ 'h': {
+ unit: 'timeOfDayHours',
+ match: patterns$1.M,
+ parse: parseDecimal$1
+ },
+
+ // Hour: 01, 02, ..., 12
+ 'hh': {
+ unit: 'timeOfDayHours',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // Minute: 0, 1, ..., 59
+ 'm': {
+ unit: 'minutes',
+ match: patterns$1.m,
+ parse: parseDecimal$1
+ },
+
+ // Minute: 00, 01, ..., 59
+ 'mm': {
+ unit: 'minutes',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // Second: 0, 1, ..., 59
+ 's': {
+ unit: 'seconds',
+ match: patterns$1.m,
+ parse: parseDecimal$1
+ },
+
+ // Second: 00, 01, ..., 59
+ 'ss': {
+ unit: 'seconds',
+ match: patterns$1.twoDigits,
+ parse: parseDecimal$1
+ },
+
+ // 1/10 of second: 0, 1, ..., 9
+ 'S': {
+ unit: 'milliseconds',
+ match: patterns$1.singleDigit,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) * 100
+ }
+ },
+
+ // 1/100 of second: 00, 01, ..., 99
+ 'SS': {
+ unit: 'milliseconds',
+ match: patterns$1.twoDigits,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) * 10
+ }
+ },
+
+ // Millisecond: 000, 001, ..., 999
+ 'SSS': {
+ unit: 'milliseconds',
+ match: patterns$1.threeDigits,
+ parse: parseDecimal$1
+ },
+
+ // Timezone: -01:00, +00:00, ... +12:00
+ 'Z': {
+ unit: 'timezone',
+ match: patterns$1.Z,
+ parse: function (matchResult) {
+ var sign = matchResult[1];
+ var hours = parseInt(matchResult[2], 10);
+ var minutes = parseInt(matchResult[3], 10);
+ var absoluteOffset = hours * 60 + minutes;
+ return (sign === '+') ? absoluteOffset : -absoluteOffset
+ }
+ },
+
+ // Timezone: -0100, +0000, ... +1200
+ 'ZZ': {
+ unit: 'timezone',
+ match: patterns$1.ZZ,
+ parse: function (matchResult) {
+ var sign = matchResult[1];
+ var hours = parseInt(matchResult[2], 10);
+ var minutes = parseInt(matchResult[3], 10);
+ var absoluteOffset = hours * 60 + minutes;
+ return (sign === '+') ? absoluteOffset : -absoluteOffset
+ }
+ },
+
+ // Seconds timestamp: 512969520
+ 'X': {
+ unit: 'timestamp',
+ match: patterns$1.anyDigits,
+ parse: function (matchResult) {
+ return parseDecimal$1(matchResult) * 1000
+ }
+ },
+
+ // Milliseconds timestamp: 512969520900
+ 'x': {
+ unit: 'timestamp',
+ match: patterns$1.anyDigits,
+ parse: parseDecimal$1
+ }
+};
+
+parsers['a'] = parsers['A'];
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function setUTCDay (dirtyDate, dirtyDay, dirtyOptions) {
+ var options = dirtyOptions || {};
+ var locale = options.locale;
+ var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;
+ var defaultWeekStartsOn = localeWeekStartsOn === undefined ? 0 : Number(localeWeekStartsOn);
+ var weekStartsOn = options.weekStartsOn === undefined ? defaultWeekStartsOn : Number(options.weekStartsOn);
+
+ // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+ if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+ throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
+ }
+
+ var date = toDate(dirtyDate, dirtyOptions);
+ var day = Number(dirtyDay);
+
+ var currentDay = date.getUTCDay();
+
+ var remainder = day % 7;
+ var dayIndex = (remainder + 7) % 7;
+
+ var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;
+
+ date.setUTCDate(date.getUTCDate() + diff);
+ return date
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function setUTCISODay (dirtyDate, dirtyDay, dirtyOptions) {
+ var day = Number(dirtyDay);
+
+ if (day % 7 === 0) {
+ day = day - 7;
+ }
+
+ var weekStartsOn = 1;
+ var date = toDate(dirtyDate, dirtyOptions);
+ var currentDay = date.getUTCDay();
+
+ var remainder = day % 7;
+ var dayIndex = (remainder + 7) % 7;
+
+ var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;
+
+ date.setUTCDate(date.getUTCDate() + diff);
+ return date
+}
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function setUTCISOWeek (dirtyDate, dirtyISOWeek, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var isoWeek = Number(dirtyISOWeek);
+ var diff = getUTCISOWeek(date, dirtyOptions) - isoWeek;
+ date.setUTCDate(date.getUTCDate() - diff * 7);
+ return date
+}
+
+var MILLISECONDS_IN_DAY$3 = 86400000;
+
+// This function will be a part of public API when UTC function will be implemented.
+// See issue: https://github.com/date-fns/date-fns/issues/376
+function setUTCISOWeekYear (dirtyDate, dirtyISOYear, dirtyOptions) {
+ var date = toDate(dirtyDate, dirtyOptions);
+ var isoYear = Number(dirtyISOYear);
+ var dateStartOfYear = startOfUTCISOWeekYear(date, dirtyOptions);
+ var diff = Math.floor((date.getTime() - dateStartOfYear.getTime()) / MILLISECONDS_IN_DAY$3);
+ var fourthOfJanuary = new Date(0);
+ fourthOfJanuary.setUTCFullYear(isoYear, 0, 4);
+ fourthOfJanuary.setUTCHours(0, 0, 0, 0);
+ date = startOfUTCISOWeekYear(fourthOfJanuary, dirtyOptions);
+ date.setUTCDate(date.getUTCDate() + diff);
+ return date
+}
+
+var MILLISECONDS_IN_MINUTE$6 = 60000;
+
+function setTimeOfDay (hours, timeOfDay) {
+ var isAM = timeOfDay === 0;
+
+ if (isAM) {
+ if (hours === 12) {
+ return 0
+ }
+ } else {
+ if (hours !== 12) {
+ return 12 + hours
+ }
+ }
+
+ return hours
+}
+
+var units = {
+ twoDigitYear: {
+ priority: 10,
+ set: function (dateValues, value) {
+ var century = Math.floor(dateValues.date.getUTCFullYear() / 100);
+ var year = century * 100 + value;
+ dateValues.date.setUTCFullYear(year, 0, 1);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ year: {
+ priority: 10,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCFullYear(value, 0, 1);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ isoYear: {
+ priority: 10,
+ set: function (dateValues, value, options) {
+ dateValues.date = startOfUTCISOWeekYear(setUTCISOWeekYear(dateValues.date, value, options), options);
+ return dateValues
+ }
+ },
+
+ quarter: {
+ priority: 20,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCMonth((value - 1) * 3, 1);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ month: {
+ priority: 30,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCMonth(value, 1);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ isoWeek: {
+ priority: 40,
+ set: function (dateValues, value, options) {
+ dateValues.date = startOfUTCISOWeek(setUTCISOWeek(dateValues.date, value, options), options);
+ return dateValues
+ }
+ },
+
+ dayOfWeek: {
+ priority: 50,
+ set: function (dateValues, value, options) {
+ dateValues.date = setUTCDay(dateValues.date, value, options);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ dayOfISOWeek: {
+ priority: 50,
+ set: function (dateValues, value, options) {
+ dateValues.date = setUTCISODay(dateValues.date, value, options);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ dayOfMonth: {
+ priority: 50,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCDate(value);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ dayOfYear: {
+ priority: 50,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCMonth(0, value);
+ dateValues.date.setUTCHours(0, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ timeOfDay: {
+ priority: 60,
+ set: function (dateValues, value, options) {
+ dateValues.timeOfDay = value;
+ return dateValues
+ }
+ },
+
+ hours: {
+ priority: 70,
+ set: function (dateValues, value, options) {
+ dateValues.date.setUTCHours(value, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ timeOfDayHours: {
+ priority: 70,
+ set: function (dateValues, value, options) {
+ var timeOfDay = dateValues.timeOfDay;
+ if (timeOfDay != null) {
+ value = setTimeOfDay(value, timeOfDay);
+ }
+ dateValues.date.setUTCHours(value, 0, 0, 0);
+ return dateValues
+ }
+ },
+
+ minutes: {
+ priority: 80,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCMinutes(value, 0, 0);
+ return dateValues
+ }
+ },
+
+ seconds: {
+ priority: 90,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCSeconds(value, 0);
+ return dateValues
+ }
+ },
+
+ milliseconds: {
+ priority: 100,
+ set: function (dateValues, value) {
+ dateValues.date.setUTCMilliseconds(value);
+ return dateValues
+ }
+ },
+
+ timezone: {
+ priority: 110,
+ set: function (dateValues, value) {
+ dateValues.date = new Date(dateValues.date.getTime() - value * MILLISECONDS_IN_MINUTE$6);
+ return dateValues
+ }
+ },
+
+ timestamp: {
+ priority: 120,
+ set: function (dateValues, value) {
+ dateValues.date = new Date(value);
+ return dateValues
+ }
+ }
+};
+
+var TIMEZONE_UNIT_PRIORITY = 110;
+var MILLISECONDS_IN_MINUTE$7 = 60000;
+
+var longFormattingTokensRegExp$1 = /(\[[^[]*])|(\\)?(LTS|LT|LLLL|LLL|LL|L|llll|lll|ll|l)/g;
+var defaultParsingTokensRegExp = /(\[[^[]*])|(\\)?(x|ss|s|mm|m|hh|h|do|dddd|ddd|dd|d|aa|a|ZZ|Z|YYYY|YY|X|Wo|WW|W|SSS|SS|S|Qo|Q|Mo|MMMM|MMM|MM|M|HH|H|GGGG|GG|E|Do|DDDo|DDDD|DDD|DD|D|A|.)/g;
+
+/**
+ * @name parse
+ * @category Common Helpers
+ * @summary Parse the date.
+ *
+ * @description
+ * Return the date parsed from string using the given format.
+ *
+ * Accepted format tokens:
+ * | Unit | Priority | Token | Input examples |
+ * |-------------------------|----------|-------|----------------------------------|
+ * | Year | 10 | YY | 00, 01, ..., 99 |
+ * | | | YYYY | 1900, 1901, ..., 2099 |
+ * | ISO week-numbering year | 10 | GG | 00, 01, ..., 99 |
+ * | | | GGGG | 1900, 1901, ..., 2099 |
+ * | Quarter | 20 | Q | 1, 2, 3, 4 |
+ * | | | Qo | 1st, 2nd, 3rd, 4th |
+ * | Month | 30 | M | 1, 2, ..., 12 |
+ * | | | Mo | 1st, 2nd, ..., 12th |
+ * | | | MM | 01, 02, ..., 12 |
+ * | | | MMM | Jan, Feb, ..., Dec |
+ * | | | MMMM | January, February, ..., December |
+ * | ISO week | 40 | W | 1, 2, ..., 53 |
+ * | | | Wo | 1st, 2nd, ..., 53rd |
+ * | | | WW | 01, 02, ..., 53 |
+ * | Day of week | 50 | d | 0, 1, ..., 6 |
+ * | | | do | 0th, 1st, ..., 6th |
+ * | | | dd | Su, Mo, ..., Sa |
+ * | | | ddd | Sun, Mon, ..., Sat |
+ * | | | dddd | Sunday, Monday, ..., Saturday |
+ * | Day of ISO week | 50 | E | 1, 2, ..., 7 |
+ * | Day of month | 50 | D | 1, 2, ..., 31 |
+ * | | | Do | 1st, 2nd, ..., 31st |
+ * | | | DD | 01, 02, ..., 31 |
+ * | Day of year | 50 | DDD | 1, 2, ..., 366 |
+ * | | | DDDo | 1st, 2nd, ..., 366th |
+ * | | | DDDD | 001, 002, ..., 366 |
+ * | Time of day | 60 | A | AM, PM |
+ * | | | a | am, pm |
+ * | | | aa | a.m., p.m. |
+ * | Hour | 70 | H | 0, 1, ... 23 |
+ * | | | HH | 00, 01, ... 23 |
+ * | Time of day hour | 70 | h | 1, 2, ..., 12 |
+ * | | | hh | 01, 02, ..., 12 |
+ * | Minute | 80 | m | 0, 1, ..., 59 |
+ * | | | mm | 00, 01, ..., 59 |
+ * | Second | 90 | s | 0, 1, ..., 59 |
+ * | | | ss | 00, 01, ..., 59 |
+ * | 1/10 of second | 100 | S | 0, 1, ..., 9 |
+ * | 1/100 of second | 100 | SS | 00, 01, ..., 99 |
+ * | Millisecond | 100 | SSS | 000, 001, ..., 999 |
+ * | Timezone | 110 | Z | -01:00, +00:00, ... +12:00 |
+ * | | | ZZ | -0100, +0000, ..., +1200 |
+ * | Seconds timestamp | 120 | X | 512969520 |
+ * | Milliseconds timestamp | 120 | x | 512969520900 |
+ *
+ * Values will be assigned to the date in the ascending order of its unit's priority.
+ * Units of an equal priority overwrite each other in the order of appearance.
+ *
+ * If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),
+ * the values will be taken from 3rd argument `baseDate` which works as a context of parsing.
+ *
+ * `baseDate` must be passed for correct work of the function.
+ * If you're not sure which `baseDate` to supply, create a new instance of Date:
+ * `parse('02/11/2014', 'MM/DD/YYYY', new Date())`
+ * In this case parsing will be done in the context of the current date.
+ * If `baseDate` is `Invalid Date` or a value not convertible to valid `Date`,
+ * then `Invalid Date` will be returned.
+ *
+ * Also, `parse` unfolds long formats like those in [format]{@link https://date-fns.org/docs/format}:
+ * | Token | Input examples |
+ * |-------|--------------------------------|
+ * | LT | 05:30 a.m. |
+ * | LTS | 05:30:15 a.m. |
+ * | L | 07/02/1995 |
+ * | l | 7/2/1995 |
+ * | LL | July 2 1995 |
+ * | ll | Jul 2 1995 |
+ * | LLL | July 2 1995 05:30 a.m. |
+ * | lll | Jul 2 1995 05:30 a.m. |
+ * | LLLL | Sunday, July 2 1995 05:30 a.m. |
+ * | llll | Sun, Jul 2 1995 05:30 a.m. |
+ *
+ * The characters wrapped in square brackets in the format string are escaped.
+ *
+ * The result may vary by locale.
+ *
+ * If `formatString` matches with `dateString` but does not provides tokens, `baseDate` will be returned.
+ *
+ * If parsing failed, `Invalid Date` will be returned.
+ * Invalid Date is a Date, whose time value is NaN.
+ * Time value of Date: http://es5.github.io/#x15.9.1.1
+ *
+ * @param {String} dateString - the string to parse
+ * @param {String} formatString - the string of tokens
+ * @param {Date|String|Number} baseDate - the date to took the missing higher priority values from
+ * @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+ * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
+ * @returns {Date} the parsed date
+ * @throws {TypeError} 3 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
+ * @throws {RangeError} `options.locale` must contain `match` property
+ * @throws {RangeError} `options.locale` must contain `formatLong` property
+ *
+ * @example
+ * // Parse 11 February 2014 from middle-endian format:
+ * var result = parse(
+ * '02/11/2014',
+ * 'MM/DD/YYYY',
+ * new Date()
+ * )
+ * //=> Tue Feb 11 2014 00:00:00
+ *
+ * @example
+ * // Parse 28th of February in English locale in the context of 2010 year:
+ * import eoLocale from 'date-fns/locale/eo'
+ * var result = parse(
+ * '28-a de februaro',
+ * 'Do [de] MMMM',
+ * new Date(2010, 0, 1)
+ * {locale: eoLocale}
+ * )
+ * //=> Sun Feb 28 2010 00:00:00
+ */
+function parse (dirtyDateString, dirtyFormatString, dirtyBaseDate, dirtyOptions) {
+ if (arguments.length < 3) {
+ throw new TypeError('3 arguments required, but only ' + arguments.length + ' present')
+ }
+
+ var dateString = String(dirtyDateString);
+ var options = dirtyOptions || {};
+
+ var weekStartsOn = options.weekStartsOn === undefined ? 0 : Number(options.weekStartsOn);
+
+ // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+ if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+ throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
+ }
+
+ var locale = options.locale || locale$1;
+ var localeParsers = locale.parsers || {};
+ var localeUnits = locale.units || {};
+
+ if (!locale.match) {
+ throw new RangeError('locale must contain match property')
+ }
+
+ if (!locale.formatLong) {
+ throw new RangeError('locale must contain formatLong property')
+ }
+
+ var formatString = String(dirtyFormatString)
+ .replace(longFormattingTokensRegExp$1, function (substring) {
+ if (substring[0] === '[') {
+ return substring
+ }
+
+ if (substring[0] === '\\') {
+ return cleanEscapedString$1(substring)
+ }
+
+ return locale.formatLong(substring)
+ });
+
+ if (formatString === '') {
+ if (dateString === '') {
+ return toDate(dirtyBaseDate, options)
+ } else {
+ return new Date(NaN)
+ }
+ }
+
+ var subFnOptions = cloneObject(options);
+ subFnOptions.locale = locale;
+
+ var tokens = formatString.match(locale.parsingTokensRegExp || defaultParsingTokensRegExp);
+ var tokensLength = tokens.length;
+
+ // If timezone isn't specified, it will be set to the system timezone
+ var setters = [{
+ priority: TIMEZONE_UNIT_PRIORITY,
+ set: dateToSystemTimezone,
+ index: 0
+ }];
+
+ var i;
+ for (i = 0; i < tokensLength; i++) {
+ var token = tokens[i];
+ var parser = localeParsers[token] || parsers[token];
+ if (parser) {
+ var matchResult;
+
+ if (parser.match instanceof RegExp) {
+ matchResult = parser.match.exec(dateString);
+ } else {
+ matchResult = parser.match(dateString, subFnOptions);
+ }
+
+ if (!matchResult) {
+ return new Date(NaN)
+ }
+
+ var unitName = parser.unit;
+ var unit = localeUnits[unitName] || units[unitName];
+
+ setters.push({
+ priority: unit.priority,
+ set: unit.set,
+ value: parser.parse(matchResult, subFnOptions),
+ index: setters.length
+ });
+
+ var substring = matchResult[0];
+ dateString = dateString.slice(substring.length);
+ } else {
+ var head = tokens[i].match(/^\[.*]$/) ? tokens[i].replace(/^\[|]$/g, '') : tokens[i];
+ if (dateString.indexOf(head) === 0) {
+ dateString = dateString.slice(head.length);
+ } else {
+ return new Date(NaN)
+ }
+ }
+ }
+
+ var uniquePrioritySetters = setters
+ .map(function (setter) {
+ return setter.priority
+ })
+ .sort(function (a, b) {
+ return a - b
+ })
+ .filter(function (priority, index, array) {
+ return array.indexOf(priority) === index
+ })
+ .map(function (priority) {
+ return setters
+ .filter(function (setter) {
+ return setter.priority === priority
+ })
+ .reverse()
+ })
+ .map(function (setterArray) {
+ return setterArray[0]
+ });
+
+ var date = toDate(dirtyBaseDate, options);
+
+ if (isNaN(date)) {
+ return new Date(NaN)
+ }
+
+ // Convert the date in system timezone to the same date in UTC+00:00 timezone.
+ // This ensures that when UTC functions will be implemented, locales will be compatible with them.
+ // See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/37
+ var utcDate = subMinutes(date, date.getTimezoneOffset());
+
+ var dateValues = {date: utcDate};
+
+ var settersLength = uniquePrioritySetters.length;
+ for (i = 0; i < settersLength; i++) {
+ var setter = uniquePrioritySetters[i];
+ dateValues = setter.set(dateValues, setter.value, subFnOptions);
+ }
+
+ return dateValues.date
+}
+
+function dateToSystemTimezone (dateValues) {
+ var date = dateValues.date;
+ var time = date.getTime();
+
+ // Get the system timezone offset at (moment of time - offset)
+ var offset = date.getTimezoneOffset();
+
+ // Get the system timezone offset at the exact moment of time
+ offset = new Date(time + offset * MILLISECONDS_IN_MINUTE$7).getTimezoneOffset();
+
+ // Convert date in timezone "UTC+00:00" to the system timezone
+ dateValues.date = new Date(time + offset * MILLISECONDS_IN_MINUTE$7);
+
+ return dateValues
+}
+
+function cleanEscapedString$1 (input) {
+ if (input.match(/\[[\s\S]/)) {
+ return input.replace(/^\[|]$/g, '')
+ }
+ return input.replace(/\\/g, '')
+}
+
+// This file is generated automatically by `scripts/build/indices.js`. Please, don't change it.
+
+//
+
+/**
+ * Custom parse behavior on top of date-fns parse function.
+ */
+function parseDate$1 (date, format$$1) {
+ if (typeof date !== 'string') {
+ return isValid(date) ? date : null;
+ }
+
+ var parsed = parse(date, format$$1, new Date());
+
+ // if date is not valid or the formatted output after parsing does not match
+ // the string value passed in (avoids overflows)
+ if (!isValid(parsed) || format(parsed, format$$1) !== date) {
+ return null;
+ }
+
+ return parsed;
+}
+
+var afterValidator = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var targetValue = ref.targetValue;
+ var inclusion = ref.inclusion; if ( inclusion === void 0 ) inclusion = false;
+ var format$$1 = ref.format;
+
+ if (typeof format$$1 === 'undefined') {
+ format$$1 = inclusion;
+ inclusion = false;
+ }
+
+ value = parseDate$1(value, format$$1);
+ targetValue = parseDate$1(targetValue, format$$1);
+
+ // if either is not valid.
+ if (!value || !targetValue) {
+ return false;
+ }
+
+ return isAfter(value, targetValue) || (inclusion && isEqual$1(value, targetValue));
+};
+
+var options = {
+ hasTarget: true,
+ isDate: true
+};
+
+// required to convert from a list of array values to an object.
+var paramNames = ['targetValue', 'inclusion', 'format'];
+
+var after = {
+ validate: afterValidator,
+ options: options,
+ paramNames: paramNames
+};
+
+/**
+ * Some Alpha Regex helpers.
+ * https://github.com/chriso/validator.js/blob/master/src/lib/alpha.js
+ */
+
+var alpha = {
+ en: /^[A-Z]*$/i,
+ cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,
+ da: /^[A-ZÆØÅ]*$/i,
+ de: /^[A-ZÄÖÜß]*$/i,
+ es: /^[A-ZÁÉÍÑÓÚÜ]*$/i,
+ fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,
+ lt: /^[A-ZĄČĘĖĮŠŲŪŽ]*$/i,
+ nl: /^[A-ZÉËÏÓÖÜ]*$/i,
+ hu: /^[A-ZÁÉÍÓÖŐÚÜŰ]*$/i,
+ pl: /^[A-ZĄĆĘŚŁŃÓŻŹ]*$/i,
+ pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,
+ ru: /^[А-ЯЁ]*$/i,
+ sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,
+ sr: /^[A-ZČĆŽŠĐ]*$/i,
+ tr: /^[A-ZÇĞİıÖŞÜ]*$/i,
+ uk: /^[А-ЩЬЮЯЄІЇҐ]*$/i,
+ ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/
+};
+
+var alphaSpaces = {
+ en: /^[A-Z\s]*$/i,
+ cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ\s]*$/i,
+ da: /^[A-ZÆØÅ\s]*$/i,
+ de: /^[A-ZÄÖÜß\s]*$/i,
+ es: /^[A-ZÁÉÍÑÓÚÜ\s]*$/i,
+ fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ\s]*$/i,
+ lt: /^[A-ZĄČĘĖĮŠŲŪŽ\s]*$/i,
+ nl: /^[A-ZÉËÏÓÖÜ\s]*$/i,
+ hu: /^[A-ZÁÉÍÓÖŐÚÜŰ\s]*$/i,
+ pl: /^[A-ZĄĆĘŚŁŃÓŻŹ\s]*$/i,
+ pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ\s]*$/i,
+ ru: /^[А-ЯЁ\s]*$/i,
+ sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ\s]*$/i,
+ sr: /^[A-ZČĆŽŠĐ\s]*$/i,
+ tr: /^[A-ZÇĞİıÖŞÜ\s]*$/i,
+ uk: /^[А-ЩЬЮЯЄІЇҐ\s]*$/i,
+ ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ\s]*$/
+};
+
+var alphanumeric = {
+ en: /^[0-9A-Z]*$/i,
+ cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,
+ da: /^[0-9A-ZÆØÅ]$/i,
+ de: /^[0-9A-ZÄÖÜß]*$/i,
+ es: /^[0-9A-ZÁÉÍÑÓÚÜ]*$/i,
+ fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,
+ lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ]*$/i,
+ hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ]*$/i,
+ nl: /^[0-9A-ZÉËÏÓÖÜ]*$/i,
+ pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ]*$/i,
+ pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,
+ ru: /^[0-9А-ЯЁ]*$/i,
+ sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,
+ sr: /^[0-9A-ZČĆŽŠĐ]*$/i,
+ tr: /^[0-9A-ZÇĞİıÖŞÜ]*$/i,
+ uk: /^[0-9А-ЩЬЮЯЄІЇҐ]*$/i,
+ ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/
+};
+
+var alphaDash = {
+ en: /^[0-9A-Z_-]*$/i,
+ cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ_-]*$/i,
+ da: /^[0-9A-ZÆØÅ_-]*$/i,
+ de: /^[0-9A-ZÄÖÜß_-]*$/i,
+ es: /^[0-9A-ZÁÉÍÑÓÚÜ_-]*$/i,
+ fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ_-]*$/i,
+ lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ_-]*$/i,
+ nl: /^[0-9A-ZÉËÏÓÖÜ_-]*$/i,
+ hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ_-]*$/i,
+ pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ_-]*$/i,
+ pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ_-]*$/i,
+ ru: /^[0-9А-ЯЁ_-]*$/i,
+ sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ_-]*$/i,
+ sr: /^[0-9A-ZČĆŽŠĐ_-]*$/i,
+ tr: /^[0-9A-ZÇĞİıÖŞÜ_-]*$/i,
+ uk: /^[0-9А-ЩЬЮЯЄІЇҐ_-]*$/i,
+ ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ_-]*$/
+};
+
+var validate = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var locale = ref.locale;
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate(val, [locale]); });
+ }
+
+ // Match at least one locale.
+ if (! locale) {
+ return Object.keys(alpha).some(function (loc) { return alpha[loc].test(value); });
+ }
+
+ return (alpha[locale] || alpha.en).test(value);
+};
+
+var paramNames$1 = ['locale'];
+
+var alpha$1 = {
+ validate: validate,
+ paramNames: paramNames$1
+};
+
+var validate$1 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var locale = ref.locale;
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$1(val, [locale]); });
+ }
+
+ // Match at least one locale.
+ if (! locale) {
+ return Object.keys(alphaDash).some(function (loc) { return alphaDash[loc].test(value); });
+ }
+
+ return (alphaDash[locale] || alphaDash.en).test(value);
+};
+
+var paramNames$2 = ['locale'];
+
+var alpha_dash = {
+ validate: validate$1,
+ paramNames: paramNames$2
+};
+
+var validate$2 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var locale = ref.locale;
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$2(val, [locale]); });
+ }
+
+ // Match at least one locale.
+ if (! locale) {
+ return Object.keys(alphanumeric).some(function (loc) { return alphanumeric[loc].test(value); });
+ }
+
+ return (alphanumeric[locale] || alphanumeric.en).test(value);
+};
+
+var paramNames$3 = ['locale'];
+
+var alpha_num = {
+ validate: validate$2,
+ paramNames: paramNames$3
+};
+
+var validate$3 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var locale = ref.locale;
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$3(val, [locale]); });
+ }
+
+ // Match at least one locale.
+ if (! locale) {
+ return Object.keys(alphaSpaces).some(function (loc) { return alphaSpaces[loc].test(value); });
+ }
+
+ return (alphaSpaces[locale] || alphaSpaces.en).test(value);
+};
+
+var paramNames$4 = ['locale'];
+
+var alpha_spaces = {
+ validate: validate$3,
+ paramNames: paramNames$4
+};
+
+var validate$4 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var targetValue = ref.targetValue;
+ var inclusion = ref.inclusion; if ( inclusion === void 0 ) inclusion = false;
+ var format$$1 = ref.format;
+
+ if (typeof format$$1 === 'undefined') {
+ format$$1 = inclusion;
+ inclusion = false;
+ }
+
+ value = parseDate$1(value, format$$1);
+ targetValue = parseDate$1(targetValue, format$$1);
+
+ // if either is not valid.
+ if (!value || !targetValue) {
+ return false;
+ }
+
+ return isBefore(value, targetValue) || (inclusion && isEqual$1(value, targetValue));
+};
+
+var options$1 = {
+ hasTarget: true,
+ isDate: true
+};
+
+var paramNames$5 = ['targetValue', 'inclusion', 'format'];
+
+var before = {
+ validate: validate$4,
+ options: options$1,
+ paramNames: paramNames$5
+};
+
+var validate$5 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var min = ref.min;
+ var max = ref.max;
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$5(val, { min: min, max: max }); });
+ }
+
+ return Number(min) <= value && Number(max) >= value;
+};
+
+var paramNames$6 = ['min', 'max'];
+
+var between = {
+ validate: validate$5,
+ paramNames: paramNames$6
+};
+
+var validate$6 = function (value, ref) {
+ var targetValue = ref.targetValue;
+
+ return String(value) === String(targetValue);
+};
+var options$2 = {
+ hasTarget: true
+};
+
+var paramNames$7 = ['targetValue'];
+
+var confirmed = {
+ validate: validate$6,
+ options: options$2,
+ paramNames: paramNames$7
+};
+
+function unwrapExports (x) {
+ return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x;
+}
+
+function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var assertString_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+exports.default = assertString;
+function assertString(input) {
+ var isString = typeof input === 'string' || input instanceof String;
+
+ if (!isString) {
+ var invalidType = void 0;
+ if (input === null) {
+ invalidType = 'null';
+ } else {
+ invalidType = typeof input === 'undefined' ? 'undefined' : _typeof(input);
+ if (invalidType === 'object' && input.constructor && input.constructor.hasOwnProperty('name')) {
+ invalidType = input.constructor.name;
+ } else {
+ invalidType = 'a ' + invalidType;
+ }
+ }
+ throw new TypeError('Expected string but received ' + invalidType + '.');
+ }
+}
+module.exports = exports['default'];
+});
+
+unwrapExports(assertString_1);
+
+var isCreditCard_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = isCreditCard;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable max-len */
+var creditCard = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11}|6[27][0-9]{14})$/;
+/* eslint-enable max-len */
+
+function isCreditCard(str) {
+ (0, _assertString2.default)(str);
+ var sanitized = str.replace(/[- ]+/g, '');
+ if (!creditCard.test(sanitized)) {
+ return false;
+ }
+ var sum = 0;
+ var digit = void 0;
+ var tmpNum = void 0;
+ var shouldDouble = void 0;
+ for (var i = sanitized.length - 1; i >= 0; i--) {
+ digit = sanitized.substring(i, i + 1);
+ tmpNum = parseInt(digit, 10);
+ if (shouldDouble) {
+ tmpNum *= 2;
+ if (tmpNum >= 10) {
+ sum += tmpNum % 10 + 1;
+ } else {
+ sum += tmpNum;
+ }
+ } else {
+ sum += tmpNum;
+ }
+ shouldDouble = !shouldDouble;
+ }
+ return !!(sum % 10 === 0 ? sanitized : false);
+}
+module.exports = exports['default'];
+});
+
+var isCreditCard = unwrapExports(isCreditCard_1);
+
+var validate$7 = function (value) { return isCreditCard(String(value)); };
+
+var credit_card = {
+ validate: validate$7
+};
+
+var validate$8 = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var min$$1 = ref.min;
+ var max$$1 = ref.max;
+ var inclusivity = ref.inclusivity; if ( inclusivity === void 0 ) inclusivity = '()';
+ var format$$1 = ref.format;
+
+ if (typeof format$$1 === 'undefined') {
+ format$$1 = inclusivity;
+ inclusivity = '()';
+ }
+
+ var minDate = parseDate$1(String(min$$1), format$$1);
+ var maxDate = parseDate$1(String(max$$1), format$$1);
+ var dateVal = parseDate$1(String(value), format$$1);
+
+ if (!minDate || !maxDate || !dateVal) {
+ return false;
+ }
+
+ if (inclusivity === '()') {
+ return isAfter(dateVal, minDate) && isBefore(dateVal, maxDate);
+ }
+
+ if (inclusivity === '(]') {
+ return isAfter(dateVal, minDate) && (isEqual$1(dateVal, maxDate) || isBefore(dateVal, maxDate));
+ }
+
+ if (inclusivity === '[)') {
+ return isBefore(dateVal, maxDate) && (isEqual$1(dateVal, minDate) || isAfter(dateVal, minDate));
+ }
+
+ return isEqual$1(dateVal, maxDate) || isEqual$1(dateVal, minDate) ||
+ (isBefore(dateVal, maxDate) && isAfter(dateVal, minDate));
+};
+
+var options$3 = {
+ isDate: true
+};
+
+var paramNames$8 = ['min', 'max', 'inclusivity', 'format'];
+
+var date_between = {
+ validate: validate$8,
+ options: options$3,
+ paramNames: paramNames$8
+};
+
+var validate$9 = function (value, ref) {
+ var format = ref.format;
+
+ return !!parseDate$1(value, format);
+};
+
+var options$4 = {
+ isDate: true
+};
+
+var paramNames$9 = ['format'];
+
+var date_format = {
+ validate: validate$9,
+ options: options$4,
+ paramNames: paramNames$9
+};
+
+var validate$a = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var decimals = ref.decimals; if ( decimals === void 0 ) decimals = '*';
+ var separator = ref.separator; if ( separator === void 0 ) separator = '.';
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$a(val, { decimals: decimals, separator: separator }); });
+ }
+
+ if (value === null || value === undefined || value === '') {
+ return false;
+ }
+
+ // if is 0.
+ if (Number(decimals) === 0) {
+ return /^-?\d*$/.test(value);
+ }
+
+ var regexPart = decimals === '*' ? '+' : ("{1," + decimals + "}");
+ var regex = new RegExp(("^[-+]?\\d*(\\" + separator + "\\d" + regexPart + ")?$"));
+
+ if (! regex.test(value)) {
+ return false;
+ }
+
+ var parsedValue = parseFloat(value);
+
+ // eslint-disable-next-line
+ return parsedValue === parsedValue;
+};
+
+var paramNames$a = ['decimals', 'separator'];
+
+var decimal = {
+ validate: validate$a,
+ paramNames: paramNames$a
+};
+
+var validate$b = function (value, ref) {
+ var length = ref[0];
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$b(val, [length]); });
+ }
+ var strVal = String(value);
+
+ return /^[0-9]*$/.test(strVal) && strVal.length === Number(length);
+};
+
+var digits = {
+ validate: validate$b
+};
+
+var validateImage = function (file, width, height) {
+ var URL = window.URL || window.webkitURL;
+ return new Promise(function (resolve) {
+ var image = new Image();
+ image.onerror = function () { return resolve({ valid: false }); };
+ image.onload = function () { return resolve({
+ valid: image.width === Number(width) && image.height === Number(height)
+ }); };
+
+ image.src = URL.createObjectURL(file);
+ });
+};
+
+var validate$c = function (files, ref) {
+ var width = ref[0];
+ var height = ref[1];
+
+ var list = [];
+ for (var i = 0; i < files.length; i++) {
+ // if file is not an image, reject.
+ if (! /\.(jpg|svg|jpeg|png|bmp|gif)$/i.test(files[i].name)) {
+ return false;
+ }
+
+ list.push(files[i]);
+ }
+
+ return Promise.all(list.map(function (file) { return validateImage(file, width, height); }));
+};
+
+var dimensions = {
+ validate: validate$c
+};
+
+var merge_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = merge;
+function merge() {
+ var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+ var defaults = arguments[1];
+
+ for (var key in defaults) {
+ if (typeof obj[key] === 'undefined') {
+ obj[key] = defaults[key];
+ }
+ }
+ return obj;
+}
+module.exports = exports['default'];
+});
+
+unwrapExports(merge_1);
+
+var isByteLength_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+exports.default = isByteLength;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable prefer-rest-params */
+function isByteLength(str, options) {
+ (0, _assertString2.default)(str);
+ var min = void 0;
+ var max = void 0;
+ if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {
+ min = options.min || 0;
+ max = options.max;
+ } else {
+ // backwards compatibility: isByteLength(str, min [, max])
+ min = arguments[1];
+ max = arguments[2];
+ }
+ var len = encodeURI(str).split(/%..|./).length - 1;
+ return len >= min && (typeof max === 'undefined' || len <= max);
+}
+module.exports = exports['default'];
+});
+
+unwrapExports(isByteLength_1);
+
+var isFQDN_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = isFQDN;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+
+
+var _merge2 = _interopRequireDefault(merge_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var default_fqdn_options = {
+ require_tld: true,
+ allow_underscores: false,
+ allow_trailing_dot: false
+};
+
+function isFQDN(str, options) {
+ (0, _assertString2.default)(str);
+ options = (0, _merge2.default)(options, default_fqdn_options);
+
+ /* Remove the optional trailing dot before checking validity */
+ if (options.allow_trailing_dot && str[str.length - 1] === '.') {
+ str = str.substring(0, str.length - 1);
+ }
+ var parts = str.split('.');
+ for (var i = 0; i < parts.length; i++) {
+ if (parts[i].length > 63) {
+ return false;
+ }
+ }
+ if (options.require_tld) {
+ var tld = parts.pop();
+ if (!parts.length || !/^([a-z\u00a1-\uffff]{2,}|xn[a-z0-9-]{2,})$/i.test(tld)) {
+ return false;
+ }
+ // disallow spaces
+ if (/[\s\u2002-\u200B\u202F\u205F\u3000\uFEFF\uDB40\uDC20]/.test(tld)) {
+ return false;
+ }
+ }
+ for (var part, _i = 0; _i < parts.length; _i++) {
+ part = parts[_i];
+ if (options.allow_underscores) {
+ part = part.replace(/_/g, '');
+ }
+ if (!/^[a-z\u00a1-\uffff0-9-]+$/i.test(part)) {
+ return false;
+ }
+ // disallow full-width chars
+ if (/[\uff01-\uff5e]/.test(part)) {
+ return false;
+ }
+ if (part[0] === '-' || part[part.length - 1] === '-') {
+ return false;
+ }
+ }
+ return true;
+}
+module.exports = exports['default'];
+});
+
+unwrapExports(isFQDN_1);
+
+var isIP_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = isIP;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ipv4Maybe = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+var ipv6Block = /^[0-9A-F]{1,4}$/i;
+
+function isIP(str) {
+ var version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+ (0, _assertString2.default)(str);
+ version = String(version);
+ if (!version) {
+ return isIP(str, 4) || isIP(str, 6);
+ } else if (version === '4') {
+ if (!ipv4Maybe.test(str)) {
+ return false;
+ }
+ var parts = str.split('.').sort(function (a, b) {
+ return a - b;
+ });
+ return parts[3] <= 255;
+ } else if (version === '6') {
+ var blocks = str.split(':');
+ var foundOmissionBlock = false; // marker to indicate ::
+
+ // At least some OS accept the last 32 bits of an IPv6 address
+ // (i.e. 2 of the blocks) in IPv4 notation, and RFC 3493 says
+ // that '::ffff:a.b.c.d' is valid for IPv4-mapped IPv6 addresses,
+ // and '::a.b.c.d' is deprecated, but also valid.
+ var foundIPv4TransitionBlock = isIP(blocks[blocks.length - 1], 4);
+ var expectedNumberOfBlocks = foundIPv4TransitionBlock ? 7 : 8;
+
+ if (blocks.length > expectedNumberOfBlocks) {
+ return false;
+ }
+ // initial or final ::
+ if (str === '::') {
+ return true;
+ } else if (str.substr(0, 2) === '::') {
+ blocks.shift();
+ blocks.shift();
+ foundOmissionBlock = true;
+ } else if (str.substr(str.length - 2) === '::') {
+ blocks.pop();
+ blocks.pop();
+ foundOmissionBlock = true;
+ }
+
+ for (var i = 0; i < blocks.length; ++i) {
+ // test for a :: which can not be at the string start/end
+ // since those cases have been handled above
+ if (blocks[i] === '' && i > 0 && i < blocks.length - 1) {
+ if (foundOmissionBlock) {
+ return false; // multiple :: in address
+ }
+ foundOmissionBlock = true;
+ } else if (foundIPv4TransitionBlock && i === blocks.length - 1) ; else if (!ipv6Block.test(blocks[i])) {
+ return false;
+ }
+ }
+ if (foundOmissionBlock) {
+ return blocks.length >= 1;
+ }
+ return blocks.length === expectedNumberOfBlocks;
+ }
+ return false;
+}
+module.exports = exports['default'];
+});
+
+var isIP = unwrapExports(isIP_1);
+
+var isEmail_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = isEmail;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+
+
+var _merge2 = _interopRequireDefault(merge_1);
+
+
+
+var _isByteLength2 = _interopRequireDefault(isByteLength_1);
+
+
+
+var _isFQDN2 = _interopRequireDefault(isFQDN_1);
+
+
+
+var _isIP2 = _interopRequireDefault(isIP_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var default_email_options = {
+ allow_display_name: false,
+ require_display_name: false,
+ allow_utf8_local_part: true,
+ require_tld: true
+};
+
+/* eslint-disable max-len */
+/* eslint-disable no-control-regex */
+var displayName = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\,\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\s]*<(.+)>$/i;
+var emailUserPart = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~]+$/i;
+var gmailUserPart = /^[a-z\d]+$/;
+var quotedEmailUser = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f]))*$/i;
+var emailUserUtf8Part = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i;
+var quotedEmailUserUtf8 = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;
+/* eslint-enable max-len */
+/* eslint-enable no-control-regex */
+
+function isEmail(str, options) {
+ (0, _assertString2.default)(str);
+ options = (0, _merge2.default)(options, default_email_options);
+
+ if (options.require_display_name || options.allow_display_name) {
+ var display_email = str.match(displayName);
+ if (display_email) {
+ str = display_email[1];
+ } else if (options.require_display_name) {
+ return false;
+ }
+ }
+
+ var parts = str.split('@');
+ var domain = parts.pop();
+ var user = parts.join('@');
+
+ var lower_domain = domain.toLowerCase();
+
+ if (options.domain_specific_validation && (lower_domain === 'gmail.com' || lower_domain === 'googlemail.com')) {
+ /*
+ Previously we removed dots for gmail addresses before validating.
+ This was removed because it allows `multiple..dots@gmail.com`
+ to be reported as valid, but it is not.
+ Gmail only normalizes single dots, removing them from here is pointless,
+ should be done in normalizeEmail
+ */
+ user = user.toLowerCase();
+
+ // Removing sub-address from username before gmail validation
+ var username = user.split('+')[0];
+
+ // Dots are not included in gmail length restriction
+ if (!(0, _isByteLength2.default)(username.replace('.', ''), { min: 6, max: 30 })) {
+ return false;
+ }
+
+ var _user_parts = username.split('.');
+ for (var i = 0; i < _user_parts.length; i++) {
+ if (!gmailUserPart.test(_user_parts[i])) {
+ return false;
+ }
+ }
+ }
+
+ if (!(0, _isByteLength2.default)(user, { max: 64 }) || !(0, _isByteLength2.default)(domain, { max: 254 })) {
+ return false;
+ }
+
+ if (!(0, _isFQDN2.default)(domain, { require_tld: options.require_tld })) {
+ if (!options.allow_ip_domain) {
+ return false;
+ }
+
+ if (!(0, _isIP2.default)(domain)) {
+ if (!domain.startsWith('[') || !domain.endsWith(']')) {
+ return false;
+ }
+
+ var noBracketdomain = domain.substr(1, domain.length - 2);
+
+ if (noBracketdomain.length === 0 || !(0, _isIP2.default)(noBracketdomain)) {
+ return false;
+ }
+ }
+ }
+
+ if (user[0] === '"') {
+ user = user.slice(1, user.length - 1);
+ return options.allow_utf8_local_part ? quotedEmailUserUtf8.test(user) : quotedEmailUser.test(user);
+ }
+
+ var pattern = options.allow_utf8_local_part ? emailUserUtf8Part : emailUserPart;
+
+ var user_parts = user.split('.');
+ for (var _i = 0; _i < user_parts.length; _i++) {
+ if (!pattern.test(user_parts[_i])) {
+ return false;
+ }
+ }
+
+ return true;
+}
+module.exports = exports['default'];
+});
+
+var isEmail = unwrapExports(isEmail_1);
+
+var validate$d = function (value, options) {
+ if ( options === void 0 ) options = {};
+
+ if (options.multiple) {
+ value = value.split(',').map(function (emailStr) { return emailStr.trim(); });
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return isEmail(String(val), options); });
+ }
+
+ return isEmail(String(value), options);
+};
+
+var email = {
+ validate: validate$d
+};
+
+var validate$e = function (value, options) {
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$e(val, options); });
+ }
+
+ return toArray(options).some(function (item) {
+ // eslint-disable-next-line
+ return item == value;
+ });
+};
+
+var included = {
+ validate: validate$e
+};
+
+var validate$f = function () {
+ var args = [], len = arguments.length;
+ while ( len-- ) args[ len ] = arguments[ len ];
+
+ return !validate$e.apply(void 0, args);
+};
+
+var excluded = {
+ validate: validate$f
+};
+
+var validate$g = function (files, extensions) {
+ var regex = new RegExp((".(" + (extensions.join('|')) + ")$"), 'i');
+
+ return files.every(function (file) { return regex.test(file.name); });
+};
+
+var ext = {
+ validate: validate$g
+};
+
+var validate$h = function (files) { return files.every(function (file) { return /\.(jpg|svg|jpeg|png|bmp|gif)$/i.test(file.name); }); };
+
+var image = {
+ validate: validate$h
+};
+
+var validate$i = function (value) {
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return /^-?[0-9]+$/.test(String(val)); });
+ }
+
+ return /^-?[0-9]+$/.test(String(value));
+};
+
+var integer = {
+ validate: validate$i
+};
+
+var validate$j = function (value, ref) {
+ if ( ref === void 0 ) ref = {};
+ var version = ref.version; if ( version === void 0 ) version = 4;
+
+ if (isNullOrUndefined(value)) {
+ value = '';
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return isIP(val, version); });
+ }
+
+ return isIP(value, version);
+};
+
+var paramNames$b = ['version'];
+
+var ip = {
+ validate: validate$j,
+ paramNames: paramNames$b
+};
+
+var validate$k = function (value, ref) {
+ if ( ref === void 0 ) ref = [];
+ var other = ref[0];
+
+ return value === other;
+};
+
+var is = {
+ validate: validate$k
+};
+
+var validate$l = function (value, ref) {
+ if ( ref === void 0 ) ref = [];
+ var other = ref[0];
+
+ return value !== other;
+};
+
+var is_not = {
+ validate: validate$l
+};
+
+/**
+ * @param {Array|String} value
+ * @param {Number} length
+ * @param {Number} max
+ */
+var compare = function (value, length, max) {
+ if (max === undefined) {
+ return value.length === length;
+ }
+
+ // cast to number.
+ max = Number(max);
+
+ return value.length >= length && value.length <= max;
+};
+
+var validate$m = function (value, ref) {
+ var length = ref[0];
+ var max = ref[1]; if ( max === void 0 ) max = undefined;
+
+ length = Number(length);
+ if (value === undefined || value === null) {
+ return false;
+ }
+
+ if (typeof value === 'number') {
+ value = String(value);
+ }
+
+ if (!value.length) {
+ value = toArray(value);
+ }
+
+ return compare(value, length, max);
+};
+
+var length = {
+ validate: validate$m
+};
+
+var validate$n = function (value, ref) {
+ var length = ref[0];
+
+ if (value === undefined || value === null) {
+ return length >= 0;
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$n(val, [length]); });
+ }
+
+ return String(value).length <= length;
+};
+
+var max$1 = {
+ validate: validate$n
+};
+
+var validate$o = function (value, ref) {
+ var max = ref[0];
+
+ if (value === null || value === undefined || value === '') {
+ return false;
+ }
+
+ if (Array.isArray(value)) {
+ return value.length > 0 && value.every(function (val) { return validate$o(val, [max]); });
+ }
+
+ return Number(value) <= max;
+};
+
+var max_value = {
+ validate: validate$o
+};
+
+var validate$p = function (files, mimes) {
+ var regex = new RegExp(((mimes.join('|').replace('*', '.+')) + "$"), 'i');
+
+ return files.every(function (file) { return regex.test(file.type); });
+};
+
+var mimes = {
+ validate: validate$p
+};
+
+var validate$q = function (value, ref) {
+ var length = ref[0];
+
+ if (value === undefined || value === null) {
+ return false;
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$q(val, [length]); });
+ }
+
+ return String(value).length >= length;
+};
+
+var min$1 = {
+ validate: validate$q
+};
+
+var validate$r = function (value, ref) {
+ var min = ref[0];
+
+ if (value === null || value === undefined || value === '') {
+ return false;
+ }
+
+ if (Array.isArray(value)) {
+ return value.length > 0 && value.every(function (val) { return validate$r(val, [min]); });
+ }
+
+ return Number(value) >= min;
+};
+
+var min_value = {
+ validate: validate$r
+};
+
+var validate$s = function (value) {
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return /^[0-9]+$/.test(String(val)); });
+ }
+
+ return /^[0-9]+$/.test(String(value));
+};
+
+var numeric = {
+ validate: validate$s
+};
+
+var validate$t = function (value, ref) {
+ var expression = ref.expression;
+
+ if (typeof expression === 'string') {
+ expression = new RegExp(expression);
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return validate$t(val, { expression: expression }); });
+ }
+
+ return expression.test(String(value));
+};
+
+var paramNames$c = ['expression'];
+
+var regex = {
+ validate: validate$t,
+ paramNames: paramNames$c
+};
+
+var validate$u = function (value, ref) {
+ if ( ref === void 0 ) ref = [];
+ var invalidateFalse = ref[0]; if ( invalidateFalse === void 0 ) invalidateFalse = false;
+
+ if (isEmptyArray(value)) {
+ return false;
+ }
+
+ // incase a field considers `false` as an empty value like checkboxes.
+ if (value === false && invalidateFalse) {
+ return false;
+ }
+
+ if (value === undefined || value === null) {
+ return false;
+ }
+
+ return !!String(value).trim().length;
+};
+
+var required = {
+ validate: validate$u
+};
+
+var validate$v = function (files, ref) {
+ var size = ref[0];
+
+ if (isNaN(size)) {
+ return false;
+ }
+
+ var nSize = Number(size) * 1024;
+ for (var i = 0; i < files.length; i++) {
+ if (files[i].size > nSize) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+var size = {
+ validate: validate$v
+};
+
+var isURL_1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = isURL;
+
+
+
+var _assertString2 = _interopRequireDefault(assertString_1);
+
+
+
+var _isFQDN2 = _interopRequireDefault(isFQDN_1);
+
+
+
+var _isIP2 = _interopRequireDefault(isIP_1);
+
+
+
+var _merge2 = _interopRequireDefault(merge_1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var default_url_options = {
+ protocols: ['http', 'https', 'ftp'],
+ require_tld: true,
+ require_protocol: false,
+ require_host: true,
+ require_valid_protocol: true,
+ allow_underscores: false,
+ allow_trailing_dot: false,
+ allow_protocol_relative_urls: false
+};
+
+var wrapped_ipv6 = /^\[([^\]]+)\](?::([0-9]+))?$/;
+
+function isRegExp(obj) {
+ return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+function checkHost(host, matches) {
+ for (var i = 0; i < matches.length; i++) {
+ var match = matches[i];
+ if (host === match || isRegExp(match) && match.test(host)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+function isURL(url, options) {
+ (0, _assertString2.default)(url);
+ if (!url || url.length >= 2083 || /[\s<>]/.test(url)) {
+ return false;
+ }
+ if (url.indexOf('mailto:') === 0) {
+ return false;
+ }
+ options = (0, _merge2.default)(options, default_url_options);
+ var protocol = void 0,
+ auth = void 0,
+ host = void 0,
+ hostname = void 0,
+ port = void 0,
+ port_str = void 0,
+ split = void 0,
+ ipv6 = void 0;
+
+ split = url.split('#');
+ url = split.shift();
+
+ split = url.split('?');
+ url = split.shift();
+
+ split = url.split('://');
+ if (split.length > 1) {
+ protocol = split.shift().toLowerCase();
+ if (options.require_valid_protocol && options.protocols.indexOf(protocol) === -1) {
+ return false;
+ }
+ } else if (options.require_protocol) {
+ return false;
+ } else if (url.substr(0, 2) === '//') {
+ if (!options.allow_protocol_relative_urls) {
+ return false;
+ }
+ split[0] = url.substr(2);
+ }
+ url = split.join('://');
+
+ if (url === '') {
+ return false;
+ }
+
+ split = url.split('/');
+ url = split.shift();
+
+ if (url === '' && !options.require_host) {
+ return true;
+ }
+
+ split = url.split('@');
+ if (split.length > 1) {
+ auth = split.shift();
+ if (auth.indexOf(':') >= 0 && auth.split(':').length > 2) {
+ return false;
+ }
+ }
+ hostname = split.join('@');
+
+ port_str = null;
+ ipv6 = null;
+ var ipv6_match = hostname.match(wrapped_ipv6);
+ if (ipv6_match) {
+ host = '';
+ ipv6 = ipv6_match[1];
+ port_str = ipv6_match[2] || null;
+ } else {
+ split = hostname.split(':');
+ host = split.shift();
+ if (split.length) {
+ port_str = split.join(':');
+ }
+ }
+
+ if (port_str !== null) {
+ port = parseInt(port_str, 10);
+ if (!/^[0-9]+$/.test(port_str) || port <= 0 || port > 65535) {
+ return false;
+ }
+ }
+
+ if (!(0, _isIP2.default)(host) && !(0, _isFQDN2.default)(host, options) && (!ipv6 || !(0, _isIP2.default)(ipv6, 6))) {
+ return false;
+ }
+
+ host = host || ipv6;
+
+ if (options.host_whitelist && !checkHost(host, options.host_whitelist)) {
+ return false;
+ }
+ if (options.host_blacklist && checkHost(host, options.host_blacklist)) {
+ return false;
+ }
+
+ return true;
+}
+module.exports = exports['default'];
+});
+
+var isURL = unwrapExports(isURL_1);
+
+var validate$w = function (value, options) {
+ if ( options === void 0 ) options = {};
+
+ if (isNullOrUndefined(value)) {
+ value = '';
+ }
+
+ if (Array.isArray(value)) {
+ return value.every(function (val) { return isURL(val, options); });
+ }
+
+ return isURL(value, options);
+};
+
+var url = {
+ validate: validate$w
+};
+
+/* eslint-disable camelcase */
+
+var Rules = /*#__PURE__*/Object.freeze({
+ after: after,
+ alpha_dash: alpha_dash,
+ alpha_num: alpha_num,
+ alpha_spaces: alpha_spaces,
+ alpha: alpha$1,
+ before: before,
+ between: between,
+ confirmed: confirmed,
+ credit_card: credit_card,
+ date_between: date_between,
+ date_format: date_format,
+ decimal: decimal,
+ digits: digits,
+ dimensions: dimensions,
+ email: email,
+ ext: ext,
+ image: image,
+ included: included,
+ integer: integer,
+ length: length,
+ ip: ip,
+ is_not: is_not,
+ is: is,
+ max: max$1,
+ max_value: max_value,
+ mimes: mimes,
+ min: min$1,
+ min_value: min_value,
+ excluded: excluded,
+ numeric: numeric,
+ regex: regex,
+ required: required,
+ size: size,
+ url: url
+});
+
+var version = '2.1.4';
+
+Object.keys(Rules).forEach(function (rule) {
+ Validator.extend(rule, Rules[rule].validate, assign({}, Rules[rule].options, { paramNames: Rules[rule].paramNames }));
+});
+
+// Merge the english messages.
+Validator.localize({ en: locale });
+
+var install = VeeValidate$1.install;
+
+/* harmony default export */ __webpack_exports__["b"] = (VeeValidate$1);
+
+
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var disposed = false
+var normalizeComponent = __webpack_require__(0)
+/* script */
+var __vue_script__ = __webpack_require__(83)
+/* template */
+var __vue_template__ = __webpack_require__(84)
+/* template functional */
+var __vue_template_functional__ = false
+/* styles */
+var __vue_styles__ = null
+/* scopeId */
+var __vue_scopeId__ = null
+/* moduleIdentifier (server only) */
+var __vue_module_identifier__ = null
+var Component = normalizeComponent(
+ __vue_script__,
+ __vue_template__,
+ __vue_template_functional__,
+ __vue_styles__,
+ __vue_scopeId__,
+ __vue_module_identifier__
+)
+Component.options.__file = "resources/js/components/NavbarLink.vue"
+
+/* hot reload */
+if (false) {(function () {
+ var hotAPI = require("vue-hot-reload-api")
+ hotAPI.install(require("vue"), false)
+ if (!hotAPI.compatible) return
+ module.hot.accept()
+ if (!module.hot.data) {
+ hotAPI.createRecord("data-v-65583fd5", Component.options)
+ } else {
+ hotAPI.reload("data-v-65583fd5", Component.options)
+ }
+ module.hot.dispose(function (data) {
+ disposed = true
+ })
+})()}
+
+module.exports = Component.exports
+
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(21);
+module.exports = __webpack_require__(91);
+
+
+/***/ }),
+/* 21 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_es6_promise_auto__ = __webpack_require__(22);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_es6_promise_auto___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_es6_promise_auto__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_vue__ = __webpack_require__(6);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_vue__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__router__ = __webpack_require__(26);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__store__ = __webpack_require__(73);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_vee_validate__ = __webpack_require__(18);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_v_tooltip__ = __webpack_require__(75);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__validationRules__ = __webpack_require__(76);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__components_WorkshopGui__ = __webpack_require__(77);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__components_WorkshopGui___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7__components_WorkshopGui__);
+/**
+ * Import of Vue and Vue-Plugins
+ */
+
+
+
+
+
+
+
+/**
+ * Import of main components
+ */
+
+
+__WEBPACK_IMPORTED_MODULE_1_vue___default.a.use(__WEBPACK_IMPORTED_MODULE_4_vee_validate__["b" /* default */]);
+__WEBPACK_IMPORTED_MODULE_1_vue___default.a.use(__WEBPACK_IMPORTED_MODULE_5_v_tooltip__["a" /* default */]);
+
+var app = new __WEBPACK_IMPORTED_MODULE_1_vue___default.a({
+ el: '#workshop',
+ components: {
+ WorkshopGui: __WEBPACK_IMPORTED_MODULE_7__components_WorkshopGui___default.a
+ },
+ router: __WEBPACK_IMPORTED_MODULE_2__router__["a" /* default */],
+ store: __WEBPACK_IMPORTED_MODULE_3__store__["a" /* default */]
+});
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+// This file can be required in Browserify and Node.js for automatic polyfill
+// To use it: require('es6-promise/auto');
+
+module.exports = __webpack_require__(23).polyfill();
+
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(process, global) {/*!
+ * @overview es6-promise - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+ * @license Licensed under MIT license
+ * See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
+ * @version v4.2.5+7f2b526d
+ */
+
+(function (global, factory) {
+ true ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global.ES6Promise = factory());
+}(this, (function () { 'use strict';
+
+function objectOrFunction(x) {
+ var type = typeof x;
+ return x !== null && (type === 'object' || type === 'function');
+}
+
+function isFunction(x) {
+ return typeof x === 'function';
+}
+
+
+
+var _isArray = void 0;
+if (Array.isArray) {
+ _isArray = Array.isArray;
+} else {
+ _isArray = function (x) {
+ return Object.prototype.toString.call(x) === '[object Array]';
+ };
+}
+
+var isArray = _isArray;
+
+var len = 0;
+var vertxNext = void 0;
+var customSchedulerFn = void 0;
+
+var asap = function asap(callback, arg) {
+ queue[len] = callback;
+ queue[len + 1] = arg;
+ len += 2;
+ if (len === 2) {
+ // If len is 2, that means that we need to schedule an async flush.
+ // If additional callbacks are queued before the queue is flushed, they
+ // will be processed by this flush that we are scheduling.
+ if (customSchedulerFn) {
+ customSchedulerFn(flush);
+ } else {
+ scheduleFlush();
+ }
+ }
+};
+
+function setScheduler(scheduleFn) {
+ customSchedulerFn = scheduleFn;
+}
+
+function setAsap(asapFn) {
+ asap = asapFn;
+}
+
+var browserWindow = typeof window !== 'undefined' ? window : undefined;
+var browserGlobal = browserWindow || {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+
+// test for web worker but not in IE10
+var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+
+// node
+function useNextTick() {
+ // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+ // see https://github.com/cujojs/when/issues/410 for details
+ return function () {
+ return process.nextTick(flush);
+ };
+}
+
+// vertx
+function useVertxTimer() {
+ if (typeof vertxNext !== 'undefined') {
+ return function () {
+ vertxNext(flush);
+ };
+ }
+
+ return useSetTimeout();
+}
+
+function useMutationObserver() {
+ var iterations = 0;
+ var observer = new BrowserMutationObserver(flush);
+ var node = document.createTextNode('');
+ observer.observe(node, { characterData: true });
+
+ return function () {
+ node.data = iterations = ++iterations % 2;
+ };
+}
+
+// web worker
+function useMessageChannel() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = flush;
+ return function () {
+ return channel.port2.postMessage(0);
+ };
+}
+
+function useSetTimeout() {
+ // Store setTimeout reference so es6-promise will be unaffected by
+ // other code modifying setTimeout (like sinon.useFakeTimers())
+ var globalSetTimeout = setTimeout;
+ return function () {
+ return globalSetTimeout(flush, 1);
+ };
+}
+
+var queue = new Array(1000);
+function flush() {
+ for (var i = 0; i < len; i += 2) {
+ var callback = queue[i];
+ var arg = queue[i + 1];
+
+ callback(arg);
+
+ queue[i] = undefined;
+ queue[i + 1] = undefined;
+ }
+
+ len = 0;
+}
+
+function attemptVertx() {
+ try {
+ var vertx = Function('return this')().require('vertx');
+ vertxNext = vertx.runOnLoop || vertx.runOnContext;
+ return useVertxTimer();
+ } catch (e) {
+ return useSetTimeout();
+ }
+}
+
+var scheduleFlush = void 0;
+// Decide what async method to use to triggering processing of queued callbacks:
+if (isNode) {
+ scheduleFlush = useNextTick();
+} else if (BrowserMutationObserver) {
+ scheduleFlush = useMutationObserver();
+} else if (isWorker) {
+ scheduleFlush = useMessageChannel();
+} else if (browserWindow === undefined && "function" === 'function') {
+ scheduleFlush = attemptVertx();
+} else {
+ scheduleFlush = useSetTimeout();
+}
+
+function then(onFulfillment, onRejection) {
+ var parent = this;
+
+ var child = new this.constructor(noop);
+
+ if (child[PROMISE_ID] === undefined) {
+ makePromise(child);
+ }
+
+ var _state = parent._state;
+
+
+ if (_state) {
+ var callback = arguments[_state - 1];
+ asap(function () {
+ return invokeCallback(_state, child, callback, parent._result);
+ });
+ } else {
+ subscribe(parent, child, onFulfillment, onRejection);
+ }
+
+ return child;
+}
+
+/**
+ `Promise.resolve` returns a promise that will become resolved with the
+ passed `value`. It is shorthand for the following:
+
+ ```javascript
+ let promise = new Promise(function(resolve, reject){
+ resolve(1);
+ });
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ let promise = Promise.resolve(1);
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ @method resolve
+ @static
+ @param {Any} value value that the returned promise will be resolved with
+ Useful for tooling.
+ @return {Promise} a promise that will become fulfilled with the given
+ `value`
+*/
+function resolve$1(object) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ if (object && typeof object === 'object' && object.constructor === Constructor) {
+ return object;
+ }
+
+ var promise = new Constructor(noop);
+ resolve(promise, object);
+ return promise;
+}
+
+var PROMISE_ID = Math.random().toString(36).substring(2);
+
+function noop() {}
+
+var PENDING = void 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+
+var TRY_CATCH_ERROR = { error: null };
+
+function selfFulfillment() {
+ return new TypeError("You cannot resolve a promise with itself");
+}
+
+function cannotReturnOwn() {
+ return new TypeError('A promises callback cannot return that same promise.');
+}
+
+function getThen(promise) {
+ try {
+ return promise.then;
+ } catch (error) {
+ TRY_CATCH_ERROR.error = error;
+ return TRY_CATCH_ERROR;
+ }
+}
+
+function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
+ try {
+ then$$1.call(value, fulfillmentHandler, rejectionHandler);
+ } catch (e) {
+ return e;
+ }
+}
+
+function handleForeignThenable(promise, thenable, then$$1) {
+ asap(function (promise) {
+ var sealed = false;
+ var error = tryThen(then$$1, thenable, function (value) {
+ if (sealed) {
+ return;
+ }
+ sealed = true;
+ if (thenable !== value) {
+ resolve(promise, value);
+ } else {
+ fulfill(promise, value);
+ }
+ }, function (reason) {
+ if (sealed) {
+ return;
+ }
+ sealed = true;
+
+ reject(promise, reason);
+ }, 'Settle: ' + (promise._label || ' unknown promise'));
+
+ if (!sealed && error) {
+ sealed = true;
+ reject(promise, error);
+ }
+ }, promise);
+}
+
+function handleOwnThenable(promise, thenable) {
+ if (thenable._state === FULFILLED) {
+ fulfill(promise, thenable._result);
+ } else if (thenable._state === REJECTED) {
+ reject(promise, thenable._result);
+ } else {
+ subscribe(thenable, undefined, function (value) {
+ return resolve(promise, value);
+ }, function (reason) {
+ return reject(promise, reason);
+ });
+ }
+}
+
+function handleMaybeThenable(promise, maybeThenable, then$$1) {
+ if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
+ handleOwnThenable(promise, maybeThenable);
+ } else {
+ if (then$$1 === TRY_CATCH_ERROR) {
+ reject(promise, TRY_CATCH_ERROR.error);
+ TRY_CATCH_ERROR.error = null;
+ } else if (then$$1 === undefined) {
+ fulfill(promise, maybeThenable);
+ } else if (isFunction(then$$1)) {
+ handleForeignThenable(promise, maybeThenable, then$$1);
+ } else {
+ fulfill(promise, maybeThenable);
+ }
+ }
+}
+
+function resolve(promise, value) {
+ if (promise === value) {
+ reject(promise, selfFulfillment());
+ } else if (objectOrFunction(value)) {
+ handleMaybeThenable(promise, value, getThen(value));
+ } else {
+ fulfill(promise, value);
+ }
+}
+
+function publishRejection(promise) {
+ if (promise._onerror) {
+ promise._onerror(promise._result);
+ }
+
+ publish(promise);
+}
+
+function fulfill(promise, value) {
+ if (promise._state !== PENDING) {
+ return;
+ }
+
+ promise._result = value;
+ promise._state = FULFILLED;
+
+ if (promise._subscribers.length !== 0) {
+ asap(publish, promise);
+ }
+}
+
+function reject(promise, reason) {
+ if (promise._state !== PENDING) {
+ return;
+ }
+ promise._state = REJECTED;
+ promise._result = reason;
+
+ asap(publishRejection, promise);
+}
+
+function subscribe(parent, child, onFulfillment, onRejection) {
+ var _subscribers = parent._subscribers;
+ var length = _subscribers.length;
+
+
+ parent._onerror = null;
+
+ _subscribers[length] = child;
+ _subscribers[length + FULFILLED] = onFulfillment;
+ _subscribers[length + REJECTED] = onRejection;
+
+ if (length === 0 && parent._state) {
+ asap(publish, parent);
+ }
+}
+
+function publish(promise) {
+ var subscribers = promise._subscribers;
+ var settled = promise._state;
+
+ if (subscribers.length === 0) {
+ return;
+ }
+
+ var child = void 0,
+ callback = void 0,
+ detail = promise._result;
+
+ for (var i = 0; i < subscribers.length; i += 3) {
+ child = subscribers[i];
+ callback = subscribers[i + settled];
+
+ if (child) {
+ invokeCallback(settled, child, callback, detail);
+ } else {
+ callback(detail);
+ }
+ }
+
+ promise._subscribers.length = 0;
+}
+
+function tryCatch(callback, detail) {
+ try {
+ return callback(detail);
+ } catch (e) {
+ TRY_CATCH_ERROR.error = e;
+ return TRY_CATCH_ERROR;
+ }
+}
+
+function invokeCallback(settled, promise, callback, detail) {
+ var hasCallback = isFunction(callback),
+ value = void 0,
+ error = void 0,
+ succeeded = void 0,
+ failed = void 0;
+
+ if (hasCallback) {
+ value = tryCatch(callback, detail);
+
+ if (value === TRY_CATCH_ERROR) {
+ failed = true;
+ error = value.error;
+ value.error = null;
+ } else {
+ succeeded = true;
+ }
+
+ if (promise === value) {
+ reject(promise, cannotReturnOwn());
+ return;
+ }
+ } else {
+ value = detail;
+ succeeded = true;
+ }
+
+ if (promise._state !== PENDING) {
+ // noop
+ } else if (hasCallback && succeeded) {
+ resolve(promise, value);
+ } else if (failed) {
+ reject(promise, error);
+ } else if (settled === FULFILLED) {
+ fulfill(promise, value);
+ } else if (settled === REJECTED) {
+ reject(promise, value);
+ }
+}
+
+function initializePromise(promise, resolver) {
+ try {
+ resolver(function resolvePromise(value) {
+ resolve(promise, value);
+ }, function rejectPromise(reason) {
+ reject(promise, reason);
+ });
+ } catch (e) {
+ reject(promise, e);
+ }
+}
+
+var id = 0;
+function nextId() {
+ return id++;
+}
+
+function makePromise(promise) {
+ promise[PROMISE_ID] = id++;
+ promise._state = undefined;
+ promise._result = undefined;
+ promise._subscribers = [];
+}
+
+function validationError() {
+ return new Error('Array Methods must be provided an Array');
+}
+
+var Enumerator = function () {
+ function Enumerator(Constructor, input) {
+ this._instanceConstructor = Constructor;
+ this.promise = new Constructor(noop);
+
+ if (!this.promise[PROMISE_ID]) {
+ makePromise(this.promise);
+ }
+
+ if (isArray(input)) {
+ this.length = input.length;
+ this._remaining = input.length;
+
+ this._result = new Array(this.length);
+
+ if (this.length === 0) {
+ fulfill(this.promise, this._result);
+ } else {
+ this.length = this.length || 0;
+ this._enumerate(input);
+ if (this._remaining === 0) {
+ fulfill(this.promise, this._result);
+ }
+ }
+ } else {
+ reject(this.promise, validationError());
+ }
+ }
+
+ Enumerator.prototype._enumerate = function _enumerate(input) {
+ for (var i = 0; this._state === PENDING && i < input.length; i++) {
+ this._eachEntry(input[i], i);
+ }
+ };
+
+ Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
+ var c = this._instanceConstructor;
+ var resolve$$1 = c.resolve;
+
+
+ if (resolve$$1 === resolve$1) {
+ var _then = getThen(entry);
+
+ if (_then === then && entry._state !== PENDING) {
+ this._settledAt(entry._state, i, entry._result);
+ } else if (typeof _then !== 'function') {
+ this._remaining--;
+ this._result[i] = entry;
+ } else if (c === Promise$1) {
+ var promise = new c(noop);
+ handleMaybeThenable(promise, entry, _then);
+ this._willSettleAt(promise, i);
+ } else {
+ this._willSettleAt(new c(function (resolve$$1) {
+ return resolve$$1(entry);
+ }), i);
+ }
+ } else {
+ this._willSettleAt(resolve$$1(entry), i);
+ }
+ };
+
+ Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
+ var promise = this.promise;
+
+
+ if (promise._state === PENDING) {
+ this._remaining--;
+
+ if (state === REJECTED) {
+ reject(promise, value);
+ } else {
+ this._result[i] = value;
+ }
+ }
+
+ if (this._remaining === 0) {
+ fulfill(promise, this._result);
+ }
+ };
+
+ Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
+ var enumerator = this;
+
+ subscribe(promise, undefined, function (value) {
+ return enumerator._settledAt(FULFILLED, i, value);
+ }, function (reason) {
+ return enumerator._settledAt(REJECTED, i, reason);
+ });
+ };
+
+ return Enumerator;
+}();
+
+/**
+ `Promise.all` accepts an array of promises, and returns a new promise which
+ is fulfilled with an array of fulfillment values for the passed promises, or
+ rejected with the reason of the first passed promise to be rejected. It casts all
+ elements of the passed iterable to promises as it runs this algorithm.
+
+ Example:
+
+ ```javascript
+ let promise1 = resolve(1);
+ let promise2 = resolve(2);
+ let promise3 = resolve(3);
+ let promises = [ promise1, promise2, promise3 ];
+
+ Promise.all(promises).then(function(array){
+ // The array here would be [ 1, 2, 3 ];
+ });
+ ```
+
+ If any of the `promises` given to `all` are rejected, the first promise
+ that is rejected will be given as an argument to the returned promises's
+ rejection handler. For example:
+
+ Example:
+
+ ```javascript
+ let promise1 = resolve(1);
+ let promise2 = reject(new Error("2"));
+ let promise3 = reject(new Error("3"));
+ let promises = [ promise1, promise2, promise3 ];
+
+ Promise.all(promises).then(function(array){
+ // Code here never runs because there are rejected promises!
+ }, function(error) {
+ // error.message === "2"
+ });
+ ```
+
+ @method all
+ @static
+ @param {Array} entries array of promises
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled when all `promises` have been
+ fulfilled, or rejected if any of them become rejected.
+ @static
+*/
+function all(entries) {
+ return new Enumerator(this, entries).promise;
+}
+
+/**
+ `Promise.race` returns a new promise which is settled in the same way as the
+ first passed promise to settle.
+
+ Example:
+
+ ```javascript
+ let promise1 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ let promise2 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 2');
+ }, 100);
+ });
+
+ Promise.race([promise1, promise2]).then(function(result){
+ // result === 'promise 2' because it was resolved before promise1
+ // was resolved.
+ });
+ ```
+
+ `Promise.race` is deterministic in that only the state of the first
+ settled promise matters. For example, even if other promises given to the
+ `promises` array argument are resolved, but the first settled promise has
+ become rejected before the other promises became fulfilled, the returned
+ promise will become rejected:
+
+ ```javascript
+ let promise1 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ let promise2 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ reject(new Error('promise 2'));
+ }, 100);
+ });
+
+ Promise.race([promise1, promise2]).then(function(result){
+ // Code here never runs
+ }, function(reason){
+ // reason.message === 'promise 2' because promise 2 became rejected before
+ // promise 1 became fulfilled
+ });
+ ```
+
+ An example real-world use case is implementing timeouts:
+
+ ```javascript
+ Promise.race([ajax('foo.json'), timeout(5000)])
+ ```
+
+ @method race
+ @static
+ @param {Array} promises array of promises to observe
+ Useful for tooling.
+ @return {Promise} a promise which settles in the same way as the first passed
+ promise to settle.
+*/
+function race(entries) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ if (!isArray(entries)) {
+ return new Constructor(function (_, reject) {
+ return reject(new TypeError('You must pass an array to race.'));
+ });
+ } else {
+ return new Constructor(function (resolve, reject) {
+ var length = entries.length;
+ for (var i = 0; i < length; i++) {
+ Constructor.resolve(entries[i]).then(resolve, reject);
+ }
+ });
+ }
+}
+
+/**
+ `Promise.reject` returns a promise rejected with the passed `reason`.
+ It is shorthand for the following:
+
+ ```javascript
+ let promise = new Promise(function(resolve, reject){
+ reject(new Error('WHOOPS'));
+ });
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ let promise = Promise.reject(new Error('WHOOPS'));
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ @method reject
+ @static
+ @param {Any} reason value that the returned promise will be rejected with.
+ Useful for tooling.
+ @return {Promise} a promise rejected with the given `reason`.
+*/
+function reject$1(reason) {
+ /*jshint validthis:true */
+ var Constructor = this;
+ var promise = new Constructor(noop);
+ reject(promise, reason);
+ return promise;
+}
+
+function needsResolver() {
+ throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+}
+
+function needsNew() {
+ throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+}
+
+/**
+ Promise objects represent the eventual result of an asynchronous operation. The
+ primary way of interacting with a promise is through its `then` method, which
+ registers callbacks to receive either a promise's eventual value or the reason
+ why the promise cannot be fulfilled.
+
+ Terminology
+ -----------
+
+ - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+ - `thenable` is an object or function that defines a `then` method.
+ - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+ - `exception` is a value that is thrown using the throw statement.
+ - `reason` is a value that indicates why a promise was rejected.
+ - `settled` the final resting state of a promise, fulfilled or rejected.
+
+ A promise can be in one of three states: pending, fulfilled, or rejected.
+
+ Promises that are fulfilled have a fulfillment value and are in the fulfilled
+ state. Promises that are rejected have a rejection reason and are in the
+ rejected state. A fulfillment value is never a thenable.
+
+ Promises can also be said to *resolve* a value. If this value is also a
+ promise, then the original promise's settled state will match the value's
+ settled state. So a promise that *resolves* a promise that rejects will
+ itself reject, and a promise that *resolves* a promise that fulfills will
+ itself fulfill.
+
+
+ Basic Usage:
+ ------------
+
+ ```js
+ let promise = new Promise(function(resolve, reject) {
+ // on success
+ resolve(value);
+
+ // on failure
+ reject(reason);
+ });
+
+ promise.then(function(value) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Advanced Usage:
+ ---------------
+
+ Promises shine when abstracting away asynchronous interactions such as
+ `XMLHttpRequest`s.
+
+ ```js
+ function getJSON(url) {
+ return new Promise(function(resolve, reject){
+ let xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url);
+ xhr.onreadystatechange = handler;
+ xhr.responseType = 'json';
+ xhr.setRequestHeader('Accept', 'application/json');
+ xhr.send();
+
+ function handler() {
+ if (this.readyState === this.DONE) {
+ if (this.status === 200) {
+ resolve(this.response);
+ } else {
+ reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+ }
+ }
+ };
+ });
+ }
+
+ getJSON('/posts.json').then(function(json) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Unlike callbacks, promises are great composable primitives.
+
+ ```js
+ Promise.all([
+ getJSON('/posts'),
+ getJSON('/comments')
+ ]).then(function(values){
+ values[0] // => postsJSON
+ values[1] // => commentsJSON
+
+ return values;
+ });
+ ```
+
+ @class Promise
+ @param {Function} resolver
+ Useful for tooling.
+ @constructor
+*/
+
+var Promise$1 = function () {
+ function Promise(resolver) {
+ this[PROMISE_ID] = nextId();
+ this._result = this._state = undefined;
+ this._subscribers = [];
+
+ if (noop !== resolver) {
+ typeof resolver !== 'function' && needsResolver();
+ this instanceof Promise ? initializePromise(this, resolver) : needsNew();
+ }
+ }
+
+ /**
+ The primary way of interacting with a promise is through its `then` method,
+ which registers callbacks to receive either a promise's eventual value or the
+ reason why the promise cannot be fulfilled.
+ ```js
+ findUser().then(function(user){
+ // user is available
+ }, function(reason){
+ // user is unavailable, and you are given the reason why
+ });
+ ```
+ Chaining
+ --------
+ The return value of `then` is itself a promise. This second, 'downstream'
+ promise is resolved with the return value of the first promise's fulfillment
+ or rejection handler, or rejected if the handler throws an exception.
+ ```js
+ findUser().then(function (user) {
+ return user.name;
+ }, function (reason) {
+ return 'default name';
+ }).then(function (userName) {
+ // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+ // will be `'default name'`
+ });
+ findUser().then(function (user) {
+ throw new Error('Found user, but still unhappy');
+ }, function (reason) {
+ throw new Error('`findUser` rejected and we're unhappy');
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+ // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+ });
+ ```
+ If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+ ```js
+ findUser().then(function (user) {
+ throw new PedagogicalException('Upstream error');
+ }).then(function (value) {
+ // never reached
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // The `PedgagocialException` is propagated all the way down to here
+ });
+ ```
+ Assimilation
+ ------------
+ Sometimes the value you want to propagate to a downstream promise can only be
+ retrieved asynchronously. This can be achieved by returning a promise in the
+ fulfillment or rejection handler. The downstream promise will then be pending
+ until the returned promise is settled. This is called *assimilation*.
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // The user's comments are now available
+ });
+ ```
+ If the assimliated promise rejects, then the downstream promise will also reject.
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // If `findCommentsByAuthor` fulfills, we'll have the value here
+ }, function (reason) {
+ // If `findCommentsByAuthor` rejects, we'll have the reason here
+ });
+ ```
+ Simple Example
+ --------------
+ Synchronous Example
+ ```javascript
+ let result;
+ try {
+ result = findResult();
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+ Errback Example
+ ```js
+ findResult(function(result, err){
+ if (err) {
+ // failure
+ } else {
+ // success
+ }
+ });
+ ```
+ Promise Example;
+ ```javascript
+ findResult().then(function(result){
+ // success
+ }, function(reason){
+ // failure
+ });
+ ```
+ Advanced Example
+ --------------
+ Synchronous Example
+ ```javascript
+ let author, books;
+ try {
+ author = findAuthor();
+ books = findBooksByAuthor(author);
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+ Errback Example
+ ```js
+ function foundBooks(books) {
+ }
+ function failure(reason) {
+ }
+ findAuthor(function(author, err){
+ if (err) {
+ failure(err);
+ // failure
+ } else {
+ try {
+ findBoooksByAuthor(author, function(books, err) {
+ if (err) {
+ failure(err);
+ } else {
+ try {
+ foundBooks(books);
+ } catch(reason) {
+ failure(reason);
+ }
+ }
+ });
+ } catch(error) {
+ failure(err);
+ }
+ // success
+ }
+ });
+ ```
+ Promise Example;
+ ```javascript
+ findAuthor().
+ then(findBooksByAuthor).
+ then(function(books){
+ // found books
+ }).catch(function(reason){
+ // something went wrong
+ });
+ ```
+ @method then
+ @param {Function} onFulfilled
+ @param {Function} onRejected
+ Useful for tooling.
+ @return {Promise}
+ */
+
+ /**
+ `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+ as the catch block of a try/catch statement.
+ ```js
+ function findAuthor(){
+ throw new Error('couldn't find that author');
+ }
+ // synchronous
+ try {
+ findAuthor();
+ } catch(reason) {
+ // something went wrong
+ }
+ // async with promises
+ findAuthor().catch(function(reason){
+ // something went wrong
+ });
+ ```
+ @method catch
+ @param {Function} onRejection
+ Useful for tooling.
+ @return {Promise}
+ */
+
+
+ Promise.prototype.catch = function _catch(onRejection) {
+ return this.then(null, onRejection);
+ };
+
+ /**
+ `finally` will be invoked regardless of the promise's fate just as native
+ try/catch/finally behaves
+
+ Synchronous example:
+
+ ```js
+ findAuthor() {
+ if (Math.random() > 0.5) {
+ throw new Error();
+ }
+ return new Author();
+ }
+
+ try {
+ return findAuthor(); // succeed or fail
+ } catch(error) {
+ return findOtherAuther();
+ } finally {
+ // always runs
+ // doesn't affect the return value
+ }
+ ```
+
+ Asynchronous example:
+
+ ```js
+ findAuthor().catch(function(reason){
+ return findOtherAuther();
+ }).finally(function(){
+ // author was either found, or not
+ });
+ ```
+
+ @method finally
+ @param {Function} callback
+ @return {Promise}
+ */
+
+
+ Promise.prototype.finally = function _finally(callback) {
+ var promise = this;
+ var constructor = promise.constructor;
+
+ if (isFunction(callback)) {
+ return promise.then(function (value) {
+ return constructor.resolve(callback()).then(function () {
+ return value;
+ });
+ }, function (reason) {
+ return constructor.resolve(callback()).then(function () {
+ throw reason;
+ });
+ });
+ }
+
+ return promise.then(callback, callback);
+ };
+
+ return Promise;
+}();
+
+Promise$1.prototype.then = then;
+Promise$1.all = all;
+Promise$1.race = race;
+Promise$1.resolve = resolve$1;
+Promise$1.reject = reject$1;
+Promise$1._setScheduler = setScheduler;
+Promise$1._setAsap = setAsap;
+Promise$1._asap = asap;
+
+/*global self*/
+function polyfill() {
+ var local = void 0;
+
+ if (typeof global !== 'undefined') {
+ local = global;
+ } else if (typeof self !== 'undefined') {
+ local = self;
+ } else {
+ try {
+ local = Function('return this')();
+ } catch (e) {
+ throw new Error('polyfill failed because global object is unavailable in this environment');
+ }
+ }
+
+ var P = local.Promise;
+
+ if (P) {
+ var promiseToString = null;
+ try {
+ promiseToString = Object.prototype.toString.call(P.resolve());
+ } catch (e) {
+ // silently ignored
+ }
+
+ if (promiseToString === '[object Promise]' && !P.cast) {
+ return;
+ }
+ }
+
+ local.Promise = Promise$1;
+}
+
+// Strange compat..
+Promise$1.polyfill = polyfill;
+Promise$1.Promise = Promise$1;
+
+return Promise$1;
+
+})));
+
+
+
+//# sourceMappingURL=es6-promise.map
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9), __webpack_require__(2)))
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
+ (typeof self !== "undefined" && self) ||
+ window;
+var apply = Function.prototype.apply;
+
+// DOM APIs, for completeness
+
+exports.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
+};
+exports.setInterval = function() {
+ return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
+};
+exports.clearTimeout =
+exports.clearInterval = function(timeout) {
+ if (timeout) {
+ timeout.close();
+ }
+};
+
+function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+ this._clearFn.call(scope, this._id);
+};
+
+// Does not start the time, just sets up the members needed.
+exports.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+};
+
+exports.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+};
+
+exports._unrefActive = exports.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
+
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, msecs);
+ }
+};
+
+// setimmediate attaches itself to the global object
+__webpack_require__(25);
+// On some exotic environments, it's not clear which object `setimmediate` was
+// able to install onto. Search each possibility in the same order as the
+// `setimmediate` library.
+exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
+ (typeof global !== "undefined" && global.setImmediate) ||
+ (this && this.setImmediate);
+exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
+ (typeof global !== "undefined" && global.clearImmediate) ||
+ (this && this.clearImmediate);
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
+ "use strict";
+
+ if (global.setImmediate) {
+ return;
+ }
+
+ var nextHandle = 1; // Spec says greater than zero
+ var tasksByHandle = {};
+ var currentlyRunningATask = false;
+ var doc = global.document;
+ var registerImmediate;
+
+ function setImmediate(callback) {
+ // Callback can either be a function or a string
+ if (typeof callback !== "function") {
+ callback = new Function("" + callback);
+ }
+ // Copy function arguments
+ var args = new Array(arguments.length - 1);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i + 1];
+ }
+ // Store and register the task
+ var task = { callback: callback, args: args };
+ tasksByHandle[nextHandle] = task;
+ registerImmediate(nextHandle);
+ return nextHandle++;
+ }
+
+ function clearImmediate(handle) {
+ delete tasksByHandle[handle];
+ }
+
+ function run(task) {
+ var callback = task.callback;
+ var args = task.args;
+ switch (args.length) {
+ case 0:
+ callback();
+ break;
+ case 1:
+ callback(args[0]);
+ break;
+ case 2:
+ callback(args[0], args[1]);
+ break;
+ case 3:
+ callback(args[0], args[1], args[2]);
+ break;
+ default:
+ callback.apply(undefined, args);
+ break;
+ }
+ }
+
+ function runIfPresent(handle) {
+ // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+ // So if we're currently running a task, we'll need to delay this invocation.
+ if (currentlyRunningATask) {
+ // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+ // "too much recursion" error.
+ setTimeout(runIfPresent, 0, handle);
+ } else {
+ var task = tasksByHandle[handle];
+ if (task) {
+ currentlyRunningATask = true;
+ try {
+ run(task);
+ } finally {
+ clearImmediate(handle);
+ currentlyRunningATask = false;
+ }
+ }
+ }
+ }
+
+ function installNextTickImplementation() {
+ registerImmediate = function(handle) {
+ process.nextTick(function () { runIfPresent(handle); });
+ };
+ }
+
+ function canUsePostMessage() {
+ // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+ // where `global.postMessage` means something completely different and can't be used for this purpose.
+ if (global.postMessage && !global.importScripts) {
+ var postMessageIsAsynchronous = true;
+ var oldOnMessage = global.onmessage;
+ global.onmessage = function() {
+ postMessageIsAsynchronous = false;
+ };
+ global.postMessage("", "*");
+ global.onmessage = oldOnMessage;
+ return postMessageIsAsynchronous;
+ }
+ }
+
+ function installPostMessageImplementation() {
+ // Installs an event handler on `global` for the `message` event: see
+ // * https://developer.mozilla.org/en/DOM/window.postMessage
+ // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+
+ var messagePrefix = "setImmediate$" + Math.random() + "$";
+ var onGlobalMessage = function(event) {
+ if (event.source === global &&
+ typeof event.data === "string" &&
+ event.data.indexOf(messagePrefix) === 0) {
+ runIfPresent(+event.data.slice(messagePrefix.length));
+ }
+ };
+
+ if (global.addEventListener) {
+ global.addEventListener("message", onGlobalMessage, false);
+ } else {
+ global.attachEvent("onmessage", onGlobalMessage);
+ }
+
+ registerImmediate = function(handle) {
+ global.postMessage(messagePrefix + handle, "*");
+ };
+ }
+
+ function installMessageChannelImplementation() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = function(event) {
+ var handle = event.data;
+ runIfPresent(handle);
+ };
+
+ registerImmediate = function(handle) {
+ channel.port2.postMessage(handle);
+ };
+ }
+
+ function installReadyStateChangeImplementation() {
+ var html = doc.documentElement;
+ registerImmediate = function(handle) {
+ // Create a
\ No newline at end of file
diff --git a/resources/js/components/GlobalResources.vue b/resources/js/components/GlobalResources.vue
new file mode 100644
index 0000000..49276cf
--- /dev/null
+++ b/resources/js/components/GlobalResources.vue
@@ -0,0 +1,194 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/resources/js/components/Navbar.vue b/resources/js/components/Navbar.vue
index deea693..9092cde 100644
--- a/resources/js/components/Navbar.vue
+++ b/resources/js/components/Navbar.vue
@@ -2,10 +2,27 @@
-
-
{{ $store.state.appInfo.appName }}
+
+
+
+
+
+
+
+
+ Show project settings
+
+
+
+
@@ -25,19 +42,18 @@
-
+
+
-
+
-
+ Create
- Add Pattern
+
-
+
-
-
-
+
@@ -46,24 +62,22 @@
\ No newline at end of file
diff --git a/resources/js/components/Shortcuts.vue b/resources/js/components/Shortcuts.vue
new file mode 100644
index 0000000..c827852
--- /dev/null
+++ b/resources/js/components/Shortcuts.vue
@@ -0,0 +1,76 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/resources/js/components/StatusBar.vue b/resources/js/components/StatusBar.vue
index 2e6ba25..566992d 100644
--- a/resources/js/components/StatusBar.vue
+++ b/resources/js/components/StatusBar.vue
@@ -4,12 +4,12 @@
@@ -19,16 +19,25 @@
-
- Unreviewed
+
+
+ Review
+
+
-
- Rejected
+
+
+ Rejected
+
+
-
- Accepted
+
+
+ Accepted
+
+
@@ -49,7 +58,7 @@
data() {
return {
- isActive: false
+ 'dropdownName': 'StatusBar::dropdown-status'
}
},
@@ -58,11 +67,11 @@
return this.status === 'todo';
},
- isToCheck: function () {
+ isReview: function () {
return this.status === 'review';
},
- isAccepted: function () {
+ isDone: function () {
return this.status === 'done';
},
@@ -72,17 +81,29 @@
title: function () {
return `status: ${this.status}`;
+ },
+
+ isActive: function () {
+ return this.$store.getters.activeDropdown === this.dropdownName;
}
},
methods: {
+
+ /**
+ * Toggle the status dropdown.
+ */
+ toggleStatus: function () {
+ this.$store.dispatch('toggleDropdown', this.dropdownName);
+ },
+
/**
* Change the status of the Pattern.
* @param status
*/
changeStatus: function (status) {
this.$emit('update-status', status);
- this.isActive = false;
+ this.$store.dispatch('toggleDropdown', this.dropdownName);
}
}
}
diff --git a/resources/js/components/StatusList.vue b/resources/js/components/StatusList.vue
new file mode 100644
index 0000000..c3c1c1a
--- /dev/null
+++ b/resources/js/components/StatusList.vue
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ pattern }}
+
+
+
+
+
+
+
+ Nothing to review 😄
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/resources/js/components/TabBar.vue b/resources/js/components/TabBar.vue
new file mode 100644
index 0000000..b8e3173
--- /dev/null
+++ b/resources/js/components/TabBar.vue
@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/resources/js/components/UpdatePattern.vue b/resources/js/components/UpdatePattern.vue
index 313dafd..d7ce86b 100644
--- a/resources/js/components/UpdatePattern.vue
+++ b/resources/js/components/UpdatePattern.vue
@@ -1,7 +1,7 @@
-